diff --git a/packages/cli/src/acp/agent.ts b/packages/cli/src/acp/agent.ts index d2f56c9b435..a2f152f085b 100644 --- a/packages/cli/src/acp/agent.ts +++ b/packages/cli/src/acp/agent.ts @@ -35,7 +35,8 @@ export const connect = Effect.fnUntraced(function* (client: OpenCodeClient, stre Deferred.await(ready).pipe(Effect.flatMap((service) => call(service, ctx))), Effect.catchTags({ ACPCatalogLoadError: (error) => ACPClient.classify(error.cause), - ACPCatalogNotReadyError: (error) => Effect.die(error), + ACPCatalogNotReadyError: (error) => + Effect.fail(new ACPError.ServiceFailureError({ safeMessage: error.message, errorName: "CatalogNotReady" })), }), Effect.mapError((error) => (error instanceof RequestError ? error : ACPError.toRequestError(error))), Effect.tapCauseIf(Cause.hasDies, (cause) => Effect.logError("ACP request failed", cause)), diff --git a/packages/cli/src/acp/catalog.ts b/packages/cli/src/acp/catalog.ts index b63603e2121..10f4f25228f 100644 --- a/packages/cli/src/acp/catalog.ts +++ b/packages/cli/src/acp/catalog.ts @@ -3,7 +3,7 @@ import type { Agent } from "@opencode/schema/agent" import type { Command } from "@opencode/schema/command" import type { Model } from "@opencode/schema/model" import { FSUtil } from "@opencode/util/fs-util" -import { Context, Deferred, Effect, Exit, Schedule, Schema, Semaphore, Stream, SubscriptionRef } from "effect" +import { Cause, Context, Deferred, Effect, Exit, Schedule, Schema, Semaphore, Stream, SubscriptionRef } from "effect" import type { ConfigOptionProvider } from "./config-option" export const builtinCommands = new Map([ @@ -90,7 +90,9 @@ export const make = Effect.fnUntraced(function* (client: OpenCodeClient) { { discard: true }, ) }), - Effect.ignore, + Effect.catchCause((cause) => + Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logWarning("ACP catalog event stream failed", cause), + ), Effect.ensuring(Deferred.succeed(connected, undefined)), Effect.forkScoped, ) diff --git a/packages/cli/src/acp/client.ts b/packages/cli/src/acp/client.ts index afa03ad1796..f79a34bb13d 100644 --- a/packages/cli/src/acp/client.ts +++ b/packages/cli/src/acp/client.ts @@ -1,5 +1,5 @@ import { ClientError } from "@opencode/client/effect" -import { InvalidRequestError, SessionNotFoundError } from "@opencode/protocol/errors" +import { InvalidCursorError, InvalidRequestError, SessionNotFoundError } from "@opencode/protocol/errors" import { Session } from "@opencode/schema/session" import { Effect, Schema } from "effect" import { HttpClientError } from "effect/unstable/http" @@ -16,6 +16,8 @@ export function classify(error: unknown): Effect.Effect { return Effect.fail(new ACPError.SessionNotFoundError({ sessionId: error.sessionID })) if (error instanceof InvalidRequestError) return Effect.fail(new ACPError.InvalidRequestError({ message: error.message, field: error.field })) + if (error instanceof InvalidCursorError) + return Effect.fail(new ACPError.InvalidRequestError({ message: error.message, field: "cursor" })) return Effect.die(error) } diff --git a/packages/cli/src/acp/permission.ts b/packages/cli/src/acp/permission.ts index e4db96c1a88..087b8c1eaef 100644 --- a/packages/cli/src/acp/permission.ts +++ b/packages/cli/src/acp/permission.ts @@ -24,6 +24,7 @@ type Input = { readonly cwd: string readonly tool?: Tool readonly child?: ACPTranslate.ChildSession + readonly settled: Effect.Effect } const options: PermissionOption[] = [ @@ -37,7 +38,13 @@ const decodeFiles = Schema.decodeUnknownOption(Schema.Array(FileDiff.Info)) export const reply = Effect.fn("cli.acp.permission.reply")(function* (input: Input, cancelled: Effect.Effect) { yield* Effect.uninterruptibleMask((restore) => // The race starts racers in order and stops once one is done, so an earlier cancel never starts the ask. - restore(cancelled.pipe(Effect.as("reject" as const), Effect.raceFirst(ask(input)))).pipe( + restore( + cancelled.pipe( + Effect.as("reject" as const), + Effect.raceFirst(input.settled.pipe(Effect.as("settled" as const))), + Effect.raceFirst(ask(input)), + ), + ).pipe( Effect.tapCauseIf(Cause.hasDies, (cause) => Effect.logWarning("ACP permission ask failed", cause)), Effect.catchCause(() => Effect.succeed("reject" as const)), Effect.flatMap((decision) => respond(input, decision)), @@ -76,10 +83,12 @@ const ask = Effect.fnUntraced(function* (input: Input) { return selected === "once" || selected === "always" ? selected : "reject" }) -function respond(input: Input, decision: Permission.Reply) { - return input.client.permission - .reply({ sessionID: input.sessionID, requestID: input.event.data.id, decision }) - .pipe(Effect.catch(ACPClient.classify)) +function respond(input: Input, decision: Permission.Reply | "settled") { + if (decision === "settled") return Effect.void + return input.client.permission.reply({ sessionID: input.sessionID, requestID: input.event.data.id, decision }).pipe( + Effect.catchTag("PermissionNotFoundError", () => Effect.void), + Effect.catch(ACPClient.classify), + ) } function prefixedTitle(prefix: string | undefined, title: string | undefined) { @@ -104,7 +113,7 @@ const permissionPreviews = Effect.fnUntraced(function* ( Effect.gen(function* () { const path = absolutePath(file.file, cwd) const oldText = file.status === "added" ? null : yield* Effect.tryPromise(() => Bun.file(path).text()) - const newText = applyPatch(oldText ?? "", file.patch) + const newText = yield* Effect.try(() => applyPatch(oldText ?? "", file.patch)) return newText === false ? [] : [diff(path, oldText, newText)] }), { concurrency: "unbounded" }, diff --git a/packages/cli/src/acp/service.ts b/packages/cli/src/acp/service.ts index aa303222a42..280c4454596 100644 --- a/packages/cli/src/acp/service.ts +++ b/packages/cli/src/acp/service.ts @@ -22,6 +22,7 @@ import type { ListSessionsResponse, LoadSessionRequest, LoadSessionResponse, + McpServer, NewSessionRequest, NewSessionResponse, PromptRequest, @@ -41,7 +42,7 @@ import { configOptions, currentModel, DEFAULT_VARIANT_VALUE, parseModelSelection import type { ACPConnection } from "./connection" import { ACPDirectories } from "./directories" import { ACPError } from "./error" -import type { ACPSessions, Attached } from "./sessions" +import type { ACPSessions, Attached, SupportedMcpServer } from "./sessions" import { ACPTranslate } from "./translate" import type { ACPTurn } from "./turn" @@ -191,23 +192,25 @@ export function make(input: { }), newSession: Effect.fnUntraced(function* (params) { const directories = yield* ACPDirectories.parse(params.cwd, params.additionalDirectories) + const mcpServers = yield* supportedMcpServers(params.mcpServers) // Load first so a catalog failure leaves no session. yield* input.catalog.get(params.cwd) const created = yield* input.client.session .create({ location: { directory: AbsolutePath.make(params.cwd) }, ...ACPDirectories.grant(directories) }) .pipe(Effect.catch(ACPClient.classify)) - const attachment = yield* input.sessions.attach(created, params.cwd, params.mcpServers) + const attachment = yield* input.sessions.attach(created, params.cwd, mcpServers) return { sessionId: attachment.attached.id, configOptions: attachment.configOptions } }), loadSession: Effect.fnUntraced(function* (params) { const directories = yield* ACPDirectories.parse(params.cwd, params.additionalDirectories) + const mcpServers = yield* supportedMcpServers(params.mcpServers) const session = yield* getSession(params.sessionId, params.cwd) yield* ACPDirectories.activate(input.client, session, directories) - const attached = (yield* input.sessions.attach(session, session.location.directory, params.mcpServers)).attached + const attached = (yield* input.sessions.attach(session, session.location.directory, mcpServers)).attached return yield* replay(attached).pipe( Effect.andThen(currentOptions(attached)), Effect.map((configOptions) => ({ configOptions })), - Effect.onError(() => input.sessions.detach(attached.id)), + Effect.onError(() => input.sessions.release(attached)), ) }), listSessions: Effect.fnUntraced(function* (params) { @@ -247,9 +250,10 @@ export function make(input: { }), resumeSession: Effect.fnUntraced(function* (params) { const directories = yield* ACPDirectories.parse(params.cwd, params.additionalDirectories) + const mcpServers = yield* supportedMcpServers(params.mcpServers) const session = yield* getSession(params.sessionId, params.cwd) yield* ACPDirectories.activate(input.client, session, directories) - const attachment = yield* input.sessions.attach(session, session.location.directory, params.mcpServers ?? []) + const attachment = yield* input.sessions.attach(session, session.location.directory, mcpServers) return { configOptions: attachment.configOptions } }), closeSession: Effect.fnUntraced(function* (params) { @@ -259,11 +263,12 @@ export function make(input: { }), forkSession: Effect.fnUntraced(function* (params) { const directories = yield* ACPDirectories.parse(params.cwd, params.additionalDirectories) + const mcpServers = yield* supportedMcpServers(params.mcpServers) const sessionID = yield* ACPClient.decodeSessionID(params.sessionId) const forked = yield* input.client.session.fork({ sessionID }).pipe(Effect.catch(ACPClient.classify)) // Forks inherit the source's grants; replace them with this request's. yield* ACPDirectories.activate(input.client, forked, directories) - const attachment = yield* input.sessions.attach(forked, forked.location.directory, params.mcpServers ?? []) + const attachment = yield* input.sessions.attach(forked, forked.location.directory, mcpServers) return { sessionId: attachment.attached.id, configOptions: attachment.configOptions } }), setSessionConfigOption: Effect.fnUntraced(function* (params) { @@ -283,6 +288,18 @@ export function make(input: { } } +const supportedMcpServers = Effect.fnUntraced(function* (servers: readonly McpServer[] = []) { + const supported = servers.filter( + (server): server is SupportedMcpServer => !("type" in server) || server.type === "http", + ) + if (supported.length < servers.length) + return yield* new ACPError.InvalidRequestError({ + message: "Only stdio and HTTP MCP servers are supported", + field: "mcpServers", + }) + return supported +}) + const requireModel = Effect.fnUntraced(function* (catalog: Catalog, modelID: string, current: Model.Ref) { const selected = parseModelSelection(modelID, catalog.providers) const model = catalog.models.find( diff --git a/packages/cli/src/acp/sessions.ts b/packages/cli/src/acp/sessions.ts index ce46abef83e..5c174031ef2 100644 --- a/packages/cli/src/acp/sessions.ts +++ b/packages/cli/src/acp/sessions.ts @@ -3,13 +3,15 @@ import type { McpServer, RequestError, SessionConfigOption } from "@agentclientp import type { OpenCodeClient, OpenCodeEvent } from "@opencode/client/effect" import { Mcp } from "@opencode/schema/mcp" import type { Session } from "@opencode/schema/session" -import { Context, Deferred, Effect, Exit, Queue, Ref, Scope, Stream } from "effect" +import { Cause, Context, Deferred, Effect, Exit, Queue, Ref, Scope, Stream } from "effect" import type { ACPCatalog, Catalog } from "./catalog" import { ACPClient } from "./client" import { availableCommands, configOptions, type Selection } from "./config-option" import { ACPConnection } from "./connection" import { ACPError } from "./error" +export type SupportedMcpServer = Exclude + export type Attached = { readonly id: Session.ID readonly cwd: string @@ -20,12 +22,13 @@ export interface Interface { readonly attach: ( session: Session.Info, cwd: string, - mcpServers: readonly McpServer[], + mcpServers: readonly SupportedMcpServer[], ) => Effect.Effect< { readonly attached: Attached; readonly configOptions: SessionConfigOption[] }, ACPError.Error | RequestError | ACPCatalog.Error > readonly detach: (sessionID: string) => Effect.Effect + readonly release: (attached: Attached) => Effect.Effect readonly require: (sessionID: string) => Effect.Effect readonly fork: (attached: Attached, effect: Effect.Effect) => Effect.Effect } @@ -66,7 +69,9 @@ export const make = Effect.fnUntraced(function* (input: { event.type === "session.model.selected" ? { model: event.data.model } : { modeID: event.data.agent }, ) }), - Effect.ignore, + Effect.catchCause((cause) => + Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logWarning("ACP selection event stream failed", cause), + ), Effect.ensuring(Deferred.succeed(connected, undefined)), Effect.forkScoped, ) @@ -89,7 +94,7 @@ export const make = Effect.fnUntraced(function* (input: { if (!isDeepStrictEqual(next.commands, previous.commands)) yield* sendCommands(attached.id, next) }) - const registerMcp = (attached: Attached, servers: readonly McpServer[]) => + const registerMcp = (attached: Attached, servers: readonly SupportedMcpServer[]) => Effect.suspend(() => { const registered = registeredMcp.get(attached.id) ?? new Set() registeredMcp.set(attached.id, registered) @@ -166,6 +171,10 @@ export const make = Effect.fnUntraced(function* (input: { const entry = sessions.get(sessionID) if (entry) yield* remove(sessionID, entry) }), + release: Effect.fn("cli.acp.sessions.release")(function* (attached) { + const entry = sessions.get(attached.id) + if (entry?.attached === attached) yield* remove(attached.id, entry) + }), require: Effect.fn("cli.acp.sessions.require")(function* (sessionID) { const entry = sessions.get(sessionID) if (!entry) return yield* new ACPError.SessionNotFoundError({ sessionId: sessionID }) @@ -179,9 +188,8 @@ export const make = Effect.fnUntraced(function* (input: { }) }) -function mcpConfig(server: McpServer) { +function mcpConfig(server: SupportedMcpServer) { if ("type" in server) { - if (server.type === "acp") throw new Error("MCP-over-ACP is not supported") return new Mcp.RemoteConfig({ type: "remote", url: server.url, diff --git a/packages/cli/src/acp/translate.ts b/packages/cli/src/acp/translate.ts index 669664192af..30b7f3b33bb 100644 --- a/packages/cli/src/acp/translate.ts +++ b/packages/cli/src/acp/translate.ts @@ -72,7 +72,7 @@ export type TurnState = { readonly compactions: ACPCompaction.Tracked readonly children: ReadonlyMap readonly openChildren: ReadonlySet - readonly forms: ReadonlySet + readonly asks: ReadonlySet readonly finish?: SessionMessage.Assistant["finish"] readonly usage?: { readonly turn: TokenUsage.Info; readonly last: TokenUsage.Info } readonly stepError?: SessionError.Error @@ -97,7 +97,7 @@ export type Output = readonly child?: ChildSession readonly toolCallSent: boolean } - | { readonly _tag: "FormSettled"; readonly formID: string } + | { readonly _tag: "AskSettled"; readonly id: string } export type Step = { readonly state: TurnState @@ -112,7 +112,7 @@ export const initial: TurnState = { compactions: new Map(), children: new Map(), openChildren: new Set(), - forms: new Set(), + asks: new Set(), } export function step(state: TurnState, event: OpenCodeEvent, ctx: Context): Step { @@ -141,11 +141,14 @@ export function step(state: TurnState, event: OpenCodeEvent, ctx: Context): Step const tool = event.data.source?.id ? state.tools.get(toolKey(event.data.sessionID, event.data.source.id)) : undefined - return { state, outputs: [{ _tag: "PermissionAsk", event, tool, child }] } + return { + state: { ...state, asks: new Set(state.asks).add(event.data.id) }, + outputs: [{ _tag: "PermissionAsk", event, tool, child }], + } } if (event.type === "form.created" && (event.data.form.sessionID === ctx.sessionID || child)) { return { - state: { ...state, forms: new Set(state.forms).add(event.data.form.id) }, + state: { ...state, asks: new Set(state.asks).add(event.data.form.id) }, outputs: [ { _tag: "FormAsk", @@ -156,10 +159,16 @@ export function step(state: TurnState, event: OpenCodeEvent, ctx: Context): Step ], } } - if ((event.type === "form.replied" || event.type === "form.cancelled") && state.forms.has(event.data.id)) { - const forms = new Set(state.forms) - forms.delete(event.data.id) - return { state: { ...state, forms }, outputs: [{ _tag: "FormSettled", formID: event.data.id }] } + const settledID = + event.type === "permission.replied" + ? event.data.requestID + : event.type === "form.replied" || event.type === "form.cancelled" + ? event.data.id + : undefined + if (settledID && state.asks.has(settledID)) { + const asks = new Set(state.asks) + asks.delete(settledID) + return { state: { ...state, asks }, outputs: [{ _tag: "AskSettled", id: settledID }] } } if (!eventSessionID || (eventSessionID !== ctx.sessionID && !child)) return { state, outputs: [] } if (matchesStart(event, ctx.start)) return { state: { ...state, started: true }, outputs: [] } diff --git a/packages/cli/src/acp/turn.ts b/packages/cli/src/acp/turn.ts index 62af42be2ce..6915420d06d 100644 --- a/packages/cli/src/acp/turn.ts +++ b/packages/cli/src/acp/turn.ts @@ -66,7 +66,7 @@ type Subscription = { /** Asks run serially off the event stream. */ readonly asks: Queue.Queue> readonly cancelled: Deferred.Deferred - readonly forms: Map> + readonly settled: Map> } export const make = Effect.fnUntraced(function* (input: { @@ -90,7 +90,7 @@ export const make = Effect.fnUntraced(function* (input: { .pipe(Stream.toQueue({ capacity: "unbounded" }), Scope.provide(subscriptionScope)), asks: yield* Queue.unbounded>(), cancelled: yield* Deferred.make(), - forms: new Map(), + settled: new Map(), } yield* Queue.take(subscription.asks).pipe( Effect.flatten, @@ -116,7 +116,12 @@ export const make = Effect.fnUntraced(function* (input: { yield* Deferred.await(settled) }) - const reply = (subscription: Subscription, ctx: ACPTranslate.Context, ask: PermissionAsk) => + const reply = ( + subscription: Subscription, + ctx: ACPTranslate.Context, + ask: PermissionAsk, + settled: Deferred.Deferred, + ) => ACPPermission.reply( { client: input.client, @@ -127,6 +132,7 @@ export const make = Effect.fnUntraced(function* (input: { cwd: ctx.cwd, tool: ask.tool, child: ask.child, + settled: Deferred.await(settled), }, Deferred.await(subscription.cancelled), ) @@ -138,16 +144,26 @@ export const make = Effect.fnUntraced(function* (input: { case "ChildUpdate": return input.connection .extNotification(ACPTranslate.ChildSessionUpdateMethod, output.update) - .pipe(Effect.ignoreCause) + .pipe( + Effect.catchCause((cause) => + Cause.hasInterruptsOnly(cause) + ? Effect.void + : Effect.logWarning("ACP child session update failed", cause), + ), + ) case "PermissionAsk": - return Queue.offer(subscription.asks, reply(subscription, ctx, output)).pipe(Effect.asVoid) + return Effect.gen(function* () { + const settled = yield* Deferred.make() + subscription.settled.set(output.event.data.id, settled) + yield* Queue.offer(subscription.asks, reply(subscription, ctx, output, settled)) + }) case "FormAsk": return Effect.gen(function* () { const capabilities = yield* Ref.get(input.capabilities) const requestedSchema = ACPElicitation.requestedSchema(output.form, capabilities) if (!requestedSchema) return yield* ACPElicitation.cancelUnshown(input.client, output.form) const settled = yield* Deferred.make() - subscription.forms.set(output.form.id, settled) + subscription.settled.set(output.form.id, settled) yield* Queue.offer( subscription.asks, ACPElicitation.reply( @@ -165,10 +181,10 @@ export const make = Effect.fnUntraced(function* (input: { ), ) }) - case "FormSettled": + case "AskSettled": return Effect.suspend(() => { - const settled = subscription.forms.get(output.formID) - subscription.forms.delete(output.formID) + const settled = subscription.settled.get(output.id) + subscription.settled.delete(output.id) return settled ? Deferred.succeed(settled, undefined) : Effect.void }) } @@ -181,8 +197,10 @@ export const make = Effect.fnUntraced(function* (input: { ) { while (true) { const event = yield* take(subscription) - const next = ACPTranslate.step(yield* Ref.get(state), event, ctx) - yield* Ref.set(state, next.state) + const next = yield* Ref.modify(state, (current) => { + const step = ACPTranslate.step(current, event, ctx) + return [step, step.state] + }) yield* Effect.forEach(next.outputs, (output) => interpret(subscription, ctx, output), { discard: true }) if (next.terminal) { yield* asksSettled(subscription) @@ -227,7 +245,13 @@ export const make = Effect.fnUntraced(function* (input: { }) const interruptServer = (sessionID: Session.ID) => - input.client.session.interrupt({ sessionID }).pipe(Effect.ignoreCause) + input.client.session + .interrupt({ sessionID }) + .pipe( + Effect.catchCause((cause) => + Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logWarning("ACP server interrupt failed", cause), + ), + ) const windDown = Effect.fnUntraced(function* ( subscription: Subscription, @@ -238,7 +262,7 @@ export const make = Effect.fnUntraced(function* (input: { yield* Deferred.succeed(subscription.cancelled, undefined) yield* interruptServer(ctx.sessionID) if (!(yield* Ref.get(state)).started) return - if (Option.isSome(yield* Fiber.await(events).pipe(Effect.timeoutOption(drainTimeout)))) return + if (Option.exists(yield* Fiber.await(events).pipe(Effect.timeoutOption(drainTimeout)), Exit.isSuccess)) return yield* Fiber.interrupt(events) const abandoned = ACPTranslate.abandon(yield* Ref.get(state), ctx) yield* Ref.set(state, abandoned.state) @@ -323,7 +347,9 @@ export const make = Effect.fnUntraced(function* (input: { }, }) }, - (effect) => Effect.ignoreCause(effect), + Effect.catchCause((cause) => + Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logWarning("ACP usage update failed", cause), + ), ) // Forked uninterruptible: interruption reaches only `execute`, so the fiber still settles with a response. diff --git a/packages/cli/test/acp/error.test.ts b/packages/cli/test/acp/error.test.ts index ea56102beb2..00be30ecb19 100644 --- a/packages/cli/test/acp/error.test.ts +++ b/packages/cli/test/acp/error.test.ts @@ -18,26 +18,34 @@ describe("acp errors", () => { }) describe("acp error boundary over the wire", () => { - test.each<[string, (acp: Wire) => void]>([ - ["ends", (acp) => acp.server.closeEvents()], - ["drops its connection", (acp) => acp.server.dropEvents()], - ])("reports an unavailable server when the event stream %s mid-turn and once the server stops", async (_, lose) => { - await using acp = await startSession({ - onPrompt: ({ sessionID, id }) => [delivered(sessionID, id), textDelta(sessionID, "msg_held", "working")], - }) - const unavailable = { - code: -32603, - message: "Internal error: OpenCode server is unavailable", - data: { errorName: "ServerUnavailable" }, - } + test.each<[string, (acp: Wire) => void, string[]]>([ + ["ends", (acp) => acp.server.closeEvents(), []], + [ + "drops its connection", + (acp) => acp.server.dropEvents(), + ["ACP catalog event stream failed", "ACP selection event stream failed"], + ], + ])( + "reports an unavailable server when the event stream %s mid-turn and once the server stops", + async (_, lose, logs) => { + await using acp = await startSession({ + onPrompt: ({ sessionID, id }) => [delivered(sessionID, id), textDelta(sessionID, "msg_held", "working")], + }) + const unavailable = { + code: -32603, + message: "Internal error: OpenCode server is unavailable", + data: { errorName: "ServerUnavailable" }, + } - const prompt = acp.prompt(acp.sessionId, "hold") - await acp.waitForUpdate((item) => item.update.sessionUpdate === "agent_message_chunk") - await acp.request("session/set_mode", { sessionId: acp.sessionId, modeId: "build" }) - lose(acp) + const prompt = acp.prompt(acp.sessionId, "hold") + await acp.waitForUpdate((item) => item.update.sessionUpdate === "agent_message_chunk") + await acp.request("session/set_mode", { sessionId: acp.sessionId, modeId: "build" }) + lose(acp) - expect(await rpcError(prompt)).toEqual(unavailable) - await acp.server.stop() - expect(await rpcError(acp.request("session/list", {}))).toEqual(unavailable) - }) + expect(await rpcError(prompt)).toEqual(unavailable) + await acp.server.stop() + expect(await rpcError(acp.request("session/list", {}))).toEqual(unavailable) + expect(acp.logs.map((log) => String(log.message)).toSorted()).toEqual(logs) + }, + ) }) diff --git a/packages/cli/test/acp/permission.test.ts b/packages/cli/test/acp/permission.test.ts index 74ea06d69d1..0d54817969c 100644 --- a/packages/cli/test/acp/permission.test.ts +++ b/packages/cli/test/acp/permission.test.ts @@ -12,6 +12,7 @@ import { permissionAsked, startSession, startWire, + succeeded, toolCalled, toolStarted, turn, @@ -143,6 +144,40 @@ describe("acp permissions over the wire", () => { }) }, ) + test("withdraws permission requests settled elsewhere and still asks the remaining one", async () => { + await using acp = await startSession({ + onPrompt: ({ sessionID, id }) => [ + delivered(sessionID, id), + permissionAsked(sessionID, "perm_elsewhere"), + permissionAsked(sessionID, "perm_queued"), + permissionAsked(sessionID, "perm_remaining"), + ], + fetch: (request) => { + if (request.path.endsWith("/permission/perm_remaining/reply")) acp.server.send(succeeded(acp.sessionId)) + return undefined + }, + permission: (_request, signal) => + acp.permissions.length === 1 + ? new Promise((resolve) => { + signal.addEventListener("abort", () => resolve({ outcome: { outcome: "cancelled" } }), { once: true }) + }) + : allowOnce(), + }) + + const prompt = acp.prompt(acp.sessionId, "hello") + await acp.until(() => acp.permissions.length === 1, "permission request") + acp.server.send( + ephemeralEvent("permission.replied", { sessionID: acp.sessionId, requestID: "perm_queued", reply: "always" }), + ephemeralEvent("permission.replied", { sessionID: acp.sessionId, requestID: "perm_elsewhere", reply: "always" }), + ) + + expect(await prompt).toMatchObject({ stopReason: "end_turn" }) + expect(acp.permissions.map((request) => request.toolCall.toolCallId)).toEqual(["perm_elsewhere", "perm_remaining"]) + expect(decisions(acp)).toEqual([["perm_remaining", "once"]]) + const cancels = acp.received.filter((message) => "method" in message && message.method === "$/cancel_request") + expect(cancels).toHaveLength(1) + expect(acp.logs).toEqual([]) + }) }) describe("acp edit previews over the wire", () => { diff --git a/packages/cli/test/acp/session.test.ts b/packages/cli/test/acp/session.test.ts index 30baa69bb65..46a68e9c704 100644 --- a/packages/cli/test/acp/session.test.ts +++ b/packages/cli/test/acp/session.test.ts @@ -156,6 +156,28 @@ describe("acp session lifecycle over the wire", () => { config: { type: "remote", url: "https://example.com/mcp", headers: { Authorization: "Bearer x" }, oauth: false }, }) }) + test("rejects MCP-over-ACP and SSE servers before creating or loading a session", async () => { + await using acp = await startWire() + acp.server.sessions.set("ses_saved", makeSession("ses_saved")) + await acp.initialize() + const existing = new Set(acp.server.sessions.keys()) + const mcpServers: McpServer[] = [{ type: "acp", name: "client", serverId: "mcp_client" }] + const sse: McpServer[] = [{ type: "sse", name: "events", url: "https://example.com/sse", headers: [] }] + const invalid = { + code: -32602, + message: "Invalid params: Only stdio and HTTP MCP servers are supported", + data: { field: "mcpServers" }, + } + + expect(await rpcError(acp.newSession("/workspace", mcpServers))).toEqual(invalid) + expect(await rpcError(acp.newSession("/workspace", sse))).toEqual(invalid) + expect( + await rpcError(acp.request("session/load", { cwd: "/workspace", sessionId: "ses_saved", mcpServers })), + ).toEqual(invalid) + expect(new Set(acp.server.sessions.keys())).toEqual(existing) + expect(acp.server.requests.filter((request) => request.path.includes("ses_saved"))).toEqual([]) + expect(acp.logs).toEqual([]) + }) }) const isSessionUpdate = Schema.is( diff --git a/packages/cli/test/acp/wire-fixture.ts b/packages/cli/test/acp/wire-fixture.ts index 0a76b80c7cf..fe66a985e0e 100644 --- a/packages/cli/test/acp/wire-fixture.ts +++ b/packages/cli/test/acp/wire-fixture.ts @@ -28,7 +28,7 @@ import type { Session } from "@opencode/schema/session" import type { SessionMessage } from "@opencode/schema/session-message" import type { TokenUsage } from "@opencode/schema/token-usage" import type { BunRequest } from "bun" -import { Duration, Effect, Exit, Option, Schema, Scope } from "effect" +import { Duration, Effect, Exit, Logger, Option, Schema, Scope } from "effect" import { FetchHttpClient } from "effect/unstable/http" import { ACP } from "../../src/acp/agent" import { ACPTurn } from "../../src/acp/turn" @@ -412,6 +412,7 @@ export async function startWire(options: WireOptions = {}) { const clientToAgent = new TransformStream() const agentToClient = new TransformStream() + const logs: Array, "message" | "cause">> = [] const agentScope = Scope.makeUnsafe() const agentConnection = await Effect.runPromise( OpenCode.make({ baseUrl: server.url }).pipe( @@ -422,6 +423,7 @@ export async function startWire(options: WireOptions = {}) { options.cancelDrainTimeout === undefined ? effect : Effect.provideService(effect, ACPTurn.CancelDrainTimeout, options.cancelDrainTimeout), + Effect.provide(Logger.layer([Logger.make((log) => logs.push({ message: log.message, cause: log.cause }))])), ), ) const clientStream = ndJsonStream(clientToAgent.writable, agentToClient.readable) @@ -505,6 +507,7 @@ export async function startWire(options: WireOptions = {}) { permissions, childUpdates, elicitations, + logs, request, until, initialize,