import type { ContentBlock } from "@agentclientprotocol/sdk"; import * as directAcp from "./acpApi"; import type { AcpSessionInfo } from "./acpApi"; import * as sessionTracker from "./acpSessionTracker"; import { getCatalogEntry, resolveAgentProviderCatalogId, } from "@/features/providers/providerCatalog"; import { setActiveMessageId, clearActiveMessageId, } from "./acpNotificationHandler"; import { searchSessionsViaExports } from "./sessionSearch"; import { perfLog } from "@/shared/lib/perfLog"; export interface AcpProvider { id: string; label: string; } export interface AcpSendMessageOptions { systemPrompt?: string; assistantPrompt?: string; personaId?: string; personaName?: string; /** Image attachments as [base64Data, mimeType] pairs. */ images?: [string, string][]; } export interface AcpPrepareSessionOptions { personaId?: string; projectId?: string; } export interface AcpCreateSessionOptions extends AcpPrepareSessionOptions { modelId?: string | null; } /** Discover ACP providers installed on the system. */ export async function discoverAcpProviders(): Promise { const providers = await directAcp.listProviders(); return resolveProvidersCatalog(providers); } /** * Derive ACP providers from already-fetched inventory entries, * avoiding a duplicate `_goose/providers/list` RPC. */ export function discoverAcpProvidersFromEntries( entries: Array<{ providerId: string; providerName: string }>, ): AcpProvider[] { return resolveProvidersCatalog( directAcp.buildProviderListFromEntries(entries), ); } function resolveProvidersCatalog(providers: AcpProvider[]): AcpProvider[] { const seen = new Set(); return providers .map((provider) => { const catalogId = resolveAgentProviderCatalogId( provider.id, provider.label, ); if (!catalogId || seen.has(catalogId)) { return null; } seen.add(catalogId); return { id: catalogId, label: getCatalogEntry(catalogId)?.displayName ?? provider.label, }; }) .filter((provider): provider is AcpProvider => provider !== null); } /** Send a message to an ACP agent. Response streams via Tauri events. */ export async function acpSendMessage( sessionId: string, prompt: string, options: AcpSendMessageOptions = {}, ): Promise { const { systemPrompt, assistantPrompt, personaId, images } = options; const sid = sessionId.slice(0, 8); const tStart = performance.now(); const gooseSessionId = sessionTracker.getGooseSessionId(sessionId, personaId); if (!gooseSessionId) { throw new Error("Session not prepared. Call acpPrepareSession first."); } const content: ContentBlock[] = []; if (systemPrompt?.trim()) { content.push({ type: "text", text: systemPrompt, annotations: { audience: ["assistant"] }, }); } if (assistantPrompt?.trim()) { content.push({ type: "text", text: assistantPrompt, annotations: { audience: ["assistant"] }, }); } content.push({ type: "text", text: prompt }); if (images) { for (const [data, mimeType] of images) { content.push({ type: "image", data, mimeType } as ContentBlock); } } const messageId = crypto.randomUUID(); setActiveMessageId(gooseSessionId, messageId); perfLog( `[perf:send] ${sid} acpSendMessage → prompt(len=${prompt.length}, imgs=${images?.length ?? 0})`, ); const tPrompt = performance.now(); const meta: Record = {}; if (personaId) meta.personaId = personaId; try { await directAcp.prompt( gooseSessionId, content, Object.keys(meta).length > 0 ? meta : undefined, ); const tDone = performance.now(); perfLog( `[perf:send] ${sid} prompt() resolved in ${(tDone - tPrompt).toFixed(1)}ms (total acpSendMessage ${(tDone - tStart).toFixed(1)}ms)`, ); } finally { clearActiveMessageId(gooseSessionId); } } /** Prepare or warm an ACP session ahead of the first prompt. */ export async function acpPrepareSession( sessionId: string, providerId: string, workingDir: string, options: AcpPrepareSessionOptions = {}, ): Promise { const sid = sessionId.slice(0, 8); const t0 = performance.now(); perfLog( `[perf:prepare] ${sid} acpPrepareSession start (provider=${providerId})`, ); const gooseSessionId = await sessionTracker.prepareSession( sessionId, providerId, workingDir, options.personaId, options.projectId, ); perfLog( `[perf:prepare] ${sid} acpPrepareSession done in ${(performance.now() - t0).toFixed(1)}ms`, ); return gooseSessionId; } export async function acpCreateSession( providerId: string, workingDir: string, options: AcpCreateSessionOptions = {}, ): Promise<{ sessionId: string }> { const localSessionId = crypto.randomUUID(); const gooseSessionId = await acpPrepareSession( localSessionId, providerId, workingDir, options, ); sessionTracker.registerSession( gooseSessionId, gooseSessionId, providerId, workingDir, ); if (options.modelId) { await directAcp.setModel(gooseSessionId, options.modelId); } return { sessionId: gooseSessionId }; } export async function acpSetModel( sessionId: string, modelId: string, ): Promise { const gooseSessionId = sessionTracker.getGooseSessionId(sessionId); return directAcp.setModel(gooseSessionId ?? sessionId, modelId); } export type { AcpSessionInfo }; export interface AcpSessionSearchResult { sessionId: string; snippet: string; messageId: string; messageRole?: "user" | "assistant" | "system"; matchCount: number; } /** List all sessions known to the goose binary. */ export async function acpListSessions(): Promise { return directAcp.listSessions(); } export async function acpSearchSessions( query: string, sessionIds: string[], ): Promise { return searchSessionsViaExports(query, sessionIds); } /** * Load an existing session from the goose binary. * * This triggers message replay via SessionNotification events that the * notification handler picks up automatically. */ export async function acpLoadSession( sessionId: string, gooseSessionId: string, workingDir?: string, ): Promise { const effectiveWorkingDir = workingDir ?? "~/.goose/artifacts"; const sid = sessionId.slice(0, 8); const t0 = performance.now(); const rollbackSessionRegistration = sessionTracker.registerSession( sessionId, gooseSessionId, "goose", effectiveWorkingDir, ); try { perfLog(`[perf:load] ${sid} acpLoadSession → client.loadSession`); await directAcp.loadSession(gooseSessionId, effectiveWorkingDir); perfLog( `[perf:load] ${sid} client.loadSession resolved in ${(performance.now() - t0).toFixed(1)}ms`, ); } catch (error) { rollbackSessionRegistration(); throw error; } } /** Export a session as JSON via the goose binary. */ export async function acpExportSession(sessionId: string): Promise { return directAcp.exportSession(sessionId); } /** Import a session from JSON via the goose binary. Returns new session metadata. */ export async function acpImportSession(json: string): Promise { return directAcp.importSession(json); } /** Duplicate (fork) a session via the goose binary. Returns new session metadata. */ export async function acpDuplicateSession( sessionId: string, ): Promise { const gooseSessionId = sessionTracker.getGooseSessionId(sessionId) ?? sessionId; return directAcp.forkSession(gooseSessionId); } /** Cancel an in-progress ACP session so the backend stops streaming. */ export async function acpCancelSession( sessionId: string, personaId?: string, ): Promise { const gooseSessionId = sessionTracker.getGooseSessionId(sessionId, personaId); await directAcp.cancelSession(gooseSessionId ?? sessionId); return true; }