feat(cli): expand acp v1 support

bun.lock

@@ -124,7 +124,7 @@
         "opencode2": "./bin/opencode2.cjs",
       },
       "dependencies": {
-        "@agentclientprotocol/sdk": "0.21.0",
+        "@agentclientprotocol/sdk": "1.2.1",
         "@effect/platform-node": "catalog:",
         "@opencode-ai/client": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
@@ -1173,7 +1173,7 @@
 
     "@adobe/css-tools": ["@adobe/css-tools@4.5.0", "", {}, "sha512-6OzddxPio9UiWTCemp4N8cYLV2ZN1ncRnV1cVGtve7dhPOtRkleRyx32GQCYSwDYgaHU3USMm84tNsvKzRCa1Q=="],
 
-    "@agentclientprotocol/sdk": ["@agentclientprotocol/sdk@0.21.0", "", { "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" } }, "sha512-ONj+Q8qOdNQp5XbH5jnMwzT9IKZJsSN0p0lkceS4GtUtNOPVLpNzSS8gqQdGMKfBvA0ESbkL8BTaSN1Rc9miEw=="],
+    "@agentclientprotocol/sdk": ["@agentclientprotocol/sdk@1.2.1", "", { "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" } }, "sha512-jwYUdOQR7tc+Zfch53VL4JJyUNK/46q03uUTYb+PjECsmnNl94XFXOfYLJ8RBpMNidXd1rpOAVgb0vqD98xImA=="],
 
     "@ai-sdk/alibaba": ["@ai-sdk/alibaba@1.0.17", "", { "dependencies": { "@ai-sdk/openai-compatible": "2.0.41", "@ai-sdk/provider": "3.0.8", "@ai-sdk/provider-utils": "4.0.23" }, "peerDependencies": { "zod": "^3.25.76 || ^4.1.8" } }, "sha512-ZbE+U5bWz2JBc5DERLowx5+TKbjGBE93LqKZAWvuEn7HOSQMraxFMZuc0ST335QZJAyfBOzh7m1mPQ+y7EaaoA=="],
 

packages/cli/package.json

@@ -22,7 +22,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "0.21.0",
+    "@agentclientprotocol/sdk": "1.2.1",
     "@effect/platform-node": "catalog:",
     "@opencode-ai/client": "workspace:*",
     "@opencode-ai/plugin": "workspace:*",

packages/cli/src/acp/agent.ts

@@ -5,6 +5,7 @@ import {
   type AuthenticateRequest,
   type CancelNotification,
   type CloseSessionRequest,
+  type DeleteSessionRequest,
   type ForkSessionRequest,
   type InitializeRequest,
   type ListSessionsRequest,
@@ -13,7 +14,6 @@ import {
   type PromptRequest,
   type ResumeSessionRequest,
   type SetSessionConfigOptionRequest,
-  type SetSessionModelRequest,
   type SetSessionModeRequest,
 } from "@agentclientprotocol/sdk"
 import type { OpenCodeClient } from "@opencode-ai/client/promise"
@@ -28,12 +28,12 @@ export function create(client: OpenCodeClient, connection: AgentSideConnection)
     newSession: (params: NewSessionRequest) => run(service.newSession(params)),
     loadSession: (params: LoadSessionRequest) => run(service.loadSession(params)),
     listSessions: (params: ListSessionsRequest) => run(service.listSessions(params)),
+    deleteSession: (params: DeleteSessionRequest) => run(service.deleteSession(params)),
     resumeSession: (params: ResumeSessionRequest) => run(service.resumeSession(params)),
     closeSession: (params: CloseSessionRequest) => run(service.closeSession(params)),
     unstable_forkSession: (params: ForkSessionRequest) => run(service.forkSession(params)),
     setSessionConfigOption: (params: SetSessionConfigOptionRequest) => run(service.setSessionConfigOption(params)),
     setSessionMode: (params: SetSessionModeRequest) => run(service.setSessionMode(params)),
-    unstable_setSessionModel: (params: SetSessionModelRequest) => run(service.setSessionModel(params)),
     prompt: (params: PromptRequest) => run(service.prompt(params)),
     cancel: (params: CancelNotification) => run(service.cancel(params)),
   } satisfies Agent

packages/cli/src/acp/event.ts

@@ -47,7 +47,7 @@ export async function streamTurn(input: {
   readonly sessionID: string
   readonly cwd: string
   readonly start: TurnStart
-  readonly userMessageID?: string | null
+  readonly writeTextFile: boolean
   readonly submit: (signal: AbortSignal) => Promise<unknown>
   readonly control: TurnControl
 }): Promise<PromptResponse> {
@@ -170,6 +170,7 @@ export async function streamTurn(input: {
         tools.delete(event.data.callID)
         await syncEditedFiles({
           connection: input.connection,
+          writeTextFile: input.writeTextFile,
           sessionID: input.sessionID,
           cwd: input.cwd,
           toolName: current.name,
@@ -231,7 +232,7 @@ export async function streamTurn(input: {
       if (!started) {
         streamController.abort()
         await completed.catch(() => {})
-        return response(undefined, undefined, "interrupted", true, undefined, input.userMessageID)
+        return response(undefined, undefined, "interrupted", true, undefined)
       }
     }
     const terminal = await completed
@@ -246,7 +247,6 @@ export async function streamTurn(input: {
       terminal,
       control.cancelled,
       finish,
-      input.userMessageID,
     )
   } catch (error) {
     streamController.abort()
@@ -400,7 +400,6 @@ function response(
   terminal: "succeeded" | "failed" | "interrupted",
   cancelled: boolean,
   finish: SessionMessageAssistant["finish"],
-  messageID: string | null | undefined,
 ): PromptResponse {
   const error = assistant?.error ?? executionError
   if (error?.type === "provider.auth") throw new ACPError.AuthRequiredError()
@@ -423,7 +422,7 @@ function response(
       }
     : undefined
   const stopReason = resolveStopReason({ terminal, cancelled, finish, error: error?.type })
-  return { stopReason, ...(usage ? { usage } : {}), ...(messageID ? { userMessageId: messageID } : {}), _meta: {} }
+  return { stopReason, ...(usage ? { usage } : {}), _meta: {} }
 }
 
 function resolveStopReason(input: {

packages/cli/src/acp/permission.ts

@@ -53,13 +53,14 @@ export async function replyPermission(input: {
 
 export async function syncEditedFiles(input: {
   readonly connection: Partial<Pick<AgentSideConnection, "writeTextFile">>
+  readonly writeTextFile: boolean
   readonly sessionID: string
   readonly cwd: string
   readonly toolName: string
   readonly toolInput: ToolInput
   readonly structured: Readonly<Record<string, unknown>>
 }) {
-  if (!input.connection.writeTextFile || toToolKind(input.toolName) !== "edit") return
+  if (!input.writeTextFile || !input.connection.writeTextFile || toToolKind(input.toolName) !== "edit") return
   const files = Array.isArray(input.structured.files)
     ? input.structured.files.flatMap((file): string[] => {
         if (!file || typeof file !== "object") return []

packages/cli/src/acp/service.ts

@@ -16,6 +16,8 @@ import type {
   CancelNotification,
   CloseSessionRequest,
   CloseSessionResponse,
+  DeleteSessionRequest,
+  DeleteSessionResponse,
   ForkSessionRequest,
   ForkSessionResponse,
   InitializeRequest,
@@ -33,8 +35,6 @@ import type {
   ResumeSessionResponse,
   SetSessionConfigOptionRequest,
   SetSessionConfigOptionResponse,
-  SetSessionModelRequest,
-  SetSessionModelResponse,
   SetSessionModeRequest,
   SetSessionModeResponse,
 } from "@agentclientprotocol/sdk"
@@ -47,7 +47,8 @@ import { ACPError } from "./error"
 
 export const AuthMethodID = "opencode-login"
 
-type Connection = Pick<AgentSideConnection, "sessionUpdate" | "requestPermission">
+type Connection = Pick<AgentSideConnection, "sessionUpdate" | "requestPermission"> &
+  Partial<Pick<AgentSideConnection, "writeTextFile">>
 
 type Catalog = {
   readonly providers: ConfigOptionProvider[]
@@ -83,12 +84,12 @@ export interface Interface {
   newSession(input: NewSessionRequest): Promise<NewSessionResponse>
   loadSession(input: LoadSessionRequest): Promise<LoadSessionResponse>
   listSessions(input: ListSessionsRequest): Promise<ListSessionsResponse>
+  deleteSession(input: DeleteSessionRequest): Promise<DeleteSessionResponse>
   resumeSession(input: ResumeSessionRequest): Promise<ResumeSessionResponse>
   closeSession(input: CloseSessionRequest): Promise<CloseSessionResponse>
   forkSession(input: ForkSessionRequest): Promise<ForkSessionResponse>
   setSessionConfigOption(input: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>
   setSessionMode(input: SetSessionModeRequest): Promise<SetSessionModeResponse>
-  setSessionModel(input: SetSessionModelRequest): Promise<SetSessionModelResponse>
   prompt(input: PromptRequest): Promise<PromptResponse>
   cancel(input: CancelNotification): Promise<void>
 }
@@ -98,6 +99,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
   const catalogs = new Map<string, Promise<Catalog>>()
   const registeredMcp = new Map<string, Set<string>>()
   const active = new Map<string, TurnControl>()
+  const capabilities = { writeTextFile: false }
 
   const catalog = (cwd: string) => {
     const cached = catalogs.get(cwd)
@@ -157,6 +159,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
 
   return {
     initialize: async (params) => {
+      capabilities.writeTextFile = params.clientCapabilities?.fs?.writeTextFile === true
       const authMethod: AuthMethod = {
         description: "Run `opencode auth login` in the terminal",
         name: "Login with opencode",
@@ -173,7 +176,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
           loadSession: true,
           mcpCapabilities: { http: true, sse: false },
           promptCapabilities: { embeddedContext: true, image: true },
-          sessionCapabilities: { close: {}, fork: {}, list: {}, resume: {} },
+          sessionCapabilities: { close: {}, delete: {}, fork: {}, list: {}, resume: {} },
         },
         authMethods: [authMethod],
         agentInfo: { name: "OpenCode", version: OPENCODE_VERSION },
@@ -216,6 +219,14 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
         ...(page.cursor.next ? { nextCursor: page.cursor.next } : {}),
       }
     },
+    deleteSession: async (params) => {
+      await input.client.session.remove({ sessionID: params.sessionId }).catch((error) => {
+        if (!isSessionNotFoundError(error)) throw error
+      })
+      sessions.delete(params.sessionId)
+      registeredMcp.delete(params.sessionId)
+      return {}
+    },
     resumeSession: async (params) => {
       const session = await getSession(input.client, params.sessionId)
       const state = await attach(session, session.location.directory, params.mcpServers ?? [])
@@ -270,13 +281,6 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
       await selectMode(input.client, await requireSession(params.sessionId), params.modeId)
       return {}
     },
-    setSessionModel: async (params) => {
-      const state = await requireSession(params.sessionId)
-      const selected = requireModel(state.catalog, params.modelId)
-      state.model = selected
-      await input.client.session.switchModel({ sessionID: state.id, model: selected })
-      return {}
-    },
     prompt: async (params) => {
       const state = await requireSession(params.sessionId)
       if (active.has(state.id)) {
@@ -295,7 +299,7 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
         sessionID: state.id,
         cwd: state.cwd,
         start: prepared.start,
-        userMessageID: params.messageId,
+        writeTextFile: capabilities.writeTextFile,
         control,
         submit: (signal) => submitPrompt(input.client, state, prepared, signal),
       }).finally(() => {
@@ -479,6 +483,7 @@ async function registerMcpServers(
 
 function mcpConfig(server: McpServer) {
   if ("type" in server) {
+    if (server.type === "acp") throw new Error("MCP-over-ACP is not supported")
     return {
       type: "remote" as const,
       url: server.url,

packages/cli/test/acp/event-behavior.test.ts

@@ -437,6 +437,7 @@ describe("acp event behavior", () => {
       sessionID: "ses_cancel",
       cwd: "/workspace",
       start: { type: "input", id: "input_cancel" },
+      writeTextFile: false,
       control,
       submit: async (signal) => {
         await fixture.client.session.prompt(
@@ -479,6 +480,7 @@ describe("acp event behavior", () => {
       sessionID: "ses_cancel_admission",
       cwd: "/workspace",
       start: { type: "input", id: "input_cancel_admission" },
+      writeTextFile: false,
       control,
       submit: (signal) =>
         fixture.client.session.prompt(
@@ -564,7 +566,7 @@ function turn(input: {
     sessionID: input.sessionID,
     cwd: "/workspace",
     start: { type: "input", id: input.inputID },
-    userMessageID: `client_${input.inputID}`,
+    writeTextFile: false,
     control: { cancelled: false, admission: new AbortController() },
     submit: (signal) =>
       input.fixture.client.session.prompt({ sessionID: input.sessionID, id: input.inputID, text: "hello" }, { signal }),

packages/cli/test/acp/event.test.ts

@@ -85,7 +85,6 @@ test("acp prompt resolves after ordered turn updates", async () => {
 
   try {
     const id = "msg_prompt"
-    const userMessageID = "client-message"
     const response = await streamTurn({
       client,
       connection: {
@@ -97,7 +96,7 @@ test("acp prompt resolves after ordered turn updates", async () => {
       sessionID: "ses_test",
       cwd: "/workspace",
       start: { type: "input", id },
-      userMessageID,
+      writeTextFile: false,
       control: { cancelled: false, admission: new AbortController() },
       submit: () => client.session.prompt({ sessionID: "ses_test", id, text: "hi" }),
     })
@@ -112,7 +111,7 @@ test("acp prompt resolves after ordered turn updates", async () => {
         },
       },
     ])
-    expect(response).toMatchObject({ stopReason: "end_turn", userMessageId: userMessageID, usage: { totalTokens: 2 } })
+    expect(response).toMatchObject({ stopReason: "end_turn", usage: { totalTokens: 2 } })
   } finally {
     events?.close()
     await server.stop(true)

packages/cli/test/acp/initialize-auth.subprocess.test.ts

@@ -14,6 +14,7 @@ describe("acp initialize/auth subprocess", () => {
     expect(initialized.agentCapabilities?.mcpCapabilities?.sse).toBe(false)
     expect(initialized.agentCapabilities?.loadSession).toBe(true)
     expect(initialized.agentCapabilities?.sessionCapabilities?.close).toEqual({})
+    expect(initialized.agentCapabilities?.sessionCapabilities?.delete).toEqual({})
     expect(initialized.agentCapabilities?.sessionCapabilities?.fork).toEqual({})
     expect(initialized.agentCapabilities?.sessionCapabilities?.list).toEqual({})
     expect(initialized.agentCapabilities?.sessionCapabilities?.resume).toEqual({})

packages/cli/test/acp/lifecycle.subprocess.test.ts

@@ -1,5 +1,6 @@
 import type {
   CloseSessionResponse,
+  DeleteSessionResponse,
   ListSessionsResponse,
   LoadSessionResponse,
   ResumeSessionResponse,
@@ -60,6 +61,20 @@ describe("acp lifecycle subprocess", () => {
     expect(listed.sessions.some((item) => item.sessionId === session.sessionId)).toBe(true)
   }, 60_000)
 
+  test("delete capability and delete request", async () => {
+    await using fixture = await createAcpFixture()
+    const acp = fixture.spawn()
+    const initialized = await initialize(acp)
+    expect(initialized.agentCapabilities?.sessionCapabilities?.delete).toEqual({})
+    const session = await newSession(acp, fixture.home)
+
+    expect(
+      expectOk(await acp.request<DeleteSessionResponse>("session/delete", { sessionId: session.sessionId })),
+    ).toEqual({})
+    const listed = expectOk(await acp.request<ListSessionsResponse>("session/list", { cwd: fixture.home }))
+    expect(listed.sessions.some((item) => item.sessionId === session.sessionId)).toBe(false)
+  }, 60_000)
+
   test("resume capability advertisement", async () => {
     await using fixture = await createAcpFixture()
     const initialized = await initialize(fixture.spawn())

packages/cli/test/acp/permission-behavior.test.ts

@@ -4,6 +4,7 @@ import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
 import { streamTurn } from "../../src/acp/event"
+import { syncEditedFiles } from "../../src/acp/permission"
 import { createSseFixture, durableEvent, ephemeralEvent, withTimeout } from "./sse-fixture"
 
 type SessionUpdateParams = Parameters<AgentSideConnection["sessionUpdate"]>[0]
@@ -12,6 +13,27 @@ type Connection = Pick<AgentSideConnection, "sessionUpdate" | "requestPermission
 type Fixture = ReturnType<typeof createSseFixture>
 
 describe("acp permission behavior", () => {
+  test("does not sync edits when writeTextFile was not advertised", async () => {
+    const writes: Parameters<AgentSideConnection["writeTextFile"]>[0][] = []
+
+    await syncEditedFiles({
+      connection: {
+        writeTextFile: async (input) => {
+          writes.push(input)
+          return {}
+        },
+      },
+      writeTextFile: false,
+      sessionID: "ses_no_write",
+      cwd: "/workspace",
+      toolName: "edit",
+      toolInput: { filePath: "/workspace/file.ts" },
+      structured: {},
+    })
+
+    expect(writes).toEqual([])
+  })
+
   test("forwards allow-once and allow-always selections to the generated client", async () => {
     const permissionRequests: RequestPermissionRequest[] = []
     const fixture = createSseFixture({
@@ -465,6 +487,7 @@ function startTurn(fixture: Fixture, connection: Connection, sessionID: string,
     sessionID,
     cwd,
     start: { type: "input", id: inputID },
+    writeTextFile: true,
     control: { cancelled: false, admission: new AbortController() },
     submit: (signal) => fixture.client.session.prompt({ sessionID, id: inputID, text: "hello" }, { signal }),
   })

packages/cli/test/acp/service-directory.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import type { McpServer, SessionConfigOption } from "@agentclientprotocol/sdk"
-import { makeACPFixture, makeSession, secondModel, testModel } from "./service-fixture"
+import { makeACPFixture, makeSession, secondModel } from "./service-fixture"
 
 describe("acp service directory behavior", () => {
   test("creates sessions from a catalog shared by concurrent callers in the same cwd", async () => {
@@ -134,7 +134,6 @@ describe("acp service directory behavior", () => {
       configId: "mode",
       value: "plan",
     })
-    await fixture.service.setSessionModel({ sessionId: session.sessionId, modelId: "test/test-model/high" })
     await fixture.service.setSessionMode({ sessionId: session.sessionId, modeId: "build" })
 
     expect(currentValue(selectedModel, "model")).toBe("test/second-model")
@@ -148,7 +147,6 @@ describe("acp service directory behavior", () => {
     ).toEqual([
       { model: { providerID: "test", id: secondModel.id } },
       { model: { providerID: "test", id: secondModel.id, variant: "medium" } },
-      { model: { providerID: "test", id: testModel.id, variant: "high" } },
     ])
     expect(
       fixture.requests

packages/cli/test/acp/service-lifecycle.test.ts

@@ -225,6 +225,33 @@ describe("acp service lifecycle", () => {
       "/api/session/missing/interrupt",
     ])
   })
+
+  test("deletes sessions from backing and local storage", async () => {
+    await using fixture = makeACPFixture({
+      fetch(request) {
+        if (request.method === "POST" && request.path === "/api/session") {
+          return Response.json({ data: makeSession("ses_delete") })
+        }
+        if (request.method === "DELETE" && request.path === "/api/session/ses_delete") {
+          return new Response(null, { status: 204 })
+        }
+        return undefined
+      },
+    })
+    const session = await fixture.service.newSession({ cwd: "/workspace", mcpServers: [] })
+
+    expect(await fixture.service.deleteSession({ sessionId: session.sessionId })).toEqual({})
+    expect(fixture.requests).toContainEqual({
+      method: "DELETE",
+      path: "/api/session/ses_delete",
+      query: {},
+      body: undefined,
+    })
+    const missing = await fixture.service
+      .setSessionConfigOption({ sessionId: session.sessionId, configId: "effort", value: "high" })
+      .catch((error: unknown) => error)
+    expect(missing).toMatchObject({ _tag: "ACPSessionNotFoundError", sessionId: session.sessionId })
+  })
 })
 
 function currentValue(result: { readonly configOptions?: readonly SessionConfigOption[] | null }, id: string) {

packages/cli/test/acp/service-usage.test.ts

@@ -45,17 +45,14 @@ describe("acp service prompt routing and usage", () => {
 
     const commandResult = await fixture.service.prompt({
       sessionId: session.sessionId,
-      messageId: "client-command",
       prompt: [{ type: "text", text: "/review now" }],
     })
     const skillResult = await fixture.service.prompt({
       sessionId: session.sessionId,
-      messageId: "client-skill",
       prompt: [{ type: "text", text: "/verify" }],
     })
     const compactResult = await fixture.service.prompt({
       sessionId: session.sessionId,
-      messageId: "client-compact",
       prompt: [{ type: "text", text: "/compact" }],
     })
 
@@ -154,13 +151,11 @@ describe("acp service prompt routing and usage", () => {
 
     const response = await fixture.service.prompt({
       sessionId: session.sessionId,
-      messageId: "client-message",
       prompt: [{ type: "text", text: "hello" }],
     })
 
     expect(response).toEqual({
       stopReason: "end_turn",
-      userMessageId: "client-message",
       usage: {
         inputTokens: 100,
         outputTokens: 40,