import { type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type AuthMethod, type CancelNotification, type CloseSessionRequest, type CloseSessionResponse, type ForkSessionRequest, type ForkSessionResponse, type InitializeRequest, type InitializeResponse, type ListSessionsRequest, type ListSessionsResponse, type LoadSessionRequest, type LoadSessionResponse, type McpServer, type NewSessionRequest, type NewSessionResponse, type PromptRequest, type PromptResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SessionInfo, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse, type SetSessionModelRequest, type SetSessionModelResponse, type SetSessionModeRequest, type SetSessionModeResponse, } from "@agentclientprotocol/sdk" import { InstallationVersion } from "@opencode-ai/core/installation/version" import * as Log from "@opencode-ai/core/util/log" import type { Message, OpencodeClient, SessionMessageResponse } from "@opencode-ai/sdk/v2" import { Context, Effect, Layer, ManagedRuntime } from "effect" import * as ACPError from "./error" import { buildConfigOptions, parseModelSelection } from "./config-option" import { promptContentToParts } from "./content" import { Directory } from "./directory" import { ACPEvent } from "./event" import { ACPSession } from "./session" import { UsageService } from "./usage" import { ACPProfile } from "./profile" import { ModelID, ProviderID } from "@/provider/schema" import { Provider } from "@/provider/provider" import type { Command } from "@/command" export const AuthMethodID = "opencode-login" const log = Log.create({ service: "acp-service" }) export type Error = ACPError.Error type ServiceConnection = Pick & Partial> export type Interface = { readonly initialize: (input: InitializeRequest) => Effect.Effect readonly authenticate: (input: AuthenticateRequest) => Effect.Effect readonly newSession: (input: NewSessionRequest) => Effect.Effect readonly loadSession: (input: LoadSessionRequest) => Effect.Effect readonly listSessions: (input: ListSessionsRequest) => Effect.Effect readonly resumeSession: (input: ResumeSessionRequest) => Effect.Effect readonly closeSession: (input: CloseSessionRequest) => Effect.Effect readonly forkSession: (input: ForkSessionRequest) => Effect.Effect readonly setSessionConfigOption: ( input: SetSessionConfigOptionRequest, ) => Effect.Effect readonly setSessionMode: (input: SetSessionModeRequest) => Effect.Effect readonly setSessionModel: (input: SetSessionModelRequest) => Effect.Effect readonly prompt: (input: PromptRequest) => Effect.Effect readonly cancel: (input: CancelNotification) => Effect.Effect } export class Service extends Context.Service()("@opencode/ACP/Service") {} export function make(input: { sdk: OpencodeClient connection?: ServiceConnection directory?: Directory.Interface session?: ACPSession.Interface usage?: UsageService.Interface eventSubscription?: (subscription: ACPEvent.Subscription) => void }): Interface { const session = input.session ?? makeSessionService() const directoryService = input.directory ?? makeDirectoryService(input.sdk) const registeredMcp = new Map>() const sessionSnapshots = new Map() const events = input.connection ? ACPEvent.start({ sdk: input.sdk, connection: input.connection, session }) : undefined if (events) input.eventSubscription?.(events) const initialize = Effect.fn("ACP.initialize")(function* (params: InitializeRequest) { const started = performance.now() const authMethod: AuthMethod = { description: "Run `opencode auth login` in the terminal", name: "Login with opencode", id: AuthMethodID, } if (params.clientCapabilities?._meta?.["terminal-auth"] === true) { authMethod._meta = { "terminal-auth": { command: "opencode", args: ["auth", "login"], label: "OpenCode Login", }, } } const response = { protocolVersion: 1, agentCapabilities: { loadSession: true, mcpCapabilities: { http: true, sse: true, }, promptCapabilities: { embeddedContext: true, image: true, }, sessionCapabilities: { close: {}, fork: {}, list: {}, resume: {}, }, }, authMethods: [authMethod], agentInfo: { name: "OpenCode", version: InstallationVersion, }, } ACPProfile.duration("acp.initialize", started) return response }) const authenticate = Effect.fn("ACP.authenticate")(function* (params: AuthenticateRequest) { if (params.methodId !== AuthMethodID) { return yield* new ACPError.UnknownAuthMethodError({ methodId: params.methodId }) } return {} }) const directorySnapshot = Effect.fn("ACP.directorySnapshot")(function* (cwd: string) { const started = performance.now() const snapshot = yield* directoryService.get(cwd) ACPProfile.duration("acp.directory.snapshot", started) return snapshot }) const configSnapshot = Effect.fn("ACP.configSnapshot")(function* (state: ACPSession.Info) { const snapshot = sessionSnapshots.get(state.id) if (snapshot) return snapshot const loaded = yield* directorySnapshot(state.cwd) sessionSnapshots.set(state.id, loaded) return loaded }) const newSession = Effect.fn("ACP.newSession")(function* (params: NewSessionRequest) { const started = performance.now() const snapshot = yield* directorySnapshot(params.cwd) const selected = selectDefaultModel(snapshot) const variant = selectVariant(snapshot, selected) const modeId = snapshot.availableModes.length > 0 ? snapshot.defaultModeID : undefined const created = yield* profiledRequest( "acp.newSession.session.create", () => input.sdk.session.create( { directory: params.cwd, ...(modeId ? { agent: modeId } : {}), model: { providerID: selected.providerID, id: selected.modelID, ...(variant ? { variant } : {}), }, }, { throwOnError: true }, ), "session", ) const state = yield* session.create({ id: created.id, cwd: params.cwd, mcpServers: params.mcpServers, model: selected, variant, modeId, }) sessionSnapshots.set(state.id, snapshot) yield* registerMcpServers(input.sdk, registeredMcp, params.cwd, state.id, params.mcpServers) yield* sendAvailableCommands(input.connection, state.id, snapshot) const response = { sessionId: state.id, configOptions: configOptions(snapshot, { model: state.model ?? selected, variant: state.variant, modeId: state.modeId, }), } ACPProfile.duration("acp.newSession", started) return response }) const loadSession = Effect.fn("ACP.loadSession")(function* (params: LoadSessionRequest) { const snapshot = yield* directorySnapshot(params.cwd) yield* request( () => input.sdk.session.get({ directory: params.cwd, sessionID: params.sessionId }, { throwOnError: true }), "session", ) const messages = yield* request( () => input.sdk.session.messages( { directory: params.cwd, sessionID: params.sessionId, limit: 100 }, { throwOnError: true }, ), "session", ) const restored = restoreFromMessages(messages.map((item) => item.info)) const model = restored.model ?? selectDefaultModel(snapshot) const state = yield* session.load({ id: params.sessionId, cwd: params.cwd, mcpServers: params.mcpServers, model, variant: restored.variant ?? selectVariant(snapshot, model), modeId: restored.modeId ?? (snapshot.availableModes.length > 0 ? snapshot.defaultModeID : undefined), }) sessionSnapshots.set(state.id, snapshot) yield* registerMcpServers(input.sdk, registeredMcp, params.cwd, state.id, params.mcpServers) yield* sendAvailableCommands(input.connection, state.id, snapshot) yield* replayMessages(events, messages) return { configOptions: configOptions(snapshot, { model: state.model ?? model, variant: state.variant, modeId: state.modeId, }), } }) const listSessions = Effect.fn("ACP.listSessions")(function* (params: ListSessionsRequest) { const cursor = params.cursor ? Number(params.cursor) : undefined const limit = 100 const sessions = yield* request( () => input.sdk.session.list( { ...(params.cwd ? { directory: params.cwd } : {}), roots: true, }, { throwOnError: true }, ), "session", ) const serverEntries = sessions.map( (item): SessionInfo => ({ sessionId: item.id, cwd: item.directory, title: item.title, updatedAt: new Date(item.time.updated).toISOString(), }), ) const liveEntries = (yield* session.list(params.cwd ?? undefined)) .filter((item) => !serverEntries.some((entry) => entry.sessionId === item.id)) .map( (item): SessionInfo => ({ sessionId: item.id, cwd: item.cwd, updatedAt: item.createdAt.toISOString(), }), ) const sorted = [...liveEntries, ...serverEntries].toSorted( (a, b) => new Date(b.updatedAt ?? 0).getTime() - new Date(a.updatedAt ?? 0).getTime(), ) const filtered = cursor === undefined || !Number.isFinite(cursor) ? sorted : sorted.filter((item) => new Date(item.updatedAt ?? 0).getTime() < cursor) const page = filtered.slice(0, limit) const last = page.at(-1) return { sessions: page, ...(filtered.length > limit && last ? { nextCursor: String(new Date(last.updatedAt ?? 0).getTime()) } : {}), } }) const resumeSession = Effect.fn("ACP.resumeSession")(function* (params: ResumeSessionRequest) { const snapshot = yield* directorySnapshot(params.cwd) yield* request( () => input.sdk.session.get({ directory: params.cwd, sessionID: params.sessionId }, { throwOnError: true }), "session", ) const messages = yield* request( () => input.sdk.session.messages( { directory: params.cwd, sessionID: params.sessionId, limit: 20 }, { throwOnError: true }, ), "session", ) const restored = restoreFromMessages(messages.map((item) => item.info)) const model = restored.model ?? selectDefaultModel(snapshot) const state = yield* session.load({ id: params.sessionId, cwd: params.cwd, mcpServers: params.mcpServers ?? [], model, variant: restored.variant ?? selectVariant(snapshot, model), modeId: restored.modeId ?? (snapshot.availableModes.length > 0 ? snapshot.defaultModeID : undefined), }) sessionSnapshots.set(state.id, snapshot) yield* registerMcpServers(input.sdk, registeredMcp, params.cwd, state.id, params.mcpServers ?? []) yield* sendAvailableCommands(input.connection, state.id, snapshot) yield* replayMessages(events, messages) return { configOptions: configOptions(snapshot, { model: state.model ?? model, variant: state.variant, modeId: state.modeId, }), } }) const closeSession = Effect.fn("ACP.closeSession")(function* (params: CloseSessionRequest) { const removed = yield* session.remove(params.sessionId) registeredMcp.delete(params.sessionId) sessionSnapshots.delete(params.sessionId) if (!removed) return {} yield* request( () => input.sdk.session.abort({ directory: removed.cwd, sessionID: params.sessionId }, { throwOnError: true }), "session", ).pipe( Effect.catch((error) => Effect.sync(() => { log.error("failed to abort session while closing ACP session", { error, sessionID: params.sessionId }) }), ), ) return {} }) const forkSession = Effect.fn("ACP.forkSession")(function* (params: ForkSessionRequest) { const snapshot = yield* directorySnapshot(params.cwd) const forked = yield* request( () => input.sdk.session.fork( { directory: params.cwd, sessionID: params.sessionId, }, { throwOnError: true }, ), "session", ) const messages = yield* request( () => input.sdk.session.messages({ directory: params.cwd, sessionID: forked.id, limit: 20 }, { throwOnError: true }), "session", ) const restored = restoreFromMessages(messages.map((item) => item.info)) const model = restored.model ?? selectDefaultModel(snapshot) const state = yield* session.load({ id: forked.id, cwd: params.cwd, mcpServers: params.mcpServers ?? [], model, variant: restored.variant ?? selectVariant(snapshot, model), modeId: restored.modeId ?? (snapshot.availableModes.length > 0 ? snapshot.defaultModeID : undefined), }) sessionSnapshots.set(state.id, snapshot) yield* registerMcpServers(input.sdk, registeredMcp, params.cwd, state.id, params.mcpServers ?? []) yield* sendAvailableCommands(input.connection, state.id, snapshot) yield* replayMessages(events, messages) return { sessionId: state.id, configOptions: configOptions(snapshot, { model: state.model ?? model, variant: state.variant, modeId: state.modeId, }), } }) const setSessionConfigOption = Effect.fn("ACP.setSessionConfigOption")(function* ( params: SetSessionConfigOptionRequest, ) { const current = yield* session.get(params.sessionId) const snapshot = yield* configSnapshot(current) if (typeof params.value !== "string") { return yield* new ACPError.InvalidConfigOptionError({ configId: params.configId }) } if (params.configId === "model") { const selected = yield* parseSelectedModel(snapshot, params.value) const variant = selected.variant ?? selectVariant(snapshot, selected.model) const state = yield* session .setVariant(params.sessionId, Directory.variants(snapshot, selected.model) ? variant : undefined) .pipe(Effect.andThen(session.setModel(params.sessionId, selected.model))) return { configOptions: configOptions(snapshot, { model: state.model ?? selected.model, variant: state.variant, modeId: state.modeId, }), } } if (params.configId === "effort") { const model = current.model ?? selectDefaultModel(snapshot) const variants = Directory.variants(snapshot, model) if (!variants || !Object.keys(variants).includes(params.value)) { return yield* new ACPError.InvalidEffortError({ effort: params.value }) } const state = yield* session.setVariant(params.sessionId, params.value) return { configOptions: configOptions(snapshot, { model: state.model ?? model, variant: state.variant, modeId: state.modeId, }), } } if (params.configId === "mode") { if (!snapshot.availableModes.some((mode) => mode.id === params.value)) { return yield* new ACPError.InvalidModeError({ mode: params.value }) } const state = yield* session.setMode(params.sessionId, params.value) return { configOptions: configOptions(snapshot, { model: state.model ?? selectDefaultModel(snapshot), variant: state.variant, modeId: state.modeId, }), } } return yield* new ACPError.InvalidConfigOptionError({ configId: params.configId }) }) const setSessionMode = Effect.fn("ACP.setSessionMode")(function* (params: SetSessionModeRequest) { const current = yield* session.get(params.sessionId) const snapshot = yield* configSnapshot(current) if (!snapshot.availableModes.some((mode) => mode.id === params.modeId)) { return yield* new ACPError.InvalidModeError({ mode: params.modeId }) } yield* session.setMode(params.sessionId, params.modeId) return {} }) const setSessionModel = Effect.fn("ACP.setSessionModel")(function* (params: SetSessionModelRequest) { const current = yield* session.get(params.sessionId) const snapshot = yield* configSnapshot(current) const selected = yield* parseSelectedModel(snapshot, params.modelId) yield* session .setVariant( params.sessionId, Directory.variants(snapshot, selected.model) ? (selected.variant ?? selectVariant(snapshot, selected.model)) : undefined, ) .pipe(Effect.andThen(session.setModel(params.sessionId, selected.model))) return {} }) return { initialize, authenticate, newSession, loadSession, listSessions, resumeSession, closeSession, forkSession, setSessionConfigOption, setSessionMode, setSessionModel, prompt: Effect.fn("ACP.prompt")(function* (params: PromptRequest) { const current = yield* session.get(params.sessionId) const snapshot = yield* directorySnapshot(current.cwd) const selected = current.model ?? selectDefaultModel(snapshot) if (!current.model) { yield* session.setModel(params.sessionId, selected) } const variant = current.variant ?? selectVariant(snapshot, selected) const modeId = current.modeId ?? (snapshot.availableModes.length > 0 ? snapshot.defaultModeID : undefined) const parts = promptContentToParts(params.prompt) const command = detectSlashCommand(parts) if (!command) { const response = yield* request( () => input.sdk.session.prompt( { sessionID: current.id, model: { providerID: selected.providerID, modelID: selected.modelID, }, ...(variant ? { variant } : {}), parts, ...(modeId ? { agent: modeId } : {}), directory: current.cwd, }, { throwOnError: true }, ), "session", ) yield* sendUsageUpdate(input.usage, input.sdk, input.connection, current.id, current.cwd) return promptResponse(response.info, params.messageId) } const known = snapshot.availableCommands.find((item) => item.name === command.name) if (known) { const response = yield* request( () => input.sdk.session.command( { sessionID: current.id, command: known.name, arguments: command.args, model: `${selected.providerID}/${selected.modelID}`, ...(variant ? { variant } : {}), ...(modeId ? { agent: modeId } : {}), directory: current.cwd, }, { throwOnError: true }, ), "session", ) yield* sendUsageUpdate(input.usage, input.sdk, input.connection, current.id, current.cwd) return promptResponse(response.info, params.messageId) } if (command.name === "compact") { yield* request( () => input.sdk.session.summarize( { sessionID: current.id, directory: current.cwd, providerID: selected.providerID, modelID: selected.modelID, }, { throwOnError: true }, ), "session", ) } yield* sendUsageUpdate(input.usage, input.sdk, input.connection, current.id, current.cwd) return promptResponse(undefined, params.messageId) }), cancel: Effect.fn("ACP.cancel")(function* (_input: CancelNotification) { return yield* new ACPError.UnsupportedOperationError({ method: "session/cancel" }) }), } } function makeSessionService() { return ManagedRuntime.make(ACPSession.defaultLayer).runSync( ACPSession.Service.use((service) => Effect.succeed(service)), ) } function makeDirectoryService(sdk: OpencodeClient) { return ManagedRuntime.make( Directory.layer.pipe( Layer.provide( Layer.succeed( Directory.Loader, Directory.Loader.of({ load: (directory) => request(() => loadDirectorySnapshot(sdk, directory), "directory"), }), ), ), ), ).runSync(Directory.Service.use((service) => Effect.succeed(service))) } function makeUsageService(sdk: OpencodeClient) { const limits = new Map>() const contextLimit: UsageService.Interface["contextLimit"] = Effect.fn("ACP.promptUsage.contextLimit")( function* (params) { const key = `${params.directory}\u0000${params.providerID}\u0000${params.modelID}` const current = limits.get(key) if (current) return yield* Effect.promise(() => current) const next = sdk.config .providers({ directory: params.directory }, { throwOnError: true }) .then((response) => { const providers = Object.fromEntries( (response.data?.providers ?? []).map((provider) => [provider.id, provider]), ) as Record return UsageService.findContextLimit(providers, params.providerID, params.modelID) }) .catch((error: unknown) => { log.error("failed to get providers for usage context limit", { error }) return undefined }) limits.set(key, next) return yield* Effect.promise(() => next) }, ) const sendUpdate: UsageService.Interface["sendUpdate"] = Effect.fn("ACP.promptUsage.sendUpdate")(function* (params) { const messages = yield* request( () => sdk.session.messages( { sessionID: params.sessionID, directory: params.directory, }, { throwOnError: true }, ), "session", ).pipe( Effect.map((messages) => messages as readonly UsageService.SessionMessage[]), Effect.catch((error) => Effect.sync(() => { log.error("failed to fetch messages for usage update", { error }) return undefined }), ), ) if (!messages) return const message = UsageService.latestAssistantMessage(messages) if (!message?.providerID || !message.modelID) return const size = yield* contextLimit({ directory: params.directory, providerID: ProviderID.make(message.providerID), modelID: ModelID.make(message.modelID), }) if (!size) return yield* Effect.promise(() => params.connection .sessionUpdate({ sessionId: params.sessionID, update: { sessionUpdate: "usage_update", used: message.tokens.input + message.tokens.cache.read, size, cost: { amount: UsageService.totalSessionCost(messages), currency: "USD" }, }, }) .catch((error) => { log.error("failed to send usage update", { error }) }), ) }) return UsageService.Service.of({ buildUsage: UsageService.buildUsage, latestAssistantMessage: UsageService.latestAssistantMessage, totalSessionCost: UsageService.totalSessionCost, contextLimit, sendUpdate, }) } function replayMessages(subscription: ACPEvent.Subscription | undefined, messages: SessionMessageResponse[]) { if (!subscription) return Effect.void return Effect.promise(async () => { for (const message of messages) { await subscription.replayMessage(message).catch((error: unknown) => { log.error("failed to replay ACP message", { error, messageID: message.info.id }) }) } }) } type ConfigState = { readonly model: Directory.DefaultModel readonly variant?: string readonly modeId?: string } type SdkResponse = { readonly data?: T readonly error?: unknown } type MessageInfo = { readonly role?: Message["role"] readonly model?: Extract["model"] readonly providerID?: Extract["providerID"] readonly modelID?: Extract["modelID"] readonly variant?: Extract["variant"] readonly mode?: Extract["mode"] readonly agent?: Message["agent"] } type AssistantInfo = UsageService.AssistantTokenCost | undefined function request(fn: () => Promise>, service?: string) { return Effect.tryPromise({ try: async () => { const result = await fn() if (isSdkResponse(result)) { if (result.error) throw result.error if (result.data !== undefined) return result.data } return result as T }, catch: (error) => fromUnknownError(error, service), }) } function profiledRequest(name: string, fn: () => Promise>, service?: string) { return request(() => ACPProfile.measure(name, fn), service) } async function loadDirectorySnapshot(sdk: OpencodeClient, directory: string) { return ACPProfile.measure("acp.directory.load", async () => { const [providersResponse, agentsResponse, commandsResponse, skillsResponse, configResponse] = await Promise.all([ ACPProfile.measure("acp.directory.provider.list", () => sdk.config.providers({ directory }, { throwOnError: true }), ), ACPProfile.measure("acp.directory.mode.defaultAgent.load", () => sdk.app.agents({ directory }, { throwOnError: true }), ), ACPProfile.measure("acp.directory.command.list", () => sdk.command.list({ directory }, { throwOnError: true })), ACPProfile.measure("acp.directory.skill.list", () => sdk.app.skills({ directory }, { throwOnError: true })), ACPProfile.measure("acp.directory.defaultModel.config", () => sdk.config.get({ directory }, { throwOnError: true }).catch(() => undefined), ), ]) const providersData = providersResponse.data! const agents = agentsResponse.data! const commandsData = commandsResponse.data! const skills = skillsResponse.data! const providers = Object.fromEntries(providersData.providers.map((provider) => [provider.id, provider])) as Record< ProviderID, Provider.Info > const defaultModelStarted = performance.now() const defaultModel = defaultModelFromConfig(configResponse?.data?.model, providers) ACPProfile.duration("acp.directory.defaultModel.resolve", defaultModelStarted, { configured: !!defaultModel }) const modes = agents .filter((agent) => agent.mode !== "subagent" && agent.hidden !== true) .map((agent) => ({ id: agent.name, name: agent.name, ...(agent.description ? { description: agent.description } : {}), })) const commands = [ ...commandsData, ...skills .filter((skill) => !commandsData.some((command) => command.name === skill.name)) .map((skill) => ({ name: skill.name, description: skill.description, source: "skill" as const, template: skill.content, hints: [], })), ] as Command.Info[] return Directory.build({ directory, providers, modes, defaultModeID: agents.find((agent) => agent.mode === "primary" && agent.hidden !== true)?.name ?? "build", commands: commands.toSorted((a, b) => a.name.localeCompare(b.name)), ...(defaultModel ? { defaultModel } : {}), }) }) } function defaultModelFromConfig( configuredModel: string | undefined, providers: Record, ): Directory.DefaultModel | undefined { const configured = configuredModel ? Provider.parseModel(configuredModel) : undefined if (configured && providers[configured.providerID]?.models[configured.modelID]) return configured // First-session ACP startup must not scan historical sessions just to infer // a default. Configured model, opencode provider, then sorted best model keep // the protocol response deterministic without extra session/message reads. const opencodeProvider = providers[ProviderID.make("opencode")] const opencodeModel = opencodeProvider ? Provider.sort(Object.values(opencodeProvider.models))[0] : undefined if (opencodeProvider && opencodeModel) return { providerID: opencodeProvider.id, modelID: opencodeModel.id } const best = Provider.sort(Object.values(providers).flatMap((provider) => Object.values(provider.models)))[0] if (best) return { providerID: best.providerID, modelID: best.id } if (configured) return configured } function selectDefaultModel(snapshot: Directory.Snapshot) { if (snapshot.defaultModel) return snapshot.defaultModel const model = snapshot.modelOptions[0] if (model) return { providerID: model.providerID, modelID: model.modelID } return { providerID: "unknown" as ProviderID, modelID: "unknown" as ModelID } } function detectSlashCommand(parts: ReturnType) { const text = parts .filter((part): part is Extract<(typeof parts)[number], { type: "text" }> => part.type === "text") .map((part) => part.text) .join("") .trim() if (!text.startsWith("/")) return const [name, ...rest] = text.slice(1).split(/\s+/) if (!name) return return { name, args: rest.join(" ").trim() } } function promptResponse(info: AssistantInfo, messageId: string | null | undefined): PromptResponse { return { stopReason: "end_turn", ...(info ? { usage: UsageService.buildUsage(info) } : {}), ...(messageId ? { userMessageId: messageId } : {}), _meta: {}, } } function sendUsageUpdate( usage: UsageService.Interface | undefined, sdk: OpencodeClient, connection: ServiceConnection | undefined, sessionID: string, directory: string, ) { if (!connection) return Effect.void return (usage ?? makeUsageService(sdk)).sendUpdate({ connection, sessionID, directory, }) } function selectVariant(snapshot: Directory.Snapshot, model: Directory.DefaultModel) { const variants = Directory.variants(snapshot, model) if (!variants) return if (variants.default) return "default" return Object.keys(variants)[0] } function configOptions(snapshot: Directory.Snapshot, session: ConfigState) { return buildConfigOptions({ providers: Object.values(snapshot.providers), currentModel: session.model, currentVariant: session.variant, modes: snapshot.availableModes, currentModeId: session.modeId, }) } function parseSelectedModel(snapshot: Directory.Snapshot, modelId: string) { const selected = parseModelSelection(modelId, Object.values(snapshot.providers)) const provider = snapshot.providers[ProviderID.make(selected.model.providerID)] const model = provider?.models[ModelID.make(selected.model.modelID)] if (!model) { return Effect.fail( new ACPError.InvalidModelError({ providerId: selected.model.providerID, modelId, }), ) } if (selected.variant && !model.variants?.[selected.variant]) { return Effect.fail(new ACPError.InvalidEffortError({ effort: selected.variant })) } return Effect.succeed({ model: { providerID: provider.id, modelID: model.id, }, variant: selected.variant, }) } function sendAvailableCommands( connection: Pick | undefined, sessionId: string, snapshot: Directory.Snapshot, ) { if (!connection) return Effect.void return Effect.sync(() => { setTimeout(() => { void connection.sessionUpdate({ sessionId, update: { sessionUpdate: "available_commands_update", availableCommands: snapshot.availableCommands.map((command) => ({ name: command.name, description: command.description ?? "", })), }, }) }, 0) }) } function registerMcpServers( sdk: OpencodeClient, registered: Map>, directory: string, sessionId: string, servers: readonly McpServer[], ) { const started = performance.now() const current = registered.get(sessionId) ?? new Set() registered.set(sessionId, current) const pending = new Set() return Effect.all( servers .map((server) => ({ server, config: mcpConfig(server) })) .filter((entry) => { const key = mcpRegistrationKey(entry.server.name, entry.config) if (current.has(key) || pending.has(key)) return false pending.add(key) return true }) .map((entry) => request( () => sdk.mcp.add( { directory, name: entry.server.name, config: entry.config, }, { throwOnError: true }, ), "mcp", ).pipe( Effect.tap(() => Effect.sync(() => current.add(mcpRegistrationKey(entry.server.name, entry.config)))), Effect.ignore, ), ), { concurrency: "unbounded" }, ).pipe( Effect.tap(() => Effect.sync(() => ACPProfile.duration("acp.mcp.register", started, { count: pending.size, }), ), ), Effect.asVoid, ) } function mcpRegistrationKey(name: string, config: ReturnType) { return `${name}:${stableStringify(config)}` } function mcpConfig(server: McpServer) { if ("type" in server) { return { type: "remote" as const, url: server.url, headers: Object.fromEntries(server.headers.map((header) => [header.name, header.value])), } } return { type: "local" as const, command: [server.command, ...server.args], environment: Object.fromEntries(server.env.map((entry) => [entry.name, entry.value])), } } function stableStringify(value: unknown): string { if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]` if (!value || typeof value !== "object") return JSON.stringify(value) return `{${Object.entries(value) .toSorted(([a], [b]) => a.localeCompare(b)) .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`) .join(",")}}` } function restoreFromMessages(messages: readonly MessageInfo[]) { const user = messages.findLast( (message) => message.role === "user" && message.model?.providerID && message.model.modelID, ) if (user?.model?.providerID && user.model.modelID) { return { model: { providerID: user.model.providerID as ProviderID, modelID: user.model.modelID as ModelID }, variant: user.model.variant, modeId: user.agent, } } const assistant = messages.findLast((message) => message.providerID && message.modelID) if (assistant?.providerID && assistant.modelID) { return { model: { providerID: assistant.providerID as ProviderID, modelID: assistant.modelID as ModelID }, variant: assistant.variant, modeId: assistant.mode ?? assistant.agent, } } return {} } function isSdkResponse(value: T | SdkResponse): value is SdkResponse { return typeof value === "object" && value !== null && ("data" in value || "error" in value) } function fromUnknownError(error: unknown, service?: string): Error { if (isACPError(error)) return error if (isAuthRequired(error)) { return new ACPError.AuthRequiredError({ providerId: findProviderID(error) }) } return new ACPError.ServiceFailureError({ safeMessage: "OpenCode service failure", service }) } function isACPError(error: unknown): error is Error { return ( typeof error === "object" && error !== null && "_tag" in error && typeof error._tag === "string" && error._tag.startsWith("ACP") ) } function isAuthRequired(value: unknown): boolean { if (typeof value !== "object" || value === null) return false if (value instanceof Error && (value.name === "ProviderAuthError" || value.name === "LoadAPIKeyError")) return true if ( value instanceof Error && (value.message.includes("ProviderAuthError") || value.message.includes("LoadAPIKeyError")) ) { return true } if ("name" in value && (value.name === "ProviderAuthError" || value.name === "LoadAPIKeyError")) return true if ("_tag" in value && (value._tag === "ProviderAuthError" || value._tag === "LoadAPIKeyError")) return true if ("error" in value && isAuthRequired(value.error)) return true if ("data" in value && isAuthRequired(value.data)) return true return false } function findProviderID(value: unknown): string | undefined { if (typeof value !== "object" || value === null) return if ("providerID" in value && typeof value.providerID === "string") return value.providerID if ("providerId" in value && typeof value.providerId === "string") return value.providerId if ("data" in value) return findProviderID(value.data) if ("error" in value) return findProviderID(value.error) }