From 66d15a7352919bbc654e09b4eda8d0765f79aa5e Mon Sep 17 00:00:00 2001 From: Shoubhit Dash Date: Sat, 3 Oct 2026 00:04:06 +0530 Subject: [PATCH] refactor(acp): split module seams and drop dead code (#52803) --- packages/cli/src/acp/agent.ts | 5 +- packages/cli/src/acp/capabilities.ts | 17 +++ packages/cli/src/acp/catalog.ts | 32 ++--- packages/cli/src/acp/child.ts | 68 +++++++++ packages/cli/src/acp/client.ts | 11 +- packages/cli/src/acp/compaction.ts | 36 +++-- packages/cli/src/acp/config-option.ts | 6 +- packages/cli/src/acp/connection.ts | 6 +- packages/cli/src/acp/content.ts | 36 +++-- packages/cli/src/acp/elicitation.ts | 24 ++-- packages/cli/src/acp/error.ts | 34 ++--- packages/cli/src/acp/permission.ts | 30 ++-- packages/cli/src/acp/replay.ts | 127 +++++++++++++++++ packages/cli/src/acp/service.ts | 84 ++++------- packages/cli/src/acp/sessions.ts | 41 ++---- packages/cli/src/acp/tool.ts | 25 ++-- packages/cli/src/acp/translate.ts | 179 +++--------------------- packages/cli/src/acp/turn.ts | 69 +++++---- packages/cli/test/acp/session.test.ts | 13 +- packages/cli/test/acp/translate.test.ts | 3 +- 20 files changed, 424 insertions(+), 422 deletions(-) create mode 100644 packages/cli/src/acp/capabilities.ts create mode 100644 packages/cli/src/acp/child.ts create mode 100644 packages/cli/src/acp/replay.ts diff --git a/packages/cli/src/acp/agent.ts b/packages/cli/src/acp/agent.ts index a2f152f085b..94c458b77f2 100644 --- a/packages/cli/src/acp/agent.ts +++ b/packages/cli/src/acp/agent.ts @@ -11,6 +11,7 @@ import { } from "@agentclientprotocol/sdk" import type { OpenCodeClient } from "@opencode/client/effect" import { Cause, Deferred, Effect, Ref, type Scope } from "effect" +import { ACPCapabilities } from "./capabilities" import { ACPCatalog } from "./catalog" import { ACPClient } from "./client" import { ACPConnection } from "./connection" @@ -27,7 +28,7 @@ export const connect = Effect.fnUntraced(function* (client: OpenCodeClient, stre const ready = yield* Deferred.make() const handle = ( - call: (service: ACPService.Interface, ctx: AgentHandlerContext) => Effect.Effect, + call: (service: ACPService.Interface, ctx: AgentHandlerContext) => Effect.Effect, ) => (name: string) => { const handler = Effect.fn(name)( @@ -114,7 +115,7 @@ export const connect = Effect.fnUntraced(function* (client: OpenCodeClient, stre const acp = ACPConnection.make(app, stream) const connection = acp.connection const sessions = yield* ACPSessions.make({ client, connection, catalog }) - const capabilities = yield* Ref.make({ childSessionUpdates: false, formElicitation: false, compaction: false }) + const capabilities = yield* Ref.make(ACPCapabilities.parse(undefined)) const turn = yield* ACPTurn.make({ client, connection, sessions, catalog, capabilities }) yield* Deferred.succeed(ready, ACPService.make({ client, connection, catalog, sessions, capabilities, turn })) return acp.agent diff --git a/packages/cli/src/acp/capabilities.ts b/packages/cli/src/acp/capabilities.ts new file mode 100644 index 00000000000..2cef2273099 --- /dev/null +++ b/packages/cli/src/acp/capabilities.ts @@ -0,0 +1,17 @@ +import type { ClientCapabilities } from "@agentclientprotocol/sdk" + +export const ChildSessionUpdates = "opencode/child-session-updates" + +export type Capabilities = ReturnType + +export function parse(client: ClientCapabilities | undefined) { + const elicitation = client?.elicitation + const compaction = client?.session?.compaction + return { + childSessionUpdates: client?._meta?.[ChildSessionUpdates] === true, + formElicitation: elicitation?.form !== undefined && elicitation.form !== null, + compaction: compaction !== undefined && compaction !== null, + } +} + +export * as ACPCapabilities from "./capabilities" diff --git a/packages/cli/src/acp/catalog.ts b/packages/cli/src/acp/catalog.ts index 10f4f25228f..ca95eacf71f 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 { Cause, Context, Deferred, Effect, Exit, Schedule, Schema, Semaphore, Stream, SubscriptionRef } from "effect" +import { Cause, Deferred, Effect, Exit, Schedule, Schema, Semaphore, Stream, SubscriptionRef } from "effect" import type { ConfigOptionProvider } from "./config-option" export const builtinCommands = new Map([ @@ -19,7 +19,7 @@ export type Catalog = { readonly commands: ReadonlyArray } -export class NotReadyError extends Schema.TaggedError()("ACPCatalogNotReadyError", { +class NotReadyError extends Schema.TaggedError()("ACPCatalogNotReadyError", { reason: Schema.Literals(["models", "agents"]), }) { override get message() { @@ -27,7 +27,7 @@ export class NotReadyError extends Schema.TaggedError()("ACPCatal } } -export class LoadError extends Schema.TaggedError()("ACPCatalogLoadError", { +class LoadError extends Schema.TaggedError()("ACPCatalogLoadError", { cause: Schema.Defect(), }) {} @@ -39,14 +39,12 @@ export interface Interface { readonly changes: (cwd: string) => Stream.Stream } -export class Service extends Context.Service()("@opencode/cli/acp/Catalog") {} - type Entry = { readonly cwd: string readonly catalog: SubscriptionRef.SubscriptionRef readonly lock: Semaphore.Semaphore - requested: number - loaded: number + requestedGeneration: number + loadedGeneration: number } const reloadOn = new Set(["model.updated", "agent.updated", "command.updated"]) @@ -59,17 +57,17 @@ export const make = Effect.fnUntraced(function* (client: OpenCodeClient) { // Requests queued behind a running load share the next one. const reload = (entry: Entry) => Effect.suspend(() => { - const target = ++entry.requested + const target = ++entry.requestedGeneration return entry.lock.withPermit( Effect.suspend(() => { - if (entry.loaded >= target) return Effect.void - const generation = entry.requested + if (entry.loadedGeneration >= target) return Effect.void + const generation = entry.requestedGeneration return load(client, entry.cwd).pipe( Effect.flatMap((next) => SubscriptionRef.set(entry.catalog, next)), Effect.ignore, Effect.andThen( Effect.sync(() => { - entry.loaded = generation + entry.loadedGeneration = generation }), ), ) @@ -103,8 +101,8 @@ export const make = Effect.fnUntraced(function* (client: OpenCodeClient) { cwd, catalog: yield* SubscriptionRef.make(yield* load(client, cwd)), lock: Semaphore.makeUnsafe(1), - requested: 0, - loaded: 0, + requestedGeneration: 0, + loadedGeneration: 0, } satisfies Entry }) @@ -125,8 +123,8 @@ export const make = Effect.fnUntraced(function* (client: OpenCodeClient) { ) }) - return Service.of({ - get: Effect.fn("cli.acp.catalog.get")(function* (cwd) { + return { + get: Effect.fnUntraced(function* (cwd) { const loaded = yield* entry(cwd) return yield* SubscriptionRef.get(loaded.catalog) }), @@ -134,7 +132,7 @@ export const make = Effect.fnUntraced(function* (client: OpenCodeClient) { yield* reload(yield* entry(cwd)) }), changes: (cwd) => Stream.unwrap(entry(cwd).pipe(Effect.map((loaded) => SubscriptionRef.changes(loaded.catalog)))), - }) + } satisfies Interface }) const load = (client: OpenCodeClient, cwd: string) => @@ -183,7 +181,7 @@ const read = Effect.fnUntraced(function* (client: OpenCodeClient, cwd: string) { } satisfies Catalog }) -function providers(models: ReadonlyArray): ConfigOptionProvider[] { +function providers(models: ReadonlyArray) { return Array.from(new Set(models.map((model) => model.providerID))) .toSorted() .map((providerID) => ({ diff --git a/packages/cli/src/acp/child.ts b/packages/cli/src/acp/child.ts new file mode 100644 index 00000000000..c9a776ae140 --- /dev/null +++ b/packages/cli/src/acp/child.ts @@ -0,0 +1,68 @@ +import type { SessionUpdate } from "@agentclientprotocol/sdk" + +export const UpdateMethod = "opencode/session/child_update" + +export type Session = { + readonly id: string + readonly parentID: string + readonly depth: number + readonly title?: string +} + +export type Event = + | { readonly type: "update"; readonly update: SessionUpdate } + | { + readonly type: "status" + readonly status: "created" | "running" | "completed" | "failed" | "interrupted" + readonly error?: { readonly type: string; readonly message: string } + } + +export type Update = { + readonly rootSessionId: string + readonly childSessionId: string + readonly parentSessionId: string + readonly depth: number + readonly title?: string +} & Event + +export function update(rootSessionID: string, child: Session, event: Event): Update { + return { + rootSessionId: rootSessionID, + childSessionId: child.id, + parentSessionId: child.parentID, + depth: child.depth, + ...(child.title ? { title: child.title } : {}), + ...event, + } +} + +export function project(sessionUpdate: SessionUpdate, child: Session) { + const projected = { ...sessionUpdate } + projected._meta = { ...projected._meta, ...meta(child) } + if (projected.sessionUpdate === "tool_call" || projected.sessionUpdate === "tool_call_update") { + projected.toolCallId = toolCallID(child, projected.toolCallId) + if (projected.title) projected.title = prefixTitle(child, projected.title) + } + return projected +} + +export function meta(child: Session) { + return { + "opencode/child-session": { + id: child.id, + parentID: child.parentID, + depth: child.depth, + ...(child.title ? { title: child.title } : {}), + }, + } +} + +export function toolCallID(child: Session | undefined, id: string) { + return child ? `${child.id}:${id}` : id +} + +export function prefixTitle(child: Session | undefined, value: string) { + return child?.title ? `${child.title}: ${value}` : value +} + +export * as ACPChild from "./child" diff --git a/packages/cli/src/acp/client.ts b/packages/cli/src/acp/client.ts index f79a34bb13d..3639f2341f4 100644 --- a/packages/cli/src/acp/client.ts +++ b/packages/cli/src/acp/client.ts @@ -9,7 +9,9 @@ export function classify(error: unknown): Effect.Effect { if ( error instanceof ClientError && HttpClientError.isHttpClientError(error.cause) && - isConnectionFailure(error.cause) + // The client reports a failed body read as a `DecodeError` with a cause; its other `DecodeError`s have none. + (error.cause.reason._tag === "TransportError" || + (error.cause.reason._tag === "DecodeError" && error.cause.reason.cause !== undefined)) ) return Effect.fail(new ACPError.ServerUnavailableError()) if (error instanceof SessionNotFoundError) @@ -21,13 +23,6 @@ export function classify(error: unknown): Effect.Effect { return Effect.die(error) } -// The client reports a failed body read as a `DecodeError` with a cause; its other `DecodeError`s have none. -function isConnectionFailure(error: HttpClientError.HttpClientError) { - return ( - error.reason._tag === "TransportError" || (error.reason._tag === "DecodeError" && error.reason.cause !== undefined) - ) -} - export function decodeSessionID(value: string) { return Schema.decodeUnknownEffect(Session.ID)(value).pipe( Effect.mapError(() => new ACPError.InvalidRequestError({ message: "Invalid session ID", field: "sessionID" })), diff --git a/packages/cli/src/acp/compaction.ts b/packages/cli/src/acp/compaction.ts index e974a7f1292..6b012a7f211 100644 --- a/packages/cli/src/acp/compaction.ts +++ b/packages/cli/src/acp/compaction.ts @@ -5,7 +5,7 @@ import { SessionMessage } from "@opencode/schema/session-message" const MarkerMeta = "opencode/compaction" -export type Started = { readonly status: "started"; readonly messageId: string; readonly reason: "auto" | "manual" } +type Started = { readonly status: "started"; readonly messageId: string; readonly reason: "auto" | "manual" } type Compaction = | Started @@ -43,11 +43,11 @@ export function usesStandardUpdates( return ctx.compaction && (!child || ctx.childUpdates) } -export function apply(event: LifecycleEvent, tracked: Tracked, standard: boolean) { +export function apply(event: LifecycleEvent, tracked: Tracked, standardUpdates: boolean) { const sessionID = event.data.sessionID if (event.type === "session.compaction.started") { const started = open(event) - return { tracked: new Map(tracked).set(sessionID, started), updates: [update(started, standard)] } + return { tracked: new Map(tracked).set(sessionID, started), updates: [update(started, standardUpdates)] } } const current = tracked.get(sessionID) const remaining = new Map(tracked) @@ -60,35 +60,41 @@ export function apply(event: LifecycleEvent, tracked: Tracked, standard: boolean reason: event.data.reason, summary: event.data.text, } - return { tracked: remaining, updates: [update(completed, standard)] } + return { tracked: remaining, updates: [update(completed, standardUpdates)] } } // Auto compaction can fail without a started event; open it first for standard clients. const started = current ?? open(event) const failed: Compaction = { ...started, status: "failed", reason: event.data.reason, error: event.data.error } return { tracked: remaining, - updates: [...(current || !standard ? [] : [update(started, standard)]), update(failed, standard)], + updates: [ + ...(current || !standardUpdates ? [] : [update(started, standardUpdates)]), + update(failed, standardUpdates), + ], } } -export function chunk(started: Started | undefined, text: string, standard: boolean): SessionUpdate | undefined { - if (!started || !standard) return undefined +export function chunk(started: Started | undefined, text: string, standardUpdates: boolean): SessionUpdate | undefined { + if (!started || !standardUpdates) return undefined return { sessionUpdate: "compaction_summary_chunk", compactionId: started.messageId, content: { type: "text", text } } } -export function abandon(started: Started, standard: boolean) { - return update({ ...started, status: "failed", error: { type: "aborted", message: "Compaction cancelled" } }, standard) +export function abandon(started: Started, standardUpdates: boolean) { + return update( + { ...started, status: "failed", error: { type: "aborted", message: "Compaction cancelled" } }, + standardUpdates, + ) } // Nothing on this connection would settle a replayed running compaction. -export function replay(message: Extract, standard: boolean) { +export function replay(message: Extract, standardUpdates: boolean) { if (message.status === "running") return undefined const base = { messageId: message.id, reason: message.reason } return update( message.status === "failed" ? { ...base, status: "failed", error: message.error } : { ...base, status: "completed", summary: message.summary }, - standard, + standardUpdates, ) } @@ -101,8 +107,8 @@ function open(event: OpeningEvent): Started { } } -function update(compaction: Compaction, standard: boolean): SessionUpdate { - if (!standard) { +function update(compaction: Compaction, standardUpdates: boolean): SessionUpdate { + if (!standardUpdates) { const marker = { status: compaction.status, messageId: compaction.messageId, @@ -125,12 +131,12 @@ function update(compaction: Compaction, standard: boolean): SessionUpdate { compactionId, status: "failed", summary: null, - error: errorMessage(compaction.error), + error: displayError(compaction.error), } } // Core reports a defect as `compaction.failed` with a multi-line pretty-printed cause. -function errorMessage(error: SessionError.Error) { +function displayError(error: SessionError.Error) { if (!error.message || (error.type === "compaction.failed" && error.message.includes("\n"))) return "Compaction failed" return error.message } diff --git a/packages/cli/src/acp/config-option.ts b/packages/cli/src/acp/config-option.ts index 09ec4f9e77f..565d570dd97 100644 --- a/packages/cli/src/acp/config-option.ts +++ b/packages/cli/src/acp/config-option.ts @@ -5,7 +5,7 @@ import { builtinCommands, type Catalog } from "./catalog" export const DEFAULT_VARIANT_VALUE = "default" -export type ConfigOptionModel = { +type ConfigOptionModel = { id: string name: string variants?: ReadonlyArray @@ -17,7 +17,7 @@ export type ConfigOptionProvider = { models: ReadonlyArray } -export type ConfigOptionMode = { +type ConfigOptionMode = { id: string name: string description?: string @@ -163,5 +163,3 @@ function selectVariant(variant: string | undefined, variants: readonly string[]) if (variants.includes(DEFAULT_VARIANT_VALUE)) return DEFAULT_VARIANT_VALUE return variants[0] ?? DEFAULT_VARIANT_VALUE } - -export * as ACPConfigOption from "./config-option" diff --git a/packages/cli/src/acp/connection.ts b/packages/cli/src/acp/connection.ts index 805f9c5fe8a..4d93ccd2b89 100644 --- a/packages/cli/src/acp/connection.ts +++ b/packages/cli/src/acp/connection.ts @@ -29,8 +29,6 @@ export interface Interface { readonly responded: (requestId: JsonRpcId) => Effect.Effect } -export class Service extends Context.Service()("@opencode/cli/acp/Connection") {} - export function make(app: AgentApp, stream: Stream) { const responses = new Map>() const writer = stream.writable.getWriter() @@ -51,7 +49,7 @@ export function make(app: AgentApp, stream: Stream) { }) return { agent, - connection: Service.of({ + connection: { sessionUpdate: (params) => promise(() => agent.client.notify(methods.client.session.update, params)), requestPermission: (params) => promise((signal) => @@ -67,7 +65,7 @@ export function make(app: AgentApp, stream: Stream) { responses.set(requestId, responded) return Deferred.await(responded) }, - }), + } satisfies Interface, } } diff --git a/packages/cli/src/acp/content.ts b/packages/cli/src/acp/content.ts index 66861659002..f74b99ad34d 100644 --- a/packages/cli/src/acp/content.ts +++ b/packages/cli/src/acp/content.ts @@ -1,18 +1,19 @@ import type { ContentBlock, ContentChunk, ResourceLink } from "@agentclientprotocol/sdk" import path from "node:path" import { fileURLToPath, pathToFileURL } from "node:url" +import { Result } from "effect" export type PromptPart = | { readonly type: "text"; readonly text: string; readonly synthetic?: boolean; readonly ignored?: boolean } | { readonly type: "file"; readonly url: string; readonly filename?: string; readonly mime: string } -export type ReplayPart = PromptPart | { readonly type: "reasoning"; readonly text: string } +type ReplayPart = PromptPart | { readonly type: "reasoning"; readonly text: string } export function promptContentToParts(content: readonly ContentBlock[]): PromptPart[] { return content.flatMap(contentBlockToParts) } -export function contentBlockToParts(block: ContentBlock): PromptPart[] { +function contentBlockToParts(block: ContentBlock): PromptPart[] { switch (block.type) { case "text": { const audience = block.annotations?.audience @@ -35,22 +36,19 @@ export function contentBlockToParts(block: ContentBlock): PromptPart[] { return [resourceLinkToPart(block)] case "resource": if ("text" in block.resource) { - try { - const parsed = new URL(block.resource.uri) - if (parsed.protocol === "file:") { - const line = parsed.hash.match(/^#L(\d+)/)?.[1] - const decoded = (() => { - try { - return fileURLToPath(parsed) - } catch { - return decodeURIComponent(parsed.pathname) - } - })() - const filepath = path.sep === "\\" ? decoded.replace(/\\/g, "/") : decoded - return [{ type: "text", text: `[${filepath}${line ? `:${line}` : ""}]\n${block.resource.text}` }] - } - } catch {} - return [{ type: "text", text: `[${block.resource.uri}]\n${block.resource.text}` }] + const parsed = URL.canParse(block.resource.uri) ? new URL(block.resource.uri) : undefined + const decoded = + parsed?.protocol === "file:" + ? Result.try(() => fileURLToPath(parsed)).pipe( + Result.orElse(() => Result.try(() => decodeURIComponent(parsed.pathname))), + Result.getOrUndefined, + ) + : undefined + if (!parsed || decoded === undefined) + return [{ type: "text", text: `[${block.resource.uri}]\n${block.resource.text}` }] + const line = parsed.hash.match(/^#L(\d+)/)?.[1] + const filepath = path.sep === "\\" ? decoded.replace(/\\/g, "/") : decoded + return [{ type: "text", text: `[${filepath}${line ? `:${line}` : ""}]\n${block.resource.text}` }] } if (!block.resource.mimeType) return [] return [ @@ -171,5 +169,3 @@ function filenameFromUri(uri: string | undefined): string | undefined { } return path.basename(uri) || undefined } - -export * as ACPContent from "./content" diff --git a/packages/cli/src/acp/elicitation.ts b/packages/cli/src/acp/elicitation.ts index 8a5cc4e1ac7..28cb713d01f 100644 --- a/packages/cli/src/acp/elicitation.ts +++ b/packages/cli/src/acp/elicitation.ts @@ -6,10 +6,11 @@ import type { } from "@agentclientprotocol/sdk" import type { OpenCodeClient } from "@opencode/client/effect" import { Form } from "@opencode/schema/form" -import { Session } from "@opencode/schema/session" import { Cause, Effect, Option, Schema } from "effect" +import type { Capabilities } from "./capabilities" +import { ACPChild } from "./child" +import { ACPClient } from "./client" import type { ACPConnection } from "./connection" -import type { ACPService } from "./service" export type AskedForm = Omit & { readonly id: string } type InputField = Exclude @@ -27,7 +28,7 @@ type Input = { readonly form: Form.Info readonly requestedSchema: ElicitationSchema readonly clientSessionID: string - readonly child?: { readonly id: string; readonly title?: string } + readonly child?: ACPChild.Session readonly toolCallSent: boolean readonly settled: Effect.Effect } @@ -58,7 +59,7 @@ function cancel(client: OpenCodeClient, form: Form.Info, message?: string) { return client.session.form.cancel({ sessionID: form.sessionID, formID: form.id, message }).pipe( Effect.catchTag(["FormAlreadySettledError", "FormNotFoundError"], () => Effect.void), Effect.catch(() => - Schema.decodeUnknownEffect(Session.ID)(form.sessionID).pipe( + ACPClient.decodeSessionID(form.sessionID).pipe( Effect.flatMap((sessionID) => client.session.interrupt({ sessionID })), Effect.ignore, ), @@ -66,7 +67,7 @@ function cancel(client: OpenCodeClient, form: Form.Info, message?: string) { ) } -export function requestedSchema(form: AskedForm, capabilities: ACPService.Capabilities): ElicitationSchema | undefined { +export function requestedSchema(form: AskedForm, capabilities: Capabilities): ElicitationSchema | undefined { if (!capabilities.formElicitation) return undefined if (Option.isNone(Schema.decodeUnknownOption(ElicitedKind)(form.metadata))) return undefined if (form.fields.some(credentialLike)) return undefined @@ -90,7 +91,7 @@ export function cancelUnshown(client: OpenCodeClient, form: Form.Info) { ) } -export function answer(form: AskedForm, response: CreateElicitationResponse): Form.Answer | undefined { +function answer(form: AskedForm, response: CreateElicitationResponse): Form.Answer | undefined { if (response.action !== "accept") return undefined const content = Schema.decodeUnknownOption(Form.Answer)(response.content ?? {}) if (Option.isNone(content)) return undefined @@ -108,8 +109,8 @@ const ask = Effect.fnUntraced(function* (input: Input) { const response = yield* input.connection.createElicitation({ mode: "form", sessionId: input.clientSessionID, - ...(toolCallID ? { toolCallId: input.child ? `${input.child.id}:${toolCallID}` : toolCallID } : {}), - message: input.child?.title ? `${input.child.title}: ${input.form.title}` : input.form.title, + ...(toolCallID ? { toolCallId: ACPChild.toolCallID(input.child, toolCallID) } : {}), + message: ACPChild.prefixTitle(input.child, input.form.title), requestedSchema: input.requestedSchema, }) return answer(input.form, response) ?? "cancel" @@ -152,7 +153,8 @@ function properties(field: InputField): Array<[string, ElicitationPropertySchema const base = { title: field.title, description: field.description } switch (field.type) { case "string": { - if (!hasOptions(field)) return [[field.key, { type: "string", ...base, ...text(field), default: field.default }]] + if (!hasOptions(field)) + return [[field.key, { type: "string", ...base, ...stringConstraints(field), default: field.default }]] const select: ElicitationPropertySchema = { type: "string", ...base, @@ -192,13 +194,13 @@ function other(field: SelectField, description: string): [string, ElicitationPro type: "string", title: `${field.title ?? field.key} (other)`, description, - ...(field.type === "string" ? text(field) : {}), + ...(field.type === "string" ? stringConstraints(field) : {}), }, ] } // Core rejects an empty string for a required field. -function text(field: Form.StringField) { +function stringConstraints(field: Form.StringField) { return { format: field.format, minLength: field.required ? Math.max(field.minLength ?? 0, 1) : field.minLength, diff --git a/packages/cli/src/acp/error.ts b/packages/cli/src/acp/error.ts index a6a923e4e30..2c22b4b75e2 100644 --- a/packages/cli/src/acp/error.ts +++ b/packages/cli/src/acp/error.ts @@ -1,5 +1,6 @@ import { RequestError } from "@agentclientprotocol/sdk" import { Schema } from "effect" +import type { ACPCatalog } from "./catalog" export class SessionNotFoundError extends Schema.TaggedError()("ACPSessionNotFoundError", { sessionId: Schema.String, @@ -55,22 +56,21 @@ export class ServerUnavailableError extends Schema.TaggedError @@ -23,7 +23,7 @@ type Input = { readonly clientSessionID: string readonly cwd: string readonly tool?: Tool - readonly child?: ACPTranslate.ChildSession + readonly child?: ACPChild.Session readonly settled: Effect.Effect } @@ -58,14 +58,11 @@ const ask = Effect.fnUntraced(function* (input: Input) { const previews = yield* permissionPreviews(toolName, toolInput, input.event.data.metadata, input.cwd).pipe( Effect.orElseSucceed((): Preview[] => []), ) - const toolCallID = input.tool?.id ?? input.event.data.id + const title = permissionTitle(toolName, toolInput, previews) const toolCall = pendingToolCall({ - toolCallId: input.child ? `${input.child.id}:${toolCallID}` : toolCallID, + toolCallId: ACPChild.toolCallID(input.child, input.tool?.id ?? input.event.data.id), toolName, - state: { - input: toolInput, - title: prefixedTitle(input.child?.title, permissionTitle(toolName, toolInput, previews)), - }, + state: { input: toolInput, title: title ? ACPChild.prefixTitle(input.child, title) : input.child?.title }, cwd: input.cwd, }) const result = yield* input.connection.requestPermission({ @@ -75,7 +72,7 @@ const ask = Effect.fnUntraced(function* (input: Input) { rawInput: input.tool ? toolCall.rawInput : undefined, locations: permissionLocations(toolName, toolInput, input.event.data, input.cwd), ...(previews.length > 0 ? { content: previews } : {}), - ...(input.child ? { _meta: ACPTranslate.childSessionMeta(input.child) } : {}), + ...(input.child ? { _meta: ACPChild.meta(input.child) } : {}), }, options, }) @@ -91,12 +88,6 @@ function respond(input: Input, decision: Permission.Reply | "settled") { ) } -function prefixedTitle(prefix: string | undefined, title: string | undefined) { - if (!prefix) return title - if (!title) return prefix - return `${prefix}: ${title}` -} - // Core trims the patch tool's diffs for display, which breaks `applyPatch`, so its previews come from its own hunks. const permissionPreviews = Effect.fnUntraced(function* ( toolName: string, @@ -167,12 +158,7 @@ function permissionTitle(toolName: string, input: ToolInput, previews: ReadonlyA } } -function permissionLocations( - toolName: string, - input: ToolInput, - ask: PermissionEvent["data"], - cwd: string, -): ToolCallLocation[] { +function permissionLocations(toolName: string, input: ToolInput, ask: PermissionEvent["data"], cwd: string) { const locations = toLocations(toolName, input, cwd) if (locations.length > 0 || !PathActions.has(ask.action)) return locations const paths = ask.resources.flatMap((resource) => { diff --git a/packages/cli/src/acp/replay.ts b/packages/cli/src/acp/replay.ts new file mode 100644 index 00000000000..c92e91b820d --- /dev/null +++ b/packages/cli/src/acp/replay.ts @@ -0,0 +1,127 @@ +import type { SessionUpdate } from "@agentclientprotocol/sdk" +import type { OpenCodeClient } from "@opencode/client/effect" +import type { SessionMessage } from "@opencode/schema/session-message" +import { Effect, Option, Stream } from "effect" +import type { Capabilities } from "./capabilities" +import { ACPClient } from "./client" +import { ACPCompaction } from "./compaction" +import type { ACPConnection } from "./connection" +import { partsToContentChunks } from "./content" +import type { Attached } from "./sessions" +import { ACPTranslate } from "./translate" +import { completedToolUpdate, errorToolUpdate, pendingToolCall, runningToolUpdate } from "./tool" + +export function history( + client: OpenCodeClient, + connection: ACPConnection.Interface, + attached: Attached, + capabilities: Capabilities, +) { + return Stream.paginate(undefined, (cursor: string | undefined) => + (cursor + ? client.message.list({ sessionID: attached.id, limit: 200, cursor }) + : client.message.list({ sessionID: attached.id, limit: 200, order: "asc" }) + ).pipe( + Effect.catch(ACPClient.classify), + Effect.map((page) => [page.data, Option.fromNullishOr(page.cursor.next)] as const), + ), + ).pipe( + Stream.runForEach((message) => + Effect.forEach( + updates(message, attached.cwd, capabilities), + (update) => connection.sessionUpdate({ sessionId: attached.id, update }), + { discard: true }, + ), + ), + ) +} + +export function updates(message: SessionMessage.Info, cwd: string, capabilities: Capabilities): SessionUpdate[] { + if (message.type === "user") + return [ + { sessionUpdate: "user_message_chunk", messageId: message.id, content: { type: "text", text: message.text } }, + ...partsToContentChunks( + (message.files ?? []).map((file) => ({ + type: "file", + url: file.source.type === "uri" ? file.source.uri : `data:${file.mime};base64,${file.data}`, + filename: file.name, + mime: file.mime, + })), + ).map((chunk) => ({ sessionUpdate: "user_message_chunk" as const, messageId: message.id, ...chunk })), + ] + if (message.type === "compaction") { + const update = ACPCompaction.replay(message, capabilities.compaction) + return update ? [update] : [] + } + if (message.type !== "assistant") return [] + // Live reasoning ordinals count only reasoning parts, not the mixed content array. + const reasoning = message.content.filter((part) => part.type === "reasoning") + return message.content.flatMap((part): SessionUpdate[] => { + if (part.type === "text") + return [ + { sessionUpdate: "agent_message_chunk", messageId: message.id, content: { type: "text", text: part.text } }, + ] + if (part.type === "reasoning") + return [ + { + sessionUpdate: "agent_thought_chunk", + messageId: ACPTranslate.reasoningMessageID(message.id, reasoning.indexOf(part)), + content: { type: "text", text: part.text }, + }, + ] + const call: SessionUpdate = { + sessionUpdate: "tool_call", + ...pendingToolCall({ + toolCallId: part.id, + toolName: part.name, + state: { input: part.state.status === "streaming" ? {} : part.state.input }, + cwd, + }), + } + switch (part.state.status) { + case "completed": + return [ + call, + { + sessionUpdate: "tool_call_update", + ...completedToolUpdate({ + toolCallId: part.id, + toolName: part.name, + input: part.state.input, + metadata: part.state.metadata, + content: part.state.content, + cwd, + }), + }, + ] + case "running": + return [ + call, + { + sessionUpdate: "tool_call_update", + ...runningToolUpdate({ toolCallId: part.id, toolName: part.name, state: { input: part.state.input }, cwd }), + }, + ] + case "error": + return [ + call, + { + sessionUpdate: "tool_call_update", + ...errorToolUpdate({ + toolCallId: part.id, + toolName: part.name, + input: part.state.input, + metadata: part.state.metadata, + content: part.state.content, + error: part.state.error.message, + cwd, + }), + }, + ] + case "streaming": + return [call] + } + }) +} + +export * as ACPReplay from "./replay" diff --git a/packages/cli/src/acp/service.ts b/packages/cli/src/acp/service.ts index 280c4454596..9c569980cc4 100644 --- a/packages/cli/src/acp/service.ts +++ b/packages/cli/src/acp/service.ts @@ -3,7 +3,7 @@ import { SessionsCursor } from "@opencode/protocol/groups/session" import { Model } from "@opencode/schema/model" import { AbsolutePath } from "@opencode/schema/schema" import { FSUtil } from "@opencode/util/fs-util" -import { DateTime, Effect, Option, Ref, Schema, Stream } from "effect" +import { DateTime, Effect, Ref, Schema } from "effect" import { withTimestampedFallback } from "@opencode/util/session-title-fallback" import type { AuthenticateRequest, @@ -27,7 +27,6 @@ import type { NewSessionResponse, PromptRequest, PromptResponse, - RequestError, ResumeSessionRequest, ResumeSessionResponse, SetSessionConfigOptionRequest, @@ -36,41 +35,34 @@ import type { SetSessionModeResponse, } from "@agentclientprotocol/sdk" import { OPENCODE_VERSION } from "../version" +import { ACPCapabilities, type Capabilities } from "./capabilities" import type { ACPCatalog, Catalog } from "./catalog" import { ACPClient } from "./client" import { configOptions, currentModel, DEFAULT_VARIANT_VALUE, parseModelSelection } from "./config-option" import type { ACPConnection } from "./connection" import { ACPDirectories } from "./directories" import { ACPError } from "./error" +import { ACPReplay } from "./replay" import type { ACPSessions, Attached, SupportedMcpServer } from "./sessions" -import { ACPTranslate } from "./translate" import type { ACPTurn } from "./turn" -export const AuthMethodID = "opencode-login" - -export type Failure = ACPError.Error | RequestError | ACPCatalog.Error - -export type Capabilities = { - readonly childSessionUpdates: boolean - readonly formElicitation: boolean - readonly compaction: boolean -} +const AuthMethodID = "opencode-login" export interface 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 deleteSession: (input: DeleteSessionRequest) => Effect.Effect - readonly resumeSession: (input: ResumeSessionRequest) => Effect.Effect - readonly closeSession: (input: CloseSessionRequest) => Effect.Effect - readonly forkSession: (input: ForkSessionRequest) => 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 deleteSession: (input: DeleteSessionRequest) => 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 prompt: (input: PromptRequest, signal: AbortSignal) => Effect.Effect + ) => Effect.Effect + readonly setSessionMode: (input: SetSessionModeRequest) => Effect.Effect + readonly prompt: (input: PromptRequest, signal: AbortSignal) => Effect.Effect readonly cancel: (input: CancelNotification) => Effect.Effect } @@ -86,7 +78,7 @@ export function make(input: { return configOptions(yield* input.catalog.get(attached.cwd), yield* Ref.get(attached.selection)) }) - const withReload = (attached: Attached, select: Effect.Effect) => { + const withReload = (attached: Attached, select: Effect.Effect) => { const retry = () => input.catalog.reload(attached.cwd).pipe(Effect.andThen(select)) return select.pipe( Effect.catchTags({ ACPInvalidModelError: retry, ACPInvalidModeError: retry, ACPInvalidEffortError: retry }), @@ -132,36 +124,9 @@ export function make(input: { return session }) - const replay = Effect.fnUntraced(function* (attached: Attached) { - const capabilities = yield* Ref.get(input.capabilities) - yield* Stream.paginate(undefined, (cursor: string | undefined) => - (cursor - ? input.client.message.list({ sessionID: attached.id, limit: 200, cursor }) - : input.client.message.list({ sessionID: attached.id, limit: 200, order: "asc" }) - ).pipe( - Effect.catch(ACPClient.classify), - Effect.map((page) => [page.data, Option.fromNullishOr(page.cursor.next)] as const), - ), - ).pipe( - Stream.runForEach((message) => - Effect.forEach( - ACPTranslate.replayMessage(message, attached.cwd, capabilities), - (update) => input.connection.sessionUpdate({ sessionId: attached.id, update }), - { discard: true }, - ), - ), - ) - }) - return { initialize: Effect.fnUntraced(function* (params) { - const elicitation = params.clientCapabilities?.elicitation - const compaction = params.clientCapabilities?.session?.compaction - yield* Ref.set(input.capabilities, { - childSessionUpdates: params.clientCapabilities?._meta?.[ACPTranslate.ChildSessionUpdatesCapability] === true, - formElicitation: elicitation?.form !== undefined && elicitation.form !== null, - compaction: compaction !== undefined && compaction !== null, - }) + yield* Ref.set(input.capabilities, ACPCapabilities.parse(params.clientCapabilities)) const authMethod: AuthMethod = { description: "Run `opencode auth login` in the terminal", name: "Login with opencode", @@ -179,7 +144,7 @@ export function make(input: { mcpCapabilities: { http: true, sse: false }, promptCapabilities: { embeddedContext: true, image: true }, sessionCapabilities: { additionalDirectories: {}, close: {}, delete: {}, fork: {}, list: {}, resume: {} }, - _meta: { [ACPTranslate.ChildSessionUpdatesCapability]: true }, + _meta: { [ACPCapabilities.ChildSessionUpdates]: true }, }, authMethods: [authMethod], agentInfo: { name: "OpenCode", version: OPENCODE_VERSION }, @@ -206,11 +171,16 @@ export function make(input: { 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, mcpServers)).attached - return yield* replay(attached).pipe( - Effect.andThen(currentOptions(attached)), + const attachment = yield* input.sessions.attach(session, session.location.directory, mcpServers) + return yield* ACPReplay.history( + input.client, + input.connection, + attachment.attached, + yield* Ref.get(input.capabilities), + ).pipe( + Effect.andThen(currentOptions(attachment.attached)), Effect.map((configOptions) => ({ configOptions })), - Effect.onError(() => input.sessions.release(attached)), + Effect.onError(() => input.sessions.release(attachment.attached)), ) }), listSessions: Effect.fnUntraced(function* (params) { diff --git a/packages/cli/src/acp/sessions.ts b/packages/cli/src/acp/sessions.ts index 5c174031ef2..d488624f690 100644 --- a/packages/cli/src/acp/sessions.ts +++ b/packages/cli/src/acp/sessions.ts @@ -1,9 +1,9 @@ import { isDeepStrictEqual } from "node:util" -import type { McpServer, RequestError, SessionConfigOption } from "@agentclientprotocol/sdk" +import type { McpServer, SessionConfigOption } from "@agentclientprotocol/sdk" import type { OpenCodeClient, OpenCodeEvent } from "@opencode/client/effect" import { Mcp } from "@opencode/schema/mcp" import type { Session } from "@opencode/schema/session" -import { Cause, Context, Deferred, Effect, Exit, Queue, Ref, Scope, Stream } from "effect" +import { Cause, 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" @@ -23,18 +23,13 @@ export interface Interface { session: Session.Info, cwd: string, mcpServers: readonly SupportedMcpServer[], - ) => Effect.Effect< - { readonly attached: Attached; readonly configOptions: SessionConfigOption[] }, - ACPError.Error | RequestError | ACPCatalog.Error - > + ) => Effect.Effect<{ readonly attached: Attached; readonly configOptions: SessionConfigOption[] }, ACPError.Failure> 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 } -export class Service extends Context.Service()("@opencode/cli/acp/Sessions") {} - type Entry = { readonly attached: Attached readonly scope: Scope.Closeable @@ -51,7 +46,7 @@ export const make = Effect.fnUntraced(function* (input: { const scope = yield* Effect.scope const sessions = new Map() // Outlives entries so re-attaching does not re-add servers. - const registeredMcp = new Map>() + const registeredMcpBySession = new Map>() const connected = yield* Deferred.make() // Subscribe before any attach so a switch right after `sessions.set` reaches the session. @@ -96,19 +91,18 @@ export const make = Effect.fnUntraced(function* (input: { const registerMcp = (attached: Attached, servers: readonly SupportedMcpServer[]) => Effect.suspend(() => { - const registered = registeredMcp.get(attached.id) ?? new Set() - registeredMcp.set(attached.id, registered) + const registered = registeredMcpBySession.get(attached.id) ?? new Map() + registeredMcpBySession.set(attached.id, registered) return Effect.forEach( servers, (server) => Effect.suspend(() => { const config = mcpConfig(server) - const key = `${server.name}:${stableStringify(config)}` - if (registered.has(key)) return Effect.void - registered.add(key) + if (isDeepStrictEqual(registered.get(server.name), config)) return Effect.void + registered.set(server.name, config) return input.client.mcp.add({ server: server.name, location: { directory: attached.cwd }, config }).pipe( Effect.catch(ACPClient.classify), - Effect.onError(() => Effect.sync(() => registered.delete(key))), + Effect.onError(() => Effect.sync(() => registered.delete(server.name))), Effect.uninterruptible, ) }), @@ -120,12 +114,12 @@ export const make = Effect.fnUntraced(function* (input: { Effect.suspend(() => { if (sessions.get(sessionID) === entry) { sessions.delete(sessionID) - registeredMcp.delete(sessionID) + registeredMcpBySession.delete(sessionID) } return Scope.close(entry.scope, Exit.void) }) - return Service.of({ + return { attach: Effect.fn("cli.acp.sessions.attach")(function* (session, cwd, mcpServers) { yield* Deferred.await(connected) const current = yield* input.catalog.get(cwd) @@ -175,7 +169,7 @@ export const make = Effect.fnUntraced(function* (input: { const entry = sessions.get(attached.id) if (entry?.attached === attached) yield* remove(attached.id, entry) }), - require: Effect.fn("cli.acp.sessions.require")(function* (sessionID) { + require: Effect.fnUntraced(function* (sessionID) { const entry = sessions.get(sessionID) if (!entry) return yield* new ACPError.SessionNotFoundError({ sessionId: sessionID }) return entry.attached @@ -185,7 +179,7 @@ export const make = Effect.fnUntraced(function* (input: { if (entry?.attached !== attached) return yield* new ACPError.SessionNotFoundError({ sessionId: attached.id }) yield* Effect.forkIn(effect, entry.scope, { startImmediately: true }) }), - }) + } satisfies Interface }) function mcpConfig(server: SupportedMcpServer) { @@ -204,13 +198,4 @@ function mcpConfig(server: SupportedMcpServer) { }) } -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(",")}}` -} - export * as ACPSessions from "./sessions" diff --git a/packages/cli/src/acp/tool.ts b/packages/cli/src/acp/tool.ts index 19095e1f758..fdbbd8da2e3 100644 --- a/packages/cli/src/acp/tool.ts +++ b/packages/cli/src/acp/tool.ts @@ -1,16 +1,13 @@ import { isAbsolute, resolve } from "node:path" import type { ToolCall, ToolCallContent, ToolCallLocation, ToolCallUpdate, ToolKind } from "@agentclientprotocol/sdk" +import type { Tool } from "@opencode/schema/tool" import { readDisplayText } from "@opencode/tui/mini/tool" import { Patch } from "@opencode/util/patch" import { Result } from "effect" export type ToolInput = Record -export type ToolContent = ReadonlyArray< - | { readonly type: "text"; readonly text: string } - | { readonly type: "file"; readonly uri: string; readonly mime: string; readonly name?: string | null } -> -export function toToolKind(toolName: string): ToolKind { +function toToolKind(toolName: string): ToolKind { switch (toolName.toLocaleLowerCase()) { case "bash": case "shell": @@ -85,18 +82,16 @@ export function pendingToolCall(input: { export function runningToolUpdate(input: { readonly toolCallId: string readonly toolName: string - readonly state: { readonly input: ToolInput; readonly title?: string } - readonly content?: ToolContent + readonly state: { readonly input: ToolInput } readonly cwd: string }): ToolCallUpdate { return { toolCallId: input.toolCallId, status: "in_progress", kind: toToolKind(input.toolName), - title: toolTitle(input.toolName, input.state.input, input.state.title), + title: toolTitle(input.toolName, input.state.input), locations: toLocations(input.toolName, input.state.input, input.cwd), rawInput: rawInput(input.toolName, input.state.input, input.cwd), - ...(input.content?.length ? { content: toolContent(input.content) } : {}), } } @@ -104,7 +99,7 @@ export function completedToolUpdate(input: { readonly toolCallId: string readonly toolName: string readonly input: ToolInput - readonly content: ToolContent + readonly content: ReadonlyArray readonly metadata?: Readonly> readonly cwd: string }): ToolCallUpdate { @@ -138,7 +133,7 @@ export function errorToolUpdate(input: { readonly toolCallId: string readonly toolName: string readonly input: ToolInput - readonly content?: ToolContent + readonly content?: ReadonlyArray readonly metadata?: Readonly> readonly error: string readonly cwd: string @@ -147,7 +142,7 @@ export function errorToolUpdate(input: { toolCallId: input.toolCallId, status: "failed", kind: toToolKind(input.toolName), - title: toolTitle(input.toolName, input.input, undefined), + title: toolTitle(input.toolName, input.input), locations: toLocations(input.toolName, input.input, input.cwd), rawInput: rawInput(input.toolName, input.input, input.cwd), content: [...toolContent(input.content ?? []), { type: "content", content: { type: "text", text: input.error } }], @@ -158,7 +153,7 @@ export function errorToolUpdate(input: { } } -function toolContent(content: ToolContent): ToolCallContent[] { +function toolContent(content: ReadonlyArray): ToolCallContent[] { return content.flatMap((part): ToolCallContent[] => { if (part.type === "text") return [{ type: "content", content: { type: "text", text: part.text } }] const match = /^data:([^;,]+)(?:;[^,]*)*;base64,(.*)$/.exec(part.uri) @@ -167,7 +162,7 @@ function toolContent(content: ToolContent): ToolCallContent[] { }) } -function toolTitle(toolName: string, input: ToolInput, fallback: string | undefined) { +function toolTitle(toolName: string, input: ToolInput, fallback?: string) { if (isShell(toolName)) return stringValue(input.command) ?? stringValue(input.cmd) ?? fallback ?? toolName return fallback || toolName } @@ -208,5 +203,3 @@ export function absolutePath(path: string, cwd: string) { export function stringValue(value: unknown) { return typeof value === "string" ? value : undefined } - -export * as ACPTool from "./tool" diff --git a/packages/cli/src/acp/translate.ts b/packages/cli/src/acp/translate.ts index 30b7f3b33bb..cb6ae5c9733 100644 --- a/packages/cli/src/acp/translate.ts +++ b/packages/cli/src/acp/translate.ts @@ -4,14 +4,11 @@ import type { Session } from "@opencode/schema/session" import type { SessionError } from "@opencode/schema/session-error" import type { SessionMessage } from "@opencode/schema/session-message" import { TokenUsage } from "@opencode/schema/token-usage" +import { ACPChild } from "./child" import { ACPCompaction } from "./compaction" -import { partsToContentChunks, type ReplayPart } from "./content" import { ACPError } from "./error" -import type { ACPService } from "./service" import { completedToolUpdate, errorToolUpdate, pendingToolCall, runningToolUpdate, type ToolInput } from "./tool" -export const ChildSessionUpdatesCapability = "opencode/child-session-updates" -export const ChildSessionUpdateMethod = "opencode/session/child_update" const RetryMeta = "opencode/retry" export type TurnStart = { readonly type: "input" | "compaction"; readonly id: SessionMessage.ID } @@ -42,35 +39,12 @@ type RetryStatus = { readonly error: SessionError.Error } -export type ChildSession = { - readonly id: string - readonly parentID: string - readonly depth: number - readonly title?: string -} - -type ChildSessionEvent = - | { readonly type: "update"; readonly update: SessionUpdate } - | { - readonly type: "status" - readonly status: "created" | "running" | "completed" | "failed" | "interrupted" - readonly error?: { readonly type: string; readonly message: string } - } - -export type ChildSessionUpdate = { - readonly rootSessionId: string - readonly childSessionId: string - readonly parentSessionId: string - readonly depth: number - readonly title?: string -} & ChildSessionEvent - export type TurnState = { readonly started: boolean readonly tools: ReadonlyMap readonly retries: ReadonlyMap readonly compactions: ACPCompaction.Tracked - readonly children: ReadonlyMap + readonly children: ReadonlyMap readonly openChildren: ReadonlySet readonly asks: ReadonlySet readonly finish?: SessionMessage.Assistant["finish"] @@ -84,22 +58,22 @@ type FormEvent = Extract export type Output = | { readonly _tag: "SessionUpdate"; readonly update: SessionUpdate } - | { readonly _tag: "ChildUpdate"; readonly update: ChildSessionUpdate } + | { readonly _tag: "ChildUpdate"; readonly update: ACPChild.Update } | { readonly _tag: "PermissionAsk" readonly event: PermissionEvent readonly tool?: Tool - readonly child?: ChildSession + readonly child?: ACPChild.Session } | { readonly _tag: "FormAsk" readonly form: FormEvent["data"]["form"] - readonly child?: ChildSession + readonly child?: ACPChild.Session readonly toolCallSent: boolean } | { readonly _tag: "AskSettled"; readonly id: string } -export type Step = { +type Step = { readonly state: TurnState readonly outputs: ReadonlyArray readonly terminal?: Terminal @@ -171,7 +145,8 @@ export function step(state: TurnState, event: OpenCodeEvent, ctx: Context): Step 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: [] } + if (event.type === "session.inbox.delivered" && event.data.inboxID === ctx.start.id) + return { state: { ...state, started: true }, outputs: [] } if (!state.started) return { state, outputs: [] } switch (event.type) { @@ -228,7 +203,7 @@ export function step(state: TurnState, event: OpenCodeEvent, ctx: Context): Step state, outputs: send({ sessionUpdate: "agent_thought_chunk", - messageId: `${event.data.assistantMessageID}:reasoning:${event.data.ordinal}`, + messageId: reasoningMessageID(event.data.assistantMessageID, event.data.ordinal), content: { type: "text", text: event.data.delta }, }), } @@ -405,126 +380,31 @@ export function abandon(state: TurnState, ctx: Context): Step { } } -export function* replayMessage( - message: SessionMessage.Info, - cwd: string, - capabilities: ACPService.Capabilities, -): Generator { - if (message.type === "user") { - yield { sessionUpdate: "user_message_chunk", messageId: message.id, content: { type: "text", text: message.text } } - const files: ReplayPart[] = (message.files ?? []).map((file) => ({ - type: "file", - url: file.source.type === "uri" ? file.source.uri : `data:${file.mime};base64,${file.data}`, - filename: file.name, - mime: file.mime, - })) - for (const chunk of partsToContentChunks(files)) - yield { sessionUpdate: "user_message_chunk", messageId: message.id, ...chunk } - return - } - if (message.type === "compaction") { - const update = ACPCompaction.replay(message, capabilities.compaction) - if (update) yield update - return - } - if (message.type !== "assistant") return - // Live reasoning ordinals count only reasoning parts, not the mixed content array. - let reasoningOrdinal = 0 - for (const part of message.content) { - if (part.type === "text") { - yield { sessionUpdate: "agent_message_chunk", messageId: message.id, content: { type: "text", text: part.text } } - continue - } - if (part.type === "reasoning") { - yield { - sessionUpdate: "agent_thought_chunk", - messageId: `${message.id}:reasoning:${reasoningOrdinal++}`, - content: { type: "text", text: part.text }, - } - continue - } - yield { - sessionUpdate: "tool_call", - ...pendingToolCall({ - toolCallId: part.id, - toolName: part.name, - state: { input: part.state.status === "streaming" ? {} : part.state.input }, - cwd, - }), - } - switch (part.state.status) { - case "completed": - yield { - sessionUpdate: "tool_call_update", - ...completedToolUpdate({ - toolCallId: part.id, - toolName: part.name, - input: part.state.input, - metadata: part.state.metadata, - content: part.state.content, - cwd, - }), - } - break - case "running": - yield { - sessionUpdate: "tool_call_update", - ...runningToolUpdate({ toolCallId: part.id, toolName: part.name, state: { input: part.state.input }, cwd }), - } - break - case "error": - yield { - sessionUpdate: "tool_call_update", - ...errorToolUpdate({ - toolCallId: part.id, - toolName: part.name, - input: part.state.input, - metadata: part.state.metadata, - content: part.state.content, - error: part.state.error.message, - cwd, - }), - } - break - case "streaming": - break - } - } +export function reasoningMessageID(messageID: string, ordinal: number) { + return `${messageID}:reasoning:${ordinal}` } function newTool(sessionID: string, id: string, name = "tool"): Tool { return { sessionID, id, name, input: {}, metadata: {} } } -function route(ctx: Context, child: ChildSession | undefined, update: SessionUpdate): Output[] { +function route(ctx: Context, child: ACPChild.Session | undefined, update: SessionUpdate): Output[] { if (!child) return ctx.mode === "turn" ? [{ _tag: "SessionUpdate", update }] : [] - const projected = projectChildUpdate(update, child) + const projected = ACPChild.project(update, child) if (ctx.childUpdates) return childStatus(ctx, child, { type: "update", update: projected }) return ctx.mode === "turn" ? [{ _tag: "SessionUpdate", update: projected }] : [] } -function childStatus(ctx: Context, child: ChildSession, value: ChildSessionEvent): Output[] { +function childStatus(ctx: Context, child: ACPChild.Session, event: ACPChild.Event): Output[] { if (!ctx.childUpdates) return [] - return [ - { - _tag: "ChildUpdate", - update: { - rootSessionId: ctx.sessionID, - childSessionId: child.id, - parentSessionId: child.parentID, - depth: child.depth, - ...(child.title ? { title: child.title } : {}), - ...value, - }, - }, - ] + return [{ _tag: "ChildUpdate", update: ACPChild.update(ctx.sessionID, child, event) }] } function childEnded( state: TurnState, ctx: Context, - child: ChildSession, - status: ChildSessionEvent, + child: ACPChild.Session, + status: ACPChild.Event, terminal: Terminal, ): Step { const openChildren = new Set(state.openChildren) @@ -570,31 +450,6 @@ function toolKey(sessionID: string, id: string) { return `${sessionID}:${id}` } -function projectChildUpdate(update: SessionUpdate, child: ChildSession) { - const projected = { ...update } - projected._meta = { ...projected._meta, ...childSessionMeta(child) } - if (projected.sessionUpdate === "tool_call" || projected.sessionUpdate === "tool_call_update") { - projected.toolCallId = `${child.id}:${projected.toolCallId}` - if (projected.title && child.title) projected.title = `${child.title}: ${projected.title}` - } - return projected -} - -export function childSessionMeta(child: ChildSession) { - return { - "opencode/child-session": { - id: child.id, - parentID: child.parentID, - depth: child.depth, - ...(child.title ? { title: child.title } : {}), - }, - } -} - -function matchesStart(event: OpenCodeEvent, start: TurnStart) { - return event.type === "session.inbox.delivered" && event.data.inboxID === start.id -} - function resolveStopReason(input: { readonly terminal: Terminal readonly finish: SessionMessage.Assistant["finish"] diff --git a/packages/cli/src/acp/turn.ts b/packages/cli/src/acp/turn.ts index 6915420d06d..be4ea7d0ede 100644 --- a/packages/cli/src/acp/turn.ts +++ b/packages/cli/src/acp/turn.ts @@ -1,7 +1,6 @@ import type { CancelNotification, PromptRequest, PromptResponse, RequestError } from "@agentclientprotocol/sdk" import type { OpenCodeClient, OpenCodeEvent } from "@opencode/client/effect" import type { Command } from "@opencode/schema/command" -import type { Session } from "@opencode/schema/session" import { SessionMessage } from "@opencode/schema/session-message" import { TokenUsage } from "@opencode/schema/token-usage" import { @@ -21,7 +20,9 @@ import { } from "effect" import { access, constants } from "node:fs/promises" import { fileURLToPath } from "node:url" +import type { Capabilities } from "./capabilities" import { builtinCommands, type ACPCatalog, type Catalog } from "./catalog" +import { ACPChild } from "./child" import { ACPClient } from "./client" import { currentModel } from "./config-option" import type { ACPConnection } from "./connection" @@ -29,21 +30,16 @@ import { linkReference, promptContentToParts, type PromptPart } from "./content" import { ACPElicitation } from "./elicitation" import { ACPError } from "./error" import { ACPPermission } from "./permission" -import type { ACPService } from "./service" import type { ACPSessions, Attached } from "./sessions" import { ACPTranslate } from "./translate" -type Failure = ACPError.Error | RequestError | ACPCatalog.Error - export interface Interface { - readonly prompt: (input: PromptRequest, signal: AbortSignal) => Effect.Effect + readonly prompt: (input: PromptRequest, signal: AbortSignal) => Effect.Effect readonly cancel: (input: CancelNotification) => Effect.Effect /** Unlike `cancel`, interrupts an idle session too, since server work can outlive its turn. */ readonly close: (sessionID: string) => Effect.Effect } -export class Service extends Context.Service()("@opencode/cli/acp/Turn") {} - /** Core acknowledges an interrupt before its cleanup settles, and its shell tool waits 3s before SIGKILL. */ export const CancelDrainTimeout = Context.Reference("@opencode/cli/acp/Turn/CancelDrainTimeout", { defaultValue: () => "5 seconds", @@ -74,11 +70,11 @@ export const make = Effect.fnUntraced(function* (input: { readonly connection: ACPConnection.Interface readonly sessions: ACPSessions.Interface readonly catalog: ACPCatalog.Interface - readonly capabilities: Ref.Ref + readonly capabilities: Ref.Ref }) { const scope = yield* Effect.scope const drainTimeout = yield* CancelDrainTimeout - const turns = yield* FiberMap.make() + const turns = yield* FiberMap.make() const subscribe = Effect.fnUntraced(function* () { // Parented to the service scope; the session scope may already be closed. @@ -143,7 +139,7 @@ export const make = Effect.fnUntraced(function* (input: { return input.connection.sessionUpdate({ sessionId: ctx.sessionID, update: output.update }) case "ChildUpdate": return input.connection - .extNotification(ACPTranslate.ChildSessionUpdateMethod, output.update) + .extNotification(ACPChild.UpdateMethod, output.update) .pipe( Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) @@ -244,23 +240,20 @@ export const make = Effect.fnUntraced(function* (input: { .pipe(Effect.catch(ACPClient.classify)) }) - const interruptServer = (sessionID: Session.ID) => - input.client.session - .interrupt({ sessionID }) + const windDown = Effect.fnUntraced(function* ( + subscription: Subscription, + ctx: ACPTranslate.Context, + state: Ref.Ref, + events: Fiber.Fiber, + ) { + yield* Deferred.succeed(subscription.cancelled, undefined) + yield* input.client.session + .interrupt({ sessionID: ctx.sessionID }) .pipe( Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logWarning("ACP server interrupt failed", cause), ), ) - - const windDown = Effect.fnUntraced(function* ( - subscription: Subscription, - ctx: ACPTranslate.Context, - state: Ref.Ref, - events: Fiber.Fiber, - ) { - yield* Deferred.succeed(subscription.cancelled, undefined) - yield* interruptServer(ctx.sessionID) if (!(yield* Ref.get(state)).started) return if (Option.exists(yield* Fiber.await(events).pipe(Effect.timeoutOption(drainTimeout)), Exit.isSuccess)) return yield* Fiber.interrupt(events) @@ -300,7 +293,7 @@ export const make = Effect.fnUntraced(function* (input: { subscription: Subscription, ctx: ACPTranslate.Context, state: Ref.Ref, - exit: Exit.Exit, + exit: Exit.Exit, ) { const close = Scope.close(subscription.scope, Exit.void) if (Exit.isFailure(exit) && !Cause.hasInterruptsOnly(exit.cause)) return yield* close @@ -318,7 +311,7 @@ export const make = Effect.fnUntraced(function* (input: { const settle = Effect.fnUntraced(function* ( attached: Attached, state: Ref.Ref, - exit: Exit.Exit, + exit: Exit.Exit, ) { if (Exit.isFailure(exit) && !Cause.hasInterrupts(exit.cause)) return yield* Effect.failCause(exit.cause) const current = yield* Ref.get(state) @@ -368,8 +361,8 @@ export const make = Effect.fnUntraced(function* (input: { return yield* settle(attached, state, exit) }) - return Service.of({ - prompt: Effect.fn("cli.acp.turn.prompt")(function* (params, signal) { + return { + prompt: Effect.fnUntraced(function* (params, signal) { const attached = yield* input.sessions.require(params.sessionId) const catalog = yield* input.catalog.get(attached.cwd) if (params.prompt.some((block) => block.type === "image" && !block.data && !block.uri)) { @@ -397,7 +390,7 @@ export const make = Effect.fnUntraced(function* (input: { yield* aborted(signal).pipe(Effect.andThen(Fiber.interrupt(turn)), Effect.forkChild) return yield* Fiber.join(turn) }), - cancel: Effect.fn("cli.acp.turn.cancel")(function* (params) { + cancel: Effect.fnUntraced(function* (params) { yield* FiberMap.remove(turns, params.sessionId) }), close: Effect.fn("cli.acp.turn.close")(function* (sessionID) { @@ -408,7 +401,7 @@ export const make = Effect.fnUntraced(function* (input: { Effect.catch(ACPClient.classify), ) }), - }) + } satisfies Interface }) function aborted(signal: AbortSignal) { @@ -427,8 +420,17 @@ function preparePrompt(catalog: Catalog, parts: readonly PromptPart[], messageID const files = visible.flatMap((part) => (part.type === "file" ? [{ uri: part.url, name: part.filename }] : [])) const slash = detectSlashCommand(text) const command = slash ? catalog.commands.find((item) => item.name === slash.name) : undefined - const start = turnStart(messageID, slash) - return { start, text, files, synthetic, slash, command } + return { + start: + slash && builtinCommands.get(slash.name)?.start === "compaction" + ? { type: "compaction", id: messageID } + : { type: "input", id: messageID }, + text, + files, + synthetic, + slash, + command, + } } function referenceUnreadableFile(part: PromptPart) { @@ -439,12 +441,7 @@ function referenceUnreadableFile(part: PromptPart) { ) } -function turnStart(messageID: SessionMessage.ID, slash: PreparedPrompt["slash"]): ACPTranslate.TurnStart { - if (slash && builtinCommands.get(slash.name)?.start === "compaction") return { type: "compaction", id: messageID } - return { type: "input", id: messageID } -} - -function detectSlashCommand(text: string): { readonly name: string; readonly args: string } | undefined { +function detectSlashCommand(text: string) { const value = text.trim() if (!value.startsWith("/")) return undefined const [name, ...rest] = value.slice(1).split(/\s+/) diff --git a/packages/cli/test/acp/session.test.ts b/packages/cli/test/acp/session.test.ts index 46a68e9c704..9f95f9bdfc8 100644 --- a/packages/cli/test/acp/session.test.ts +++ b/packages/cli/test/acp/session.test.ts @@ -137,19 +137,28 @@ describe("acp session lifecycle over the wire", () => { const first = await acp.newSession("/workspace", [local, local, remote]) await acp.request("session/resume", { cwd: "/workspace", sessionId: first.sessionId, mcpServers: [local, remote] }) await acp.request("session/resume", { cwd: "/workspace", sessionId: first.sessionId, mcpServers: [changed] }) - await acp.newSession("/workspace", [local]) + await acp.request("session/resume", { cwd: "/workspace", sessionId: first.sessionId, mcpServers: [local] }) const localConfig = (args: string[]) => ({ name: "tools", directory: "/workspace", config: { type: "local", command: ["bun", ...args], environment: { TOKEN: "x" } }, }) - expect(acp.server.mcp).toHaveLength(4) expect(acp.server.mcp.filter((item) => item.name === "tools")).toEqual([ localConfig(["server.ts"]), localConfig(["changed.ts"]), localConfig(["server.ts"]), ]) + + await acp.newSession("/workspace", [local]) + + expect(acp.server.mcp).toHaveLength(5) + expect(acp.server.mcp.filter((item) => item.name === "tools")).toEqual([ + localConfig(["server.ts"]), + localConfig(["changed.ts"]), + localConfig(["server.ts"]), + localConfig(["server.ts"]), + ]) expect(acp.server.mcp.find((item) => item.name === "docs")).toEqual({ name: "docs", directory: "/workspace", diff --git a/packages/cli/test/acp/translate.test.ts b/packages/cli/test/acp/translate.test.ts index be664c70fe0..4225442460f 100644 --- a/packages/cli/test/acp/translate.test.ts +++ b/packages/cli/test/acp/translate.test.ts @@ -4,6 +4,7 @@ import { Session } from "@opencode/schema/session" import { SessionMessage } from "@opencode/schema/session-message" import { Schema } from "effect" import path from "node:path" +import { ACPReplay } from "../../src/acp/replay" import { ACPTranslate } from "../../src/acp/translate" import { assistantMessage, @@ -629,7 +630,7 @@ function translate(row: Row) { } return { updates: row.messages.flatMap((message) => [ - ...ACPTranslate.replayMessage(decodeMessage(message), context.cwd, capabilities), + ...ACPReplay.updates(decodeMessage(message), context.cwd, capabilities), ]), } }