chore(protocol): regenerate the OpenAPI document and check it in CI

.github/actions/setup-bun/action.yml

@@ -45,16 +45,14 @@ runs:
     - name: Get cache directory
       id: cache
       shell: bash
-      run: |
-        echo "dir=$(bun pm cache)" >> "$GITHUB_OUTPUT"
-        echo "version=$(bun --version)" >> "$GITHUB_OUTPUT"
+      run: echo "dir=$(bun pm cache)" >> "$GITHUB_OUTPUT"
 
     - name: Restore Bun dependencies
       id: bun-cache
       uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
       with:
         path: ${{ steps.cache.outputs.dir }}
-        key: ${{ runner.os }}-${{ runner.arch }}-bun-${{ steps.cache.outputs.version }}-${{ hashFiles('bun.lock', 'patches/**') }}
+        key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lock') }}
 
     - name: Install setuptools for distutils compatibility
       run: python3 -m pip install setuptools || pip install setuptools || true
@@ -77,4 +75,4 @@ runs:
       uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
       with:
         path: ${{ steps.cache.outputs.dir }}
-        key: ${{ steps.bun-cache.outputs.cache-primary-key }}
+        key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lock') }}

.github/workflows/test.yml

@@ -167,6 +167,11 @@ jobs:
           bun run script/build-node.ts --single --skip-install --outdir=dist/node
           bun run script/service-smoke.ts --node
 
+      - name: Check generated OpenAPI document
+        if: runner.os == 'Linux'
+        working-directory: packages/protocol
+        run: bun run check:generated
+
       - name: Check generated client
         if: runner.os == 'Linux'
         working-directory: packages/client

packages/cli/src/acp/agent.ts

@@ -8,34 +8,22 @@ import {
   type AgentRequestMethod,
   type Stream,
 } from "@agentclientprotocol/sdk"
-import type { OpenCodeClient } from "@opencode/client/promise"
-import { Cause, Deferred, Effect, Ref, type Scope } from "effect"
+import { ClientError, type OpenCodeClient } from "@opencode/client/promise"
+import { Cause, Effect, type Scope } from "effect"
 import { ACPCatalog } from "./catalog"
 import { ACPConnection } from "./connection"
 import { ACPError } from "./error"
-import { ACPPromise } from "./promise"
 import { ACPService } from "./service"
-import { ACPSessions } from "./sessions"
-import { ACPTurn } from "./turn"
 
 // Untraced so request spans parent to the caller's span instead of a setup span that has already ended.
 export const connect = Effect.fnUntraced(function* (client: OpenCodeClient, stream: Stream) {
   const run = Effect.runPromiseWith(yield* Effect.context<Scope.Scope>())
   const catalog = yield* ACPCatalog.make(client)
-  // Requests can dispatch once the stream's read loop yields, which may be before the service below is built.
-  const ready = yield* Deferred.make<ACPService.Interface>()
   const handle =
-    <Params, A>(
-      call: (service: ACPService.Interface, ctx: AgentHandlerContext<Params>) => Effect.Effect<A, ACPService.Failure>,
-    ) =>
+    <Params, A>(call: (ctx: AgentHandlerContext<Params>) => Effect.Effect<A, ACPError.Error | RequestError>) =>
     (name: string) => {
       const handler = Effect.fn(name)(
-        (ctx: AgentHandlerContext<Params>) =>
-          Deferred.await(ready).pipe(Effect.flatMap((service) => call(service, ctx))),
-        Effect.catchTags({
-          ACPCatalogLoadError: (error) => ACPPromise.classify(error.cause),
-          ACPCatalogNotReadyError: (error) => Effect.die(error),
-        }),
+        call,
         Effect.mapError((error) => (error instanceof RequestError ? error : ACPError.toRequestError(error))),
         Effect.tapCauseIf(Cause.hasDies, (cause) => Effect.logError("ACP request failed", cause)),
         Effect.catchDefect((defect) => Effect.fail(ACPError.toRequestError(ACPError.fromUnknown(defect)))),
@@ -54,70 +42,78 @@ export const connect = Effect.fnUntraced(function* (client: OpenCodeClient, stre
 
   request(
     "initialize",
-    handle((service, ctx) => service.initialize(ctx.params)),
+    handle((ctx) => promise(() => service.initialize(ctx.params))),
   )
   request(
     "authenticate",
-    handle((service, ctx) => service.authenticate(ctx.params)),
+    handle((ctx) => promise(() => service.authenticate(ctx.params))),
   )
   request(
     "session/new",
-    handle((service, ctx) => service.newSession(ctx.params)),
+    handle((ctx) => promise(() => service.newSession(ctx.params))),
   )
   request(
     "session/load",
-    handle((service, ctx) => service.loadSession(ctx.params)),
+    handle((ctx) => promise(() => service.loadSession(ctx.params))),
   )
   request(
     "session/list",
-    handle((service, ctx) => service.listSessions(ctx.params)),
+    handle((ctx) => promise(() => service.listSessions(ctx.params))),
   )
   request(
     "session/delete",
-    handle((service, ctx) => service.deleteSession(ctx.params)),
+    handle((ctx) => promise(() => service.deleteSession(ctx.params))),
   )
   request(
     "session/resume",
-    handle((service, ctx) => service.resumeSession(ctx.params)),
+    handle((ctx) => promise(() => service.resumeSession(ctx.params))),
   )
   request(
     "session/close",
-    handle((service, ctx) => service.closeSession(ctx.params)),
+    handle((ctx) => promise(() => service.closeSession(ctx.params))),
   )
   request(
     "session/fork",
-    handle((service, ctx) => service.forkSession(ctx.params)),
+    handle((ctx) => promise(() => service.forkSession(ctx.params))),
   )
   request(
     "session/set_config_option",
-    handle((service, ctx) => service.setSessionConfigOption(ctx.params)),
+    handle((ctx) => promise(() => service.setSessionConfigOption(ctx.params))),
   )
   request(
     "session/set_mode",
-    handle((service, ctx) => service.setSessionMode(ctx.params)),
+    handle((ctx) => promise(() => service.setSessionMode(ctx.params))),
   )
   // The SDK signal is passed through rather than interrupting the fiber: a cancelled turn still resolves with
   // `stopReason: "cancelled"`.
   request(
     "session/prompt",
-    handle((service, ctx) => ACPPromise.promise(() => service.prompt(ctx.params, ctx.signal))),
+    handle((ctx) => promise(() => service.prompt(ctx.params, ctx.signal))),
   )
   notification(
     "session/cancel",
-    handle((service, ctx) => ACPPromise.promise(() => service.cancel(ctx.params))),
+    handle((ctx) => promise(() => service.cancel(ctx.params))),
   )
   const connection = app.connect(stream)
-  const promiseConnection = ACPConnection.promise(connection)
-  const sessions = yield* ACPSessions.make({ client, connection: ACPConnection.make(connection), catalog })
-  const capabilities = yield* Ref.make({ childSessionUpdates: false })
-  const turn = ACPTurn.make({ client, connection: promiseConnection, sessions, catalog, capabilities, run })
-  yield* Deferred.succeed(
-    ready,
-    ACPService.make({ client, connection: promiseConnection, catalog, sessions, capabilities, turn }),
-  )
+  // Inbound dispatch starts after the stream's async read loop yields, so handlers never observe this before assignment.
+  const service = ACPService.make({ client, connection: ACPConnection.make(connection), catalog, run })
   return connection
 })
 
 const spanName = (method: string) => `cli.acp.${method.replaceAll("/", ".")}`
 
+const promise = <A>(evaluate: () => Promise<A>) =>
+  Effect.tryPromise({
+    try: evaluate,
+    // A catalog load failure is classified by the client error that caused it.
+    catch: (cause) => (cause instanceof ACPCatalog.LoadError ? cause.cause : cause),
+  }).pipe(
+    Effect.catch((cause) => {
+      if (cause instanceof RequestError || ACPError.is(cause)) return Effect.fail(cause)
+      if (cause instanceof ClientError && cause.reason === "Transport")
+        return Effect.fail(new ACPError.ServerUnavailableError())
+      return Effect.die(cause)
+    }),
+  )
+
 export * as ACP from "./agent"

packages/cli/src/acp/catalog.ts

@@ -1,20 +1,14 @@
 import type { CommandInfo, ModelInfo, ModelRef, OpenCodeClient, OpenCodeEvent } from "@opencode/client/promise"
 import { FSUtil } from "@opencode/util/fs-util"
-import { Context, Deferred, Effect, Exit, Schedule, Schema, Semaphore, Stream, SubscriptionRef } from "effect"
+import { Context, Deferred, Effect, Exit, Schedule, Schema, Scope, Semaphore, Stream, SubscriptionRef } from "effect"
 import type { ConfigOptionProvider } from "./config-option"
 
-// ACP runs these itself; they take precedence over server commands with the same name.
-export const builtinCommands = new Map([
-  ["compact", { description: "Compact the session", start: "compaction" as const }],
-])
-
 export type Catalog = {
   readonly providers: ConfigOptionProvider[]
   readonly models: ModelInfo[]
   readonly defaultModel: ModelRef
   readonly modes: Array<{ id: string; name: string; description?: string }>
   readonly defaultModeID: string
-  /** Server commands, without those shadowed by a built-in. */
   readonly commands: CommandInfo[]
 }
 
@@ -139,6 +133,52 @@ export const make = Effect.fnUntraced(function* (client: OpenCodeClient) {
   })
 })
 
+export type Live = {
+  readonly cwd: string
+  readonly current: Catalog
+}
+
+/** Temporary adapter for the promise-based `ACPService` until sessions consume the service directly. */
+export function promise(input: {
+  readonly catalog: Interface
+  readonly run: <A, E>(effect: Effect.Effect<A, E, Scope.Scope>) => Promise<A>
+  readonly changed: (live: Live, previous: Catalog) => Promise<unknown>
+}) {
+  const lives = new Map<string, Live>()
+  return {
+    get: (cwd: string) =>
+      input.run(
+        Effect.gen(function* () {
+          const current = yield* input.catalog.get(cwd)
+          const key = FSUtil.resolve(cwd)
+          const existing = lives.get(key)
+          if (existing) return existing
+          const live: Live = {
+            cwd,
+            // A loaded entry's read never suspends.
+            get current() {
+              return Effect.runSync(input.catalog.get(cwd))
+            },
+          }
+          lives.set(key, live)
+          yield* input.catalog.changes(cwd).pipe(
+            Stream.runFoldEffect(
+              () => current,
+              (previous, next) =>
+                next === previous
+                  ? Effect.succeed(previous)
+                  : Effect.promise(() => input.changed(live, previous).catch(() => {})).pipe(Effect.as(next)),
+            ),
+            Effect.ignore,
+            Effect.forkScoped({ startImmediately: true }),
+          )
+          return live
+        }),
+      ),
+    reload: (live: Live) => input.run(input.catalog.reload(live.cwd)),
+  }
+}
+
 const load = (client: OpenCodeClient, cwd: string) =>
   read(client, cwd).pipe(
     // Some providers discover models in the background after plugin startup begins.
@@ -182,7 +222,7 @@ const read = Effect.fnUntraced(function* (client: OpenCodeClient, cwd: string) {
     },
     modes: agents.map((agent) => ({ id: agent.id, name: agent.name, description: agent.description })),
     defaultModeID: defaultAgent.id,
-    commands: commandResult.data.filter((command) => !builtinCommands.has(command.name)),
+    commands: commandResult.data,
   } satisfies Catalog
 })
 

packages/cli/src/acp/config-option.ts

@@ -1,6 +1,4 @@
 import type { SessionConfigOption } from "@agentclientprotocol/sdk"
-import type { ModelRef } from "@opencode/client/promise"
-import { builtinCommands, type Catalog } from "./catalog"
 
 export const DEFAULT_VARIANT_VALUE = "default"
 
@@ -27,34 +25,6 @@ export type ModelSelection = {
   variant?: string
 }
 
-/** A session's model and mode. Unset fields follow the catalog defaults. */
-export type Selection = {
-  readonly model?: ModelRef
-  readonly modeID?: string
-}
-
-export function currentModel(catalog: Catalog, selection: Selection) {
-  return selection.model ?? catalog.defaultModel
-}
-
-export function configOptions(catalog: Catalog, selection: Selection) {
-  const model = currentModel(catalog, selection)
-  return buildConfigOptions({
-    providers: catalog.providers,
-    currentModel: { providerID: model.providerID, modelID: model.id },
-    currentVariant: model.variant,
-    modes: catalog.modes,
-    currentModeId: selection.modeID ?? catalog.defaultModeID,
-  })
-}
-
-export function availableCommands(catalog: Catalog) {
-  return [
-    ...catalog.commands.map((command) => ({ name: command.name, description: command.description ?? "" })),
-    ...Array.from(builtinCommands, ([name, command]) => ({ name, description: command.description })),
-  ]
-}
-
 export function buildConfigOptions(input: {
   providers: readonly ConfigOptionProvider[]
   currentModel: ModelSelection["model"]

packages/cli/src/acp/connection.ts

@@ -1,28 +1,11 @@
 import {
   methods,
   type AgentConnection,
-  type RequestError,
   type RequestPermissionRequest,
   type RequestPermissionResponse,
   type SendRequestOptions,
   type SessionNotification,
 } from "@agentclientprotocol/sdk"
-import { Context, type Effect } from "effect"
-import type { ACPError } from "./error"
-import { ACPPromise } from "./promise"
-
-export interface Interface {
-  readonly sessionUpdate: (params: SessionNotification) => Effect.Effect<void, ACPError.Error | RequestError>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/cli/acp/Connection") {}
-
-export function make(connection: AgentConnection) {
-  return Service.of({
-    sessionUpdate: (params) =>
-      ACPPromise.promise(() => connection.client.notify(methods.client.session.update, params)),
-  })
-}
 
 export type Connection = {
   readonly signal?: AbortSignal
@@ -31,8 +14,7 @@ export type Connection = {
   extNotification?(method: string, params: Record<string, unknown>): Promise<void>
 }
 
-/** Promise view for the turn, permission, and replay code until they run as effects. */
-export function promise(connection: AgentConnection): Connection {
+export function make(connection: AgentConnection): Connection {
   return {
     signal: connection.signal,
     sessionUpdate: (params) => connection.client.notify(methods.client.session.update, params),

packages/cli/src/acp/event.ts

@@ -7,8 +7,6 @@ import type {
   SessionStructuredError,
   TokenUsageInfo,
 } from "@opencode/client/promise"
-import { Event } from "@opencode/schema/event"
-import { SessionMessage } from "@opencode/schema/session-message"
 import { TokenUsage } from "@opencode/schema/token-usage"
 import type { ACPConnection } from "./connection"
 import { partsToContentChunks, type ReplayPart } from "./content"
@@ -46,7 +44,6 @@ export type TurnStart =
 export const ChildSessionUpdatesCapability = "opencode/child-session-updates"
 export const ChildSessionUpdateMethod = "opencode/session/child_update"
 const RetryMeta = "opencode/retry"
-const CompactionMeta = "opencode/compaction"
 
 type RetryStatus = {
   readonly attempt: number
@@ -54,18 +51,6 @@ type RetryStatus = {
   readonly error: SessionStructuredError
 }
 
-type CompactionMarker = {
-  readonly status: "started" | "completed" | "failed"
-  readonly messageId: string
-  readonly reason: "auto" | "manual"
-  readonly error?: SessionStructuredError
-}
-
-type CompactionEvent = Extract<
-  EventSubscribeOutput,
-  { readonly type: "session.compaction.started" | "session.compaction.ended" | "session.compaction.failed" }
->
-
 type ChildSessionUpdateBase = {
   readonly rootSessionId: string
   readonly childSessionId: string
@@ -123,7 +108,6 @@ export async function streamTurn(input: {
   let usage: { readonly turn: TokenUsageInfo; readonly last: TokenUsageInfo } | undefined
   const tools = new Map<string, ToolState>()
   const retries = new Map<string, RetryStatus>()
-  const compactions = new Map<string, string>()
   const children = new Map<string, ChildSession>()
   const openChildren = new Set<string>()
   let handedOff = false
@@ -244,15 +228,6 @@ export async function streamTurn(input: {
         await send({ sessionUpdate: "session_info_update", _meta: { [RetryMeta]: retry } })
         continue
       }
-      if (
-        event.type === "session.compaction.started" ||
-        event.type === "session.compaction.ended" ||
-        event.type === "session.compaction.failed"
-      ) {
-        const marker = compactionMarker(event, compactions)
-        if (marker) await send(compactionUpdate(marker))
-        continue
-      }
       if (event.type === "session.text.delta") {
         await send({
           sessionUpdate: "agent_message_chunk",
@@ -460,31 +435,6 @@ function toolKey(sessionID: string, id: string) {
   return `${sessionID}:${id}`
 }
 
-// Message IDs follow core's compaction message projection, so live markers match replayed ones.
-function compactionMarker(event: CompactionEvent, compactions: Map<string, string>): CompactionMarker | undefined {
-  const sessionID = event.data.sessionID
-  if (event.type === "session.compaction.started") {
-    const messageId = event.data.inputID ?? SessionMessage.ID.fromEvent(Event.ID.make(event.id))
-    compactions.set(sessionID, messageId)
-    return { status: "started", messageId, reason: event.data.reason }
-  }
-  const tracked = compactions.get(sessionID)
-  compactions.delete(sessionID)
-  if (event.type === "session.compaction.ended")
-    return tracked ? { status: "completed", messageId: tracked, reason: event.data.reason } : undefined
-  // Automatic compaction can fail before it starts, for example when there is nothing to compact yet.
-  return {
-    status: "failed",
-    messageId: tracked ?? event.data.inputID ?? SessionMessage.ID.fromEvent(Event.ID.make(event.id)),
-    reason: event.data.reason,
-    error: event.data.error,
-  }
-}
-
-function compactionUpdate(marker: CompactionMarker): SessionUpdate {
-  return { sessionUpdate: "session_info_update", _meta: { [CompactionMeta]: marker } }
-}
-
 function projectChildUpdate(update: SessionUpdate, child: ChildSession) {
   const projected = { ...update }
   projected._meta = {
@@ -541,19 +491,6 @@ async function replayMessage(
     }
     return
   }
-  // A running compaction has no live turn on this connection to settle it, so replay only settled ones.
-  if (message.type === "compaction" && message.status !== "running") {
-    await connection.sessionUpdate({
-      sessionId: sessionID,
-      update: compactionUpdate({
-        status: message.status,
-        messageId: message.id,
-        reason: message.reason,
-        ...(message.status === "failed" ? { error: message.error } : {}),
-      }),
-    })
-    return
-  }
   if (message.type !== "assistant") return
   // Live reasoning ordinals count only reasoning parts, not the mixed content array.
   let reasoningOrdinal = 0

packages/cli/src/acp/promise.ts

@@ -1,17 +0,0 @@
-import { RequestError } from "@agentclientprotocol/sdk"
-import { ClientError } from "@opencode/client/promise"
-import { Effect } from "effect"
-import { ACPError } from "./error"
-
-/** Runs a promise, keeping ACP failures typed. Any other rejection is a defect. */
-export const promise = <A>(evaluate: (signal: AbortSignal) => Promise<A>) =>
-  Effect.tryPromise({ try: evaluate, catch: (cause) => cause }).pipe(Effect.catch(classify))
-
-export function classify(cause: unknown): Effect.Effect<never, ACPError.Error | RequestError> {
-  if (cause instanceof RequestError || ACPError.is(cause)) return Effect.fail(cause)
-  if (cause instanceof ClientError && cause.reason === "Transport")
-    return Effect.fail(new ACPError.ServerUnavailableError())
-  return Effect.die(cause)
-}
-
-export * as ACPPromise from "./promise"

packages/cli/src/acp/service.ts

@@ -1,6 +1,14 @@
-import { isSessionNotFoundError, type ModelRef, type OpenCodeClient } from "@opencode/client/promise"
+import { isDeepStrictEqual } from "node:util"
+import {
+  isSessionNotFoundError,
+  type CommandInfo,
+  type ModelRef,
+  type OpenCodeClient,
+  type SessionInfo,
+  type SessionMessageInfo,
+} from "@opencode/client/promise"
 import { FSUtil } from "@opencode/util/fs-util"
-import { Effect, Option, Ref, Stream } from "effect"
+import type { Effect, Scope } from "effect"
 import { withTimestampedFallback } from "@opencode/util/session-title-fallback"
 import type {
   AuthenticateRequest,
@@ -19,11 +27,11 @@ import type {
   ListSessionsResponse,
   LoadSessionRequest,
   LoadSessionResponse,
+  McpServer,
   NewSessionRequest,
   NewSessionResponse,
   PromptRequest,
   PromptResponse,
-  RequestError,
   ResumeSessionRequest,
   ResumeSessionResponse,
   SetSessionConfigOptionRequest,
@@ -32,116 +40,177 @@ import type {
   SetSessionModeResponse,
 } from "@agentclientprotocol/sdk"
 import { OPENCODE_VERSION } from "../version"
-import type { ACPCatalog, Catalog } from "./catalog"
-import { configOptions, currentModel, DEFAULT_VARIANT_VALUE, parseModelSelection } from "./config-option"
+import { SessionMessage } from "@opencode/schema/session-message"
+import { ACPCatalog, type Catalog } from "./catalog"
+import { buildConfigOptions, DEFAULT_VARIANT_VALUE, parseModelSelection } from "./config-option"
 import type { ACPConnection } from "./connection"
-import { ChildSessionUpdatesCapability, replayMessages } from "./event"
+import { promptContentToParts } from "./content"
+import {
+  ChildSessionUpdateMethod,
+  ChildSessionUpdatesCapability,
+  replayMessages,
+  streamTurn,
+  type ChildSessionUpdate,
+  type TurnControl,
+  type TurnStart,
+} from "./event"
 import { ACPError } from "./error"
-import { ACPPromise } from "./promise"
-import type { ACPSessions, Attached } from "./sessions"
-import type { ACPTurn } from "./turn"
 
 export const AuthMethodID = "opencode-login"
 
-export type Failure = ACPError.Error | RequestError | ACPCatalog.Error
+// ACP runs these itself; they take precedence over server commands with the same name.
+const builtinCommands = new Map([["compact", { description: "Compact the session", start: "compaction" as const }]])
+
+// Model and mode are unset while the session follows the server defaults.
+type Attached = {
+  readonly id: string
+  readonly cwd: string
+  readonly abort: AbortController
+  readonly catalog: ACPCatalog.Live
+  model?: ModelRef
+  modeID?: string
+}
+
+type PreparedPrompt = {
+  readonly start: TurnStart
+  readonly text: string
+  readonly files: Array<{ readonly uri: string; readonly name?: string }>
+  readonly synthetic: ReadonlyArray<string>
+  readonly slash?: { readonly name: string; readonly args: string }
+  readonly command?: CommandInfo
+}
 
 export interface Interface {
-  readonly initialize: (input: InitializeRequest) => Effect.Effect<InitializeResponse>
-  readonly authenticate: (input: AuthenticateRequest) => Effect.Effect<AuthenticateResponse, Failure>
-  readonly newSession: (input: NewSessionRequest) => Effect.Effect<NewSessionResponse, Failure>
-  readonly loadSession: (input: LoadSessionRequest) => Effect.Effect<LoadSessionResponse, Failure>
-  readonly listSessions: (input: ListSessionsRequest) => Effect.Effect<ListSessionsResponse, Failure>
-  readonly deleteSession: (input: DeleteSessionRequest) => Effect.Effect<DeleteSessionResponse, Failure>
-  readonly resumeSession: (input: ResumeSessionRequest) => Effect.Effect<ResumeSessionResponse, Failure>
-  readonly closeSession: (input: CloseSessionRequest) => Effect.Effect<CloseSessionResponse, Failure>
-  readonly forkSession: (input: ForkSessionRequest) => Effect.Effect<ForkSessionResponse, Failure>
-  readonly setSessionConfigOption: (
-    input: SetSessionConfigOptionRequest,
-  ) => Effect.Effect<SetSessionConfigOptionResponse, Failure>
-  readonly setSessionMode: (input: SetSessionModeRequest) => Effect.Effect<SetSessionModeResponse, Failure>
+  initialize(input: InitializeRequest): Promise<InitializeResponse>
+  authenticate(input: AuthenticateRequest): Promise<AuthenticateResponse>
+  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>
   prompt(input: PromptRequest, signal?: AbortSignal): Promise<PromptResponse>
   cancel(input: CancelNotification): Promise<void>
 }
 
 export function make(input: {
   readonly client: OpenCodeClient
-  /** Replay still writes through the promise view. */
   readonly connection: ACPConnection.Connection
   readonly catalog: ACPCatalog.Interface
-  readonly sessions: ACPSessions.Interface
-  readonly capabilities: Ref.Ref<{ readonly childSessionUpdates: boolean }>
-  readonly turn: ACPTurn.Interface
+  readonly run: <A, E>(effect: Effect.Effect<A, E, Scope.Scope>) => Promise<A>
 }): Interface {
-  const currentOptions = Effect.fnUntraced(function* (attached: Attached) {
-    return configOptions(yield* input.catalog.get(attached.cwd), yield* Ref.get(attached.selection))
+  const sessions = new Map<string, Attached>()
+  const registeredMcp = new Map<string, Set<string>>()
+  const active = new Map<string, { readonly control: TurnControl; readonly turn: Promise<PromptResponse> }>()
+  const capabilities = { childSessionUpdates: false }
+
+  const catalogs = ACPCatalog.promise({
+    catalog: input.catalog,
+    run: input.run,
+    changed: (live, previous) =>
+      Promise.all(
+        Array.from(sessions.values())
+          .filter((state) => state.catalog === live)
+          .map(async (state) => {
+            const options = configOptions(state)
+            if (!isDeepStrictEqual(options, configOptions(state, previous))) {
+              await input.connection.sessionUpdate({
+                sessionId: state.id,
+                update: { sessionUpdate: "config_option_update", configOptions: options },
+              })
+            }
+            if (!isDeepStrictEqual(live.current.commands, previous.commands)) await sendCommands(state)
+          }),
+      ),
   })
 
-  // A selection the catalog has not seen may be new on the server, so reload once before rejecting it.
-  const withReload = <A>(attached: Attached, select: Effect.Effect<A, Failure>) => {
-    const retry = () => input.catalog.reload(attached.cwd).pipe(Effect.andThen(select))
-    return select.pipe(
-      Effect.catchTags({ ACPInvalidModelError: retry, ACPInvalidModeError: retry, ACPInvalidEffortError: retry }),
-    )
+  const sendCommands = (state: Attached) =>
+    input.connection.sessionUpdate({
+      sessionId: state.id,
+      update: {
+        sessionUpdate: "available_commands_update",
+        availableCommands: [
+          ...state.catalog.current.commands
+            .filter((command) => !builtinCommands.has(command.name))
+            .map((command) => ({ name: command.name, description: command.description ?? "" })),
+          ...Array.from(builtinCommands, ([name, command]) => ({ name, description: command.description })),
+        ],
+      },
+    })
+
+  const withReload = <A>(state: Attached, select: () => Promise<A>) =>
+    select().catch(async (error: unknown) => {
+      if (
+        !(
+          error instanceof ACPError.InvalidModelError ||
+          error instanceof ACPError.InvalidModeError ||
+          error instanceof ACPError.InvalidEffortError
+        )
+      )
+        throw error
+      await catalogs.reload(state.catalog)
+      return select()
+    })
+
+  const requireSession = async (sessionID: string) => {
+    const current = sessions.get(sessionID)
+    if (current) return current
+    throw new ACPError.SessionNotFoundError({ sessionId: sessionID })
   }
 
-  const selectOption = Effect.fnUntraced(function* (attached: Attached, configId: string, value: string) {
-    const catalog = yield* input.catalog.get(attached.cwd)
-    const current = currentModel(catalog, yield* Ref.get(attached.selection))
-    switch (configId) {
-      case "model":
-        return yield* selectModel(attached, yield* requireModel(catalog, value, current))
-      case "effort":
-        return yield* selectModel(attached, yield* requireEffort(catalog, value, current))
-      case "mode":
-        return yield* selectMode(attached, value)
-      default:
-        return yield* new ACPError.InvalidConfigOptionError({ configId })
+  const detach = (sessionID: string) => {
+    sessions.get(sessionID)?.abort.abort()
+    sessions.delete(sessionID)
+    registeredMcp.delete(sessionID)
+  }
+
+  const cancelTurn = (sessionID: string) => {
+    const turn = active.get(sessionID)
+    if (turn) {
+      turn.control.cancelled = true
+      turn.control.admission.abort()
     }
-  })
+    return input.client.session.interrupt({ sessionID })
+  }
 
-  const selectModel = Effect.fnUntraced(function* (attached: Attached, model: ModelRef) {
-    yield* Ref.update(attached.selection, (selection) => ({ ...selection, model }))
-    yield* ACPPromise.promise(() => input.client.session.switchModel({ sessionID: attached.id, model }))
-  })
+  const attach = async (session: SessionInfo, cwd: string, mcpServers: readonly McpServer[]) => {
+    const catalog = await catalogs.get(cwd)
+    sessions.get(session.id)?.abort.abort()
+    const state: Attached = {
+      id: session.id,
+      cwd,
+      abort: new AbortController(),
+      catalog,
+      model: session.model,
+      modeID: session.agent,
+    }
+    sessions.set(session.id, state)
+    await registerMcpServers(input.client, registeredMcp, state, mcpServers)
+    await sendCommands(state)
+    return state
+  }
 
-  const selectMode = Effect.fnUntraced(function* (attached: Attached, modeID: string) {
-    const catalog = yield* input.catalog.get(attached.cwd)
-    if (!catalog.modes.some((mode) => mode.id === modeID)) return yield* new ACPError.InvalidModeError({ mode: modeID })
-    yield* Ref.update(attached.selection, (selection) => ({ ...selection, modeID }))
-    yield* ACPPromise.promise(() => input.client.session.switchAgent({ sessionID: attached.id, agent: modeID }))
-  })
+  const replay = async (state: Attached) => {
+    await replayMessages(input.connection, state.id, state.cwd, await messages(input.client, state.id))
+  }
 
-  const getSession = Effect.fnUntraced(function* (sessionID: string, cwd: string) {
-    const session = yield* ACPPromise.promise(() =>
-      input.client.session.get({ sessionID }).catch((error) => {
-        if (isSessionNotFoundError(error)) throw new ACPError.SessionNotFoundError({ sessionId: sessionID })
-        throw error
-      }),
-    )
-    if (FSUtil.resolve(cwd) !== FSUtil.resolve(session.location.directory))
-      return yield* new ACPError.SessionDirectoryMismatchError({ sessionId: sessionID, cwd })
-    return session
-  })
-
-  const replay = (attached: Attached) =>
-    Stream.paginate(undefined, (cursor: string | undefined) =>
-      ACPPromise.promise(() =>
-        cursor
-          ? input.client.message.list({ sessionID: attached.id, limit: 200, cursor })
-          : input.client.message.list({ sessionID: attached.id, limit: 200, order: "asc" }),
-      ).pipe(Effect.map((page) => [page.data, Option.fromNullishOr(page.cursor.next)] as const)),
-    ).pipe(
-      Stream.runCollect,
-      Effect.flatMap((messages) =>
-        ACPPromise.promise(() => replayMessages(input.connection, attached.id, attached.cwd, messages)),
-      ),
-    )
+  const configOptions = (state: Attached, catalog = state.catalog.current) => {
+    const model = currentModel(state, catalog)
+    return buildConfigOptions({
+      providers: catalog.providers,
+      currentModel: { providerID: model.providerID, modelID: model.id },
+      currentVariant: model.variant,
+      modes: catalog.modes,
+      currentModeId: state.modeID ?? catalog.defaultModeID,
+    })
+  }
 
   return {
-    initialize: Effect.fnUntraced(function* (params) {
-      yield* Ref.set(input.capabilities, {
-        childSessionUpdates: params.clientCapabilities?._meta?.[ChildSessionUpdatesCapability] === true,
-      })
+    initialize: async (params) => {
+      capabilities.childSessionUpdates = params.clientCapabilities?._meta?.[ChildSessionUpdatesCapability] === true
       const authMethod: AuthMethod = {
         description: "Run `opencode auth login` in the terminal",
         name: "Login with opencode",
@@ -164,37 +233,32 @@ export function make(input: {
         authMethods: [authMethod],
         agentInfo: { name: "OpenCode", version: OPENCODE_VERSION },
       }
-    }),
-    authenticate: Effect.fnUntraced(function* (params) {
-      if (params.methodId !== AuthMethodID)
-        return yield* new ACPError.UnknownAuthMethodError({ methodId: params.methodId })
+    },
+    authenticate: async (params) => {
+      if (params.methodId !== AuthMethodID) throw new ACPError.UnknownAuthMethodError({ methodId: params.methodId })
       return {}
-    }),
-    newSession: Effect.fnUntraced(function* (params) {
+    },
+    newSession: async (params) => {
       // Load before creating so a catalog failure leaves no session behind. Agent and model stay unset
       // so the server resolves its defaults after plugins activate.
-      yield* input.catalog.get(params.cwd)
-      const created = yield* ACPPromise.promise(() =>
-        input.client.session.create({ location: { directory: params.cwd } }),
-      )
-      const attached = yield* input.sessions.attach(created, params.cwd, params.mcpServers)
-      return { sessionId: attached.id, configOptions: yield* currentOptions(attached) }
-    }),
-    loadSession: Effect.fnUntraced(function* (params) {
-      const session = yield* getSession(params.sessionId, params.cwd)
-      const attached = yield* input.sessions.attach(session, session.location.directory, params.mcpServers)
-      yield* replay(attached)
-      return { configOptions: yield* currentOptions(attached) }
-    }),
-    listSessions: Effect.fnUntraced(function* (params) {
-      const page = yield* ACPPromise.promise(() =>
-        input.client.session.list({
-          ...(params.cwd ? { directory: params.cwd } : {}),
-          order: "desc",
-          limit: 100,
-          ...(params.cursor ? { cursor: params.cursor } : {}),
-        }),
-      )
+      await catalogs.get(params.cwd)
+      const created = await input.client.session.create({ location: { directory: params.cwd } })
+      const state = await attach(created, params.cwd, params.mcpServers)
+      return { sessionId: state.id, configOptions: configOptions(state) }
+    },
+    loadSession: async (params) => {
+      const session = await getSession(input.client, params.sessionId, params.cwd)
+      const state = await attach(session, session.location.directory, params.mcpServers)
+      await replay(state)
+      return { configOptions: configOptions(state) }
+    },
+    listSessions: async (params) => {
+      const page = await input.client.session.list({
+        ...(params.cwd ? { directory: params.cwd } : {}),
+        order: "desc",
+        limit: 100,
+        ...(params.cursor ? { cursor: params.cursor } : {}),
+      })
       return {
         sessions: page.data.map((session) => ({
           sessionId: session.id,
@@ -204,57 +268,178 @@ export function make(input: {
         })),
         ...(page.cursor.next ? { nextCursor: page.cursor.next } : {}),
       }
-    }),
-    deleteSession: Effect.fnUntraced(function* (params) {
-      yield* ACPPromise.promise(() =>
-        input.client.session.remove({ sessionID: params.sessionId }).catch((error) => {
-          if (!isSessionNotFoundError(error)) throw error
-        }),
-      )
-      yield* input.sessions.detach(params.sessionId)
+    },
+    deleteSession: async (params) => {
+      await input.client.session.remove({ sessionID: params.sessionId }).catch((error) => {
+        if (!isSessionNotFoundError(error)) throw error
+      })
+      detach(params.sessionId)
       return {}
-    }),
-    resumeSession: Effect.fnUntraced(function* (params) {
-      const session = yield* getSession(params.sessionId, params.cwd)
-      const attached = yield* input.sessions.attach(session, session.location.directory, params.mcpServers ?? [])
-      return { configOptions: yield* currentOptions(attached) }
-    }),
-    closeSession: Effect.fnUntraced(function* (params) {
-      yield* input.turn.close(params.sessionId)
-      yield* input.sessions.detach(params.sessionId)
+    },
+    resumeSession: async (params) => {
+      const session = await getSession(input.client, params.sessionId, params.cwd)
+      const state = await attach(session, session.location.directory, params.mcpServers ?? [])
+      return { configOptions: configOptions(state) }
+    },
+    closeSession: async (params) => {
+      const turn = active.get(params.sessionId)
+      await cancelTurn(params.sessionId).catch((error) => {
+        if (!isSessionNotFoundError(error)) throw error
+      })
+      await turn?.turn.catch(() => {})
+      detach(params.sessionId)
       return {}
-    }),
-    forkSession: Effect.fnUntraced(function* (params) {
-      const forked = yield* ACPPromise.promise(() => input.client.session.fork({ sessionID: params.sessionId }))
-      const attached = yield* input.sessions.attach(forked, forked.location.directory, params.mcpServers ?? [])
-      yield* replay(attached)
-      return { sessionId: attached.id, configOptions: yield* currentOptions(attached) }
-    }),
-    setSessionConfigOption: Effect.fnUntraced(function* (params) {
-      const attached = yield* input.sessions.require(params.sessionId)
+    },
+    forkSession: async (params) => {
+      const forked = await input.client.session.fork({
+        sessionID: params.sessionId,
+      })
+      const state = await attach(forked, forked.location.directory, params.mcpServers ?? [])
+      await replay(state)
+      return { sessionId: state.id, configOptions: configOptions(state) }
+    },
+    setSessionConfigOption: async (params) => {
+      const state = await requireSession(params.sessionId)
       const value = params.value
-      if (typeof value !== "string") return yield* new ACPError.InvalidConfigOptionError({ configId: params.configId })
-      yield* withReload(attached, selectOption(attached, params.configId, value))
-      return { configOptions: yield* currentOptions(attached) }
-    }),
-    setSessionMode: Effect.fnUntraced(function* (params) {
-      const attached = yield* input.sessions.require(params.sessionId)
-      yield* withReload(attached, selectMode(attached, params.modeId))
+      if (typeof value !== "string") throw new ACPError.InvalidConfigOptionError({ configId: params.configId })
+      await withReload(state, async () => {
+        switch (params.configId) {
+          case "model": {
+            const selected = requireModel(state.catalog.current, value, currentModel(state))
+            state.model = selected
+            await input.client.session.switchModel({ sessionID: state.id, model: selected })
+            return
+          }
+          case "effort": {
+            const current = currentModel(state)
+            const model = state.catalog.current.models.find(
+              (item) => item.providerID === current.providerID && item.id === current.id,
+            )
+            if (!model || (value !== DEFAULT_VARIANT_VALUE && !model.variants.some((variant) => variant.id === value)))
+              throw new ACPError.InvalidEffortError({ effort: value })
+            state.model = { ...current, variant: value }
+            await input.client.session.switchModel({ sessionID: state.id, model: state.model })
+            return
+          }
+          case "mode":
+            return selectMode(input.client, state, value)
+          default:
+            throw new ACPError.InvalidConfigOptionError({ configId: params.configId })
+        }
+      })
+      return { configOptions: configOptions(state) }
+    },
+    setSessionMode: async (params) => {
+      const state = await requireSession(params.sessionId)
+      await withReload(state, () => selectMode(input.client, state, params.modeId))
       return {}
-    }),
-    prompt: input.turn.prompt,
-    cancel: input.turn.cancel,
+    },
+    prompt: async (params, signal) => {
+      const state = await requireSession(params.sessionId)
+      if (active.has(state.id)) {
+        throw new ACPError.ServiceFailureError({
+          safeMessage: `Session already has an active ACP prompt: ${state.id}`,
+          service: "session",
+        })
+      }
+      const messageID = SessionMessage.ID.create()
+      const prepared = preparePrompt(state.catalog.current, params.prompt, messageID)
+      const control: TurnControl = { cancelled: false, admission: new AbortController() }
+      const extNotification = input.connection.extNotification
+      const childSessionUpdate =
+        capabilities.childSessionUpdates && extNotification
+          ? (update: ChildSessionUpdate) => extNotification(ChildSessionUpdateMethod, update).then(() => {})
+          : undefined
+      // A `$/cancel_request` for this prompt behaves like `session/cancel` for its turn.
+      const cancel = () => void cancelTurn(state.id).catch(() => {})
+      const turn = streamTurn({
+        client: input.client,
+        connection: input.connection,
+        sessionID: state.id,
+        cwd: state.cwd,
+        start: prepared.start,
+        action: prepared.command !== undefined,
+        control,
+        connectionSignal: input.connection.signal,
+        sessionSignal: state.abort.signal,
+        submit: (signal) => submitPrompt(input.client, state, prepared, signal),
+        ...(childSessionUpdate ? { childSessionUpdate } : {}),
+      })
+        .then(async (result) => {
+          await sendUsageUpdate(input.client, input.connection, state, result.contextTokens).catch(() => {})
+          return result.response
+        })
+        .finally(() => {
+          signal?.removeEventListener("abort", cancel)
+          if (active.get(state.id)?.control === control) active.delete(state.id)
+        })
+      active.set(state.id, { control, turn })
+      signal?.addEventListener("abort", cancel, { once: true })
+      // The cancel may already be buffered behind the awaits above.
+      if (signal?.aborted) cancel()
+      return turn
+    },
+    cancel: async (params) => {
+      await cancelTurn(params.sessionId).catch(() => {})
+    },
   }
 }
 
-const requireModel = Effect.fnUntraced(function* (catalog: Catalog, modelID: string, current: ModelRef) {
+function preparePrompt(catalog: Catalog, prompt: PromptRequest["prompt"], messageID: string): PreparedPrompt {
+  const parts = promptContentToParts(prompt)
+  const visible = parts.filter((part) => part.type !== "text" || (!part.synthetic && !part.ignored))
+  const synthetic = parts.flatMap((part) => (part.type === "text" && part.synthetic ? [part.text] : []))
+  const text = visible.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("\n")
+  const files = visible.flatMap((part) => (part.type === "file" ? [{ uri: part.url, name: part.filename }] : []))
+  const slash = detectSlashCommand(text)
+  const command =
+    slash && !builtinCommands.has(slash.name) ? catalog.commands.find((item) => item.name === slash.name) : undefined
+  const start = turnStart(messageID, slash)
+  return { start, text, files, synthetic, slash, command }
+}
+
+async function submitPrompt(client: OpenCodeClient, session: Attached, prompt: PreparedPrompt, signal: AbortSignal) {
+  if (prompt.synthetic.length > 0) {
+    await client.session.synthetic({
+      sessionID: session.id,
+      text: prompt.synthetic.join("\n\n"),
+      description: "ACP embedded context",
+      delivery: "steer",
+      resume: false,
+    })
+  }
+  if (prompt.start.type === "compaction") return client.session.compact({ sessionID: session.id, id: prompt.start.id })
+  if (prompt.command) {
+    return client.session.command(
+      {
+        sessionID: session.id,
+        name: prompt.command.name,
+        text: prompt.slash?.args ?? "",
+        files: prompt.files,
+        delivery: "steer",
+      },
+      { signal },
+    )
+  }
+  return client.session.prompt(
+    { sessionID: session.id, id: prompt.start.id, text: prompt.text, files: prompt.files, delivery: "steer" },
+    { signal },
+  )
+}
+
+function turnStart(messageID: string, slash: PreparedPrompt["slash"]): TurnStart {
+  if (slash && builtinCommands.get(slash.name)?.start === "compaction") return { type: "compaction", id: messageID }
+  return { type: "input", id: messageID }
+}
+
+function requireModel(catalog: Catalog, modelID: string, current: ModelRef): ModelRef {
   const selected = parseModelSelection(modelID, catalog.providers)
   const model = catalog.models.find(
     (item) => item.providerID === selected.model.providerID && item.id === selected.model.modelID,
   )
-  if (!model) return yield* new ACPError.InvalidModelError({ providerId: selected.model.providerID, modelId: modelID })
+  if (!model) throw new ACPError.InvalidModelError({ providerId: selected.model.providerID, modelId: modelID })
   if (selected.variant && !model.variants.some((variant) => variant.id === selected.variant))
-    return yield* new ACPError.InvalidEffortError({ effort: selected.variant })
+    throw new ACPError.InvalidEffortError({ effort: selected.variant })
   const variant =
     selected.variant ??
     (current.providerID === model.providerID &&
@@ -262,14 +447,124 @@ const requireModel = Effect.fnUntraced(function* (catalog: Catalog, modelID: str
     (current.variant === DEFAULT_VARIANT_VALUE || model.variants.some((variant) => variant.id === current.variant))
       ? current.variant
       : undefined)
-  return { providerID: model.providerID, id: model.id, variant } satisfies ModelRef
-})
+  return { providerID: model.providerID, id: model.id, variant }
+}
 
-const requireEffort = Effect.fnUntraced(function* (catalog: Catalog, effort: string, current: ModelRef) {
-  const model = catalog.models.find((item) => item.providerID === current.providerID && item.id === current.id)
-  if (!model || (effort !== DEFAULT_VARIANT_VALUE && !model.variants.some((variant) => variant.id === effort)))
-    return yield* new ACPError.InvalidEffortError({ effort })
-  return { ...current, variant: effort } satisfies ModelRef
-})
+function currentModel(state: Attached, catalog = state.catalog.current) {
+  return state.model ?? catalog.defaultModel
+}
+
+async function selectMode(client: OpenCodeClient, state: Attached, modeID: string) {
+  if (!state.catalog.current.modes.some((mode) => mode.id === modeID))
+    throw new ACPError.InvalidModeError({ mode: modeID })
+  state.modeID = modeID
+  await client.session.switchAgent({ sessionID: state.id, agent: modeID })
+}
+
+async function getSession(client: OpenCodeClient, sessionID: string, cwd: string) {
+  const session = await client.session.get({ sessionID }).catch((error) => {
+    if (isSessionNotFoundError(error)) throw new ACPError.SessionNotFoundError({ sessionId: sessionID })
+    throw error
+  })
+  if (FSUtil.resolve(cwd) !== FSUtil.resolve(session.location.directory)) {
+    throw new ACPError.SessionDirectoryMismatchError({ sessionId: sessionID, cwd })
+  }
+  return session
+}
+
+async function messages(client: OpenCodeClient, sessionID: string) {
+  const result: SessionMessageInfo[] = []
+  let cursor: string | undefined
+  do {
+    const page = cursor
+      ? await client.message.list({ sessionID, limit: 200, cursor })
+      : await client.message.list({ sessionID, limit: 200, order: "asc" })
+    result.push(...page.data)
+    cursor = page.cursor.next ?? undefined
+  } while (cursor)
+  return result
+}
+
+async function registerMcpServers(
+  client: OpenCodeClient,
+  registered: Map<string, Set<string>>,
+  session: Attached,
+  servers: readonly McpServer[],
+) {
+  const current = registered.get(session.id) ?? new Set<string>()
+  registered.set(session.id, current)
+  await Promise.all(
+    servers.flatMap((server) => {
+      const config = mcpConfig(server)
+      const key = `${server.name}:${stableStringify(config)}`
+      if (current.has(key)) return []
+      current.add(key)
+      return [
+        client.mcp.add({ server: server.name, location: { directory: session.cwd }, config }).catch((error) => {
+          current.delete(key)
+          throw error
+        }),
+      ]
+    }),
+  )
+}
+
+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,
+      headers: Object.fromEntries(server.headers.map((header) => [header.name, header.value])),
+      oauth: false as const,
+    }
+  }
+  return {
+    type: "local" as const,
+    command: [server.command, ...server.args],
+    environment: Object.fromEntries(server.env.map((entry) => [entry.name, entry.value])),
+  }
+}
+
+function stableStringify(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`
+  if (!value || typeof value !== "object") return JSON.stringify(value)
+  return `{${Object.entries(value)
+    .toSorted(([a], [b]) => a.localeCompare(b))
+    .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+    .join(",")}}`
+}
+
+async function sendUsageUpdate(
+  client: OpenCodeClient,
+  connection: ACPConnection.Connection,
+  session: Attached,
+  used?: number,
+) {
+  if (!used) return
+  const current = currentModel(session)
+  const model = session.catalog.current.models.find(
+    (item) => item.providerID === current.providerID && item.id === current.id,
+  )
+  if (!model?.limit.context) return
+  const info = await client.session.get({ sessionID: session.id })
+  await connection.sessionUpdate({
+    sessionId: session.id,
+    update: {
+      sessionUpdate: "usage_update",
+      used,
+      size: model.limit.context,
+      cost: { amount: info.cost, currency: "USD" },
+    },
+  })
+}
+
+function detectSlashCommand(text: string): { readonly name: string; readonly args: string } | undefined {
+  const value = text.trim()
+  if (!value.startsWith("/")) return undefined
+  const [name, ...rest] = value.slice(1).split(/\s+/)
+  if (!name) return undefined
+  return { name, args: rest.join(" ").trim() }
+}
 
 export * as ACPService from "./service"

packages/cli/src/acp/sessions.ts

@@ -1,176 +0,0 @@
-import { isDeepStrictEqual } from "node:util"
-import type { McpServer, RequestError } from "@agentclientprotocol/sdk"
-import type { OpenCodeClient, SessionInfo } from "@opencode/client/promise"
-import { Context, Effect, Exit, Ref, Scope, Stream } from "effect"
-import type { ACPCatalog, Catalog } from "./catalog"
-import { availableCommands, configOptions, type Selection } from "./config-option"
-import type { ACPConnection } from "./connection"
-import { ACPError } from "./error"
-import { ACPPromise } from "./promise"
-
-export type Attached = {
-  readonly id: string
-  readonly cwd: string
-  readonly selection: Ref.Ref<Selection>
-  /** Aborted when the session detaches, for the promise-based turn. */
-  readonly signal: AbortSignal
-}
-
-export interface Interface {
-  /**
-   * Attaches a session in its own scope, closing any previous attachment of the same ID. The scope follows the
-   * cwd's catalog and pushes config option and command updates while it is open. A failed attach leaves the
-   * session detached.
-   */
-  readonly attach: (
-    session: SessionInfo,
-    cwd: string,
-    mcpServers: readonly McpServer[],
-  ) => Effect.Effect<Attached, ACPError.Error | RequestError | ACPCatalog.Error>
-  /** Closes the session scope. No-op when the session is not attached. */
-  readonly detach: (sessionID: string) => Effect.Effect<void>
-  readonly require: (sessionID: string) => Effect.Effect<Attached, ACPError.SessionNotFoundError>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/cli/acp/Sessions") {}
-
-type Entry = { readonly attached: Attached; readonly scope: Scope.Closeable }
-
-export const make = Effect.fnUntraced(function* (input: {
-  readonly client: OpenCodeClient
-  readonly connection: ACPConnection.Interface
-  readonly catalog: ACPCatalog.Interface
-}) {
-  const scope = yield* Effect.scope
-  const sessions = new Map<string, Entry>()
-  // Kept across re-attachment so resuming with the same servers does not add them again.
-  const registeredMcp = new Map<string, Set<string>>()
-
-  const sendCommands = (sessionID: string, catalog: Catalog) =>
-    input.connection.sessionUpdate({
-      sessionId: sessionID,
-      update: { sessionUpdate: "available_commands_update", availableCommands: availableCommands(catalog) },
-    })
-
-  const changed = Effect.fnUntraced(function* (attached: Attached, previous: Catalog, next: Catalog) {
-    const selection = yield* Ref.get(attached.selection)
-    const options = configOptions(next, selection)
-    if (!isDeepStrictEqual(options, configOptions(previous, selection))) {
-      yield* input.connection.sessionUpdate({
-        sessionId: attached.id,
-        update: { sessionUpdate: "config_option_update", configOptions: options },
-      })
-    }
-    if (!isDeepStrictEqual(next.commands, previous.commands)) yield* sendCommands(attached.id, next)
-  })
-
-  const registerMcp = (attached: Attached, servers: readonly McpServer[]) =>
-    Effect.suspend(() => {
-      const registered = registeredMcp.get(attached.id) ?? new Set<string>()
-      registeredMcp.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)
-            return ACPPromise.promise(() =>
-              input.client.mcp.add({ server: server.name, location: { directory: attached.cwd }, config }),
-            ).pipe(
-              Effect.onError(() => Effect.sync(() => registered.delete(key))),
-              Effect.uninterruptible,
-            )
-          }),
-        { concurrency: "unbounded", discard: true },
-      )
-    })
-
-  const remove = (sessionID: string, entry: Entry) =>
-    Effect.suspend(() => {
-      if (sessions.get(sessionID) === entry) {
-        sessions.delete(sessionID)
-        registeredMcp.delete(sessionID)
-      }
-      return Scope.close(entry.scope, Exit.void)
-    })
-
-  return Service.of({
-    attach: Effect.fn("cli.acp.sessions.attach")(function* (session, cwd, mcpServers) {
-      const current = yield* input.catalog.get(cwd)
-      const abort = new AbortController()
-      const entry: Entry = {
-        attached: {
-          id: session.id,
-          cwd,
-          selection: yield* Ref.make<Selection>({ model: session.model, modeID: session.agent }),
-          signal: abort.signal,
-        },
-        scope: Scope.forkUnsafe(scope),
-      }
-      // Swap synchronously so concurrent attaches of one ID cannot both keep a scope.
-      const replaced = sessions.get(session.id)
-      sessions.set(session.id, entry)
-      if (replaced) yield* Scope.close(replaced.scope, Exit.void)
-      yield* Scope.addFinalizer(
-        entry.scope,
-        Effect.sync(() => abort.abort()),
-      )
-      yield* registerMcp(entry.attached, mcpServers).pipe(
-        Effect.andThen(sendCommands(session.id, current)),
-        Effect.onError(() => remove(session.id, entry)),
-      )
-      // `changes` emits the latest catalog first, so a reload since `current` is still pushed.
-      yield* input.catalog.changes(cwd).pipe(
-        Stream.runFoldEffect(
-          () => current,
-          (previous, next) =>
-            next === previous
-              ? Effect.succeed(previous)
-              : changed(entry.attached, previous, next).pipe(Effect.ignore, Effect.as(next)),
-        ),
-        Effect.ignore,
-        Effect.forkIn(entry.scope),
-      )
-      return entry.attached
-    }),
-    detach: Effect.fn("cli.acp.sessions.detach")(function* (sessionID) {
-      const entry = sessions.get(sessionID)
-      if (entry) yield* remove(sessionID, entry)
-    }),
-    require: Effect.fn("cli.acp.sessions.require")(function* (sessionID) {
-      const entry = sessions.get(sessionID)
-      if (!entry) return yield* new ACPError.SessionNotFoundError({ sessionId: sessionID })
-      return entry.attached
-    }),
-  })
-})
-
-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,
-      headers: Object.fromEntries(server.headers.map((header) => [header.name, header.value])),
-      oauth: false as const,
-    }
-  }
-  return {
-    type: "local" as const,
-    command: [server.command, ...server.args],
-    environment: Object.fromEntries(server.env.map((entry) => [entry.name, entry.value])),
-  }
-}
-
-function stableStringify(value: unknown): string {
-  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`
-  if (!value || typeof value !== "object") return JSON.stringify(value)
-  return `{${Object.entries(value)
-    .toSorted(([a], [b]) => a.localeCompare(b))
-    .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
-    .join(",")}}`
-}
-
-export * as ACPSessions from "./sessions"

packages/cli/src/acp/turn.ts

@@ -1,203 +0,0 @@
-import type { CancelNotification, PromptRequest, PromptResponse, RequestError } from "@agentclientprotocol/sdk"
-import { isSessionNotFoundError, type CommandInfo, type OpenCodeClient } from "@opencode/client/promise"
-import { SessionMessage } from "@opencode/schema/session-message"
-import { Effect, Ref, type Scope } from "effect"
-import { builtinCommands, type ACPCatalog, type Catalog } from "./catalog"
-import { currentModel } from "./config-option"
-import type { ACPConnection } from "./connection"
-import { promptContentToParts } from "./content"
-import { ACPError } from "./error"
-import {
-  ChildSessionUpdateMethod,
-  streamTurn,
-  type ChildSessionUpdate,
-  type TurnControl,
-  type TurnStart,
-} from "./event"
-import { ACPPromise } from "./promise"
-import type { ACPSessions, Attached } from "./sessions"
-
-type PreparedPrompt = {
-  readonly start: TurnStart
-  readonly text: string
-  readonly files: Array<{ readonly uri: string; readonly name?: string }>
-  readonly synthetic: ReadonlyArray<string>
-  readonly slash?: { readonly name: string; readonly args: string }
-  readonly command?: CommandInfo
-}
-
-export interface Interface {
-  prompt(input: PromptRequest, signal?: AbortSignal): Promise<PromptResponse>
-  cancel(input: CancelNotification): Promise<void>
-  /** Cancels the session's active turn and waits for it to settle. */
-  readonly close: (sessionID: string) => Effect.Effect<void, ACPError.Error | RequestError>
-}
-
-export function make(input: {
-  readonly client: OpenCodeClient
-  readonly connection: ACPConnection.Connection
-  readonly sessions: ACPSessions.Interface
-  readonly catalog: ACPCatalog.Interface
-  readonly capabilities: Ref.Ref<{ readonly childSessionUpdates: boolean }>
-  readonly run: <A, E>(effect: Effect.Effect<A, E, Scope.Scope>) => Promise<A>
-}): Interface {
-  const active = new Map<string, { readonly control: TurnControl; readonly turn: Promise<PromptResponse> }>()
-
-  const cancelTurn = (sessionID: string) => {
-    const turn = active.get(sessionID)
-    if (turn) {
-      turn.control.cancelled = true
-      turn.control.admission.abort()
-    }
-    return input.client.session.interrupt({ sessionID })
-  }
-
-  const sendUsageUpdate = async (state: Attached, used?: number) => {
-    if (!used) return
-    const model = await input.run(
-      Effect.gen(function* () {
-        const catalog = yield* input.catalog.get(state.cwd)
-        const current = currentModel(catalog, yield* Ref.get(state.selection))
-        return catalog.models.find((item) => item.providerID === current.providerID && item.id === current.id)
-      }),
-    )
-    if (!model?.limit.context) return
-    const info = await input.client.session.get({ sessionID: state.id })
-    await input.connection.sessionUpdate({
-      sessionId: state.id,
-      update: {
-        sessionUpdate: "usage_update",
-        used,
-        size: model.limit.context,
-        cost: { amount: info.cost, currency: "USD" },
-      },
-    })
-  }
-
-  return {
-    prompt: async (params, signal) => {
-      // Read everything first so the active check and registration below stay synchronous.
-      const resolved = await input.run(
-        Effect.gen(function* () {
-          const attached = yield* input.sessions.require(params.sessionId)
-          return {
-            attached,
-            catalog: yield* input.catalog.get(attached.cwd),
-            childSessionUpdates: (yield* Ref.get(input.capabilities)).childSessionUpdates,
-          }
-        }),
-      )
-      const state = resolved.attached
-      if (active.has(state.id)) {
-        throw new ACPError.ServiceFailureError({
-          safeMessage: `Session already has an active ACP prompt: ${state.id}`,
-          service: "session",
-        })
-      }
-      const messageID = SessionMessage.ID.create()
-      const prepared = preparePrompt(resolved.catalog, params.prompt, messageID)
-      const control: TurnControl = { cancelled: false, admission: new AbortController() }
-      const extNotification = input.connection.extNotification
-      const childSessionUpdate =
-        resolved.childSessionUpdates && extNotification
-          ? (update: ChildSessionUpdate) => extNotification(ChildSessionUpdateMethod, update).then(() => {})
-          : undefined
-      // A `$/cancel_request` for this prompt behaves like `session/cancel` for its turn.
-      const cancel = () => void cancelTurn(state.id).catch(() => {})
-      const turn = streamTurn({
-        client: input.client,
-        connection: input.connection,
-        sessionID: state.id,
-        cwd: state.cwd,
-        start: prepared.start,
-        action: prepared.command !== undefined,
-        control,
-        connectionSignal: input.connection.signal,
-        sessionSignal: state.signal,
-        submit: (signal) => submitPrompt(input.client, state, prepared, signal),
-        ...(childSessionUpdate ? { childSessionUpdate } : {}),
-      })
-        .then(async (result) => {
-          await sendUsageUpdate(state, result.contextTokens).catch(() => {})
-          return result.response
-        })
-        .finally(() => {
-          signal?.removeEventListener("abort", cancel)
-          if (active.get(state.id)?.control === control) active.delete(state.id)
-        })
-      active.set(state.id, { control, turn })
-      signal?.addEventListener("abort", cancel, { once: true })
-      // The cancel may already be buffered behind the awaits above.
-      if (signal?.aborted) cancel()
-      return turn
-    },
-    cancel: async (params) => {
-      await cancelTurn(params.sessionId).catch(() => {})
-    },
-    close: Effect.fnUntraced(function* (sessionID) {
-      const turn = active.get(sessionID)
-      yield* ACPPromise.promise(() =>
-        cancelTurn(sessionID).catch((error) => {
-          if (!isSessionNotFoundError(error)) throw error
-        }),
-      )
-      if (turn) yield* Effect.promise(() => turn.turn.catch(() => {}))
-    }),
-  }
-}
-
-function preparePrompt(catalog: Catalog, prompt: PromptRequest["prompt"], messageID: string): PreparedPrompt {
-  const parts = promptContentToParts(prompt)
-  const visible = parts.filter((part) => part.type !== "text" || (!part.synthetic && !part.ignored))
-  const synthetic = parts.flatMap((part) => (part.type === "text" && part.synthetic ? [part.text] : []))
-  const text = visible.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("\n")
-  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 }
-}
-
-async function submitPrompt(client: OpenCodeClient, session: Attached, prompt: PreparedPrompt, signal: AbortSignal) {
-  if (prompt.synthetic.length > 0) {
-    await client.session.synthetic({
-      sessionID: session.id,
-      text: prompt.synthetic.join("\n\n"),
-      description: "ACP embedded context",
-      delivery: "steer",
-      resume: false,
-    })
-  }
-  if (prompt.start.type === "compaction") return client.session.compact({ sessionID: session.id, id: prompt.start.id })
-  if (prompt.command) {
-    return client.session.command(
-      {
-        sessionID: session.id,
-        name: prompt.command.name,
-        text: prompt.slash?.args ?? "",
-        files: prompt.files,
-        delivery: "steer",
-      },
-      { signal },
-    )
-  }
-  return client.session.prompt(
-    { sessionID: session.id, id: prompt.start.id, text: prompt.text, files: prompt.files, delivery: "steer" },
-    { signal },
-  )
-}
-
-function turnStart(messageID: string, slash: PreparedPrompt["slash"]): 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 {
-  const value = text.trim()
-  if (!value.startsWith("/")) return undefined
-  const [name, ...rest] = value.slice(1).split(/\s+/)
-  if (!name) return undefined
-  return { name, args: rest.join(" ").trim() }
-}
-
-export * as ACPTurn from "./turn"

packages/cli/test/acp/catalog.test.ts

@@ -118,71 +118,24 @@ describe("acp catalog and config options over the wire", () => {
     const session = await acp.newSession()
     acp.server.catalog.models = [testModel, secondModel]
     acp.server.catalog.agents = [buildAgent, planAgent, configured]
-    const set = (configId: string, value: string) =>
-      acp.request("session/set_config_option", { sessionId: session.sessionId, configId, value })
-    const initialModelReads = modelReads(acp)
 
-    const model = await set("model", "test/second-model")
-    const reloadedModelReads = modelReads(acp)
-    const missingModel = await rpcError(set("model", "test/missing-model"))
-    const missingModelReads = modelReads(acp)
+    const model = await acp.request("session/set_config_option", {
+      sessionId: session.sessionId,
+      configId: "model",
+      value: "test/second-model",
+    })
     await acp.request("session/set_mode", { sessionId: session.sessionId, modeId: "copilot-build" })
     const reads = agentReads(acp)
-    const missing = await rpcError(set("mode", "missing"))
+    const missing = await rpcError(
+      acp.request("session/set_config_option", { sessionId: session.sessionId, configId: "mode", value: "missing" }),
+    )
 
     expect(currentValue(model, "model")).toBe("test/second-model")
-    expect([reloadedModelReads, missingModelReads]).toEqual([initialModelReads + 1, initialModelReads + 2])
-    expect(missingModel).toMatchObject({ code: -32602, data: { modelId: "test/missing-model" } })
     expect(acp.server.selections).toContainEqual({ sessionID: session.sessionId, agent: "copilot-build" })
     expect(missing).toMatchObject({ code: -32602, data: { mode: "missing" } })
     expect(agentReads(acp)).toBeGreaterThan(reads)
   })
 
-  test.each([
-    [
-      "a sibling session closes",
-      async (acp: Wire) => {
-        const closed = await acp.newSession()
-        const open = await acp.newSession()
-        await acp.request("session/close", { sessionId: closed.sessionId })
-        return open.sessionId
-      },
-    ],
-    ...(["session/load", "session/resume"] as const).map(
-      (method) =>
-        [
-          `${method} re-attaches the session`,
-          async (acp: Wire) => {
-            const session = await acp.newSession()
-            const params = { cwd: "/workspace", sessionId: session.sessionId, mcpServers: [] }
-            await acp.request(method, params)
-            await acp.request(method, params)
-            return session.sessionId
-          },
-        ] as const,
-    ),
-  ])("pushes exactly one update per catalog change after %s", async (_, setup) => {
-    await using acp = await startWire()
-    acp.server.catalog.models = [testModel]
-    await acp.initialize()
-    const sessionId = await setup(acp)
-    const since = acp.updates.length
-
-    await change(acp, sessionId, "config_option_update", () => {
-      acp.server.catalog.models = [testModel, secondModel]
-      acp.server.send(ephemeralEvent("model.updated", {}))
-    })
-    await change(acp, sessionId, "available_commands_update", () => {
-      acp.server.catalog.commands = [reviewCommand, { name: "ship", description: "Ship it" }]
-      acp.server.send(ephemeralEvent("command.updated", {}, { directory: "/workspace" }))
-    })
-
-    expect(updateKinds(acp, since)).toEqual([
-      [sessionId, "config_option_update"],
-      [sessionId, "available_commands_update"],
-    ])
-  })
-
   test.each(["empty", "missing the default"])(
     "retries when the model list is %s but the default is ready",
     async (initial) => {
@@ -259,52 +212,25 @@ describe("acp catalog and config options over the wire", () => {
     await using acp = await startSession()
     const advertised = await acp.waitForUpdate((item) => commandNames(item) !== undefined)
 
-    acp.server.catalog.commands = [
-      reviewCommand,
-      { name: "compact", description: "Server compact" },
-      { name: "ship", description: "Ship it" },
-    ]
+    acp.server.catalog.commands = [reviewCommand, { name: "compact", description: "Server compact" }]
     acp.server.send(ephemeralEvent("command.updated", {}, { directory: "/workspace" }))
     const replaced = await acp.waitForUpdate((item) => item !== advertised && commandNames(item) !== undefined)
     const compacted = await acp.prompt(acp.sessionId, "/compact")
 
-    expect([advertised, replaced].map((item) => item.update)).toEqual([
-      {
+    expect([advertised, replaced].map((item) => item.update)).toEqual(
+      Array.from({ length: 2 }, () => ({
         sessionUpdate: "available_commands_update",
         availableCommands: [
           { name: "review", description: "Review changes" },
           { name: "compact", description: "Compact the session" },
         ],
-      },
-      {
-        sessionUpdate: "available_commands_update",
-        availableCommands: [
-          { name: "review", description: "Review changes" },
-          { name: "ship", description: "Ship it" },
-          { name: "compact", description: "Compact the session" },
-        ],
-      },
-    ])
+      })),
+    )
     expect(compacted.stopReason).toBe("end_turn")
     expect(acp.server.submissions.map((item) => item.kind)).toEqual(["compact"])
   })
 })
 
-// Each change waits on a catalog reload over HTTP, so a stray update for an earlier change lands before the next one.
-async function change(acp: Wire, sessionId: string, kind: string, trigger: () => void) {
-  const seen = acp.updates.filter((item) => item.sessionId === sessionId && item.update.sessionUpdate === kind).length
-  trigger()
-  await acp.until(
-    () =>
-      acp.updates.filter((item) => item.sessionId === sessionId && item.update.sessionUpdate === kind).length > seen,
-    kind,
-  )
-}
-
-function updateKinds(acp: Wire, since: number) {
-  return acp.updates.slice(since).map((item) => [item.sessionId, item.update.sessionUpdate])
-}
-
 function commandNames(item: SessionNotification) {
   if (item.update.sessionUpdate !== "available_commands_update") return undefined
   return item.update.availableCommands.map((command) => command.name)

packages/cli/test/acp/compaction.test.ts

@@ -1,271 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { SessionNotification } from "@agentclientprotocol/sdk"
-import { OpenCode, type OpenCodeEvent, type SessionMessageInfo } from "@opencode/client/promise"
-import { Event } from "@opencode/schema/event"
-import { SessionMessage } from "@opencode/schema/session-message"
-import { Schema } from "effect"
-import {
-  assistantMessage,
-  childCreated,
-  durableEvent,
-  ephemeralEvent,
-  makeSession,
-  startSession,
-  startWire,
-  stepEnded,
-  succeeded,
-  textDelta,
-  turn,
-} from "./wire-fixture"
-
-const summary = "Summary of the earlier conversation"
-const providerError = { type: "provider.error", message: "summary request failed", status: 500 }
-const decodeCompact = Schema.decodeUnknownSync(Schema.Struct({ id: Schema.String }))
-
-describe("acp compaction markers over the wire", () => {
-  test("marks a /compact turn without forwarding the summary text", async () => {
-    const compacted = await compactTurn((sessionID, id) => [
-      durableEvent("session.compaction.started", { sessionID, reason: "manual", recent: "", inputID: id }),
-      ephemeralEvent("session.compaction.delta", { sessionID, text: summary }),
-      durableEvent("session.compaction.ended", { sessionID, reason: "manual", text: summary, recent: "" }),
-    ])
-    await using acp = compacted.acp
-
-    expect(turnUpdates(acp.updates)).toEqual([
-      marker(acp.sessionId, { status: "started", messageId: compacted.id, reason: "manual" }),
-      marker(acp.sessionId, { status: "completed", messageId: compacted.id, reason: "manual" }),
-    ])
-    expect(compacted.response.stopReason).toBe("end_turn")
-  })
-
-  test("marks a failed /compact turn with the full compaction error", async () => {
-    const compacted = await compactTurn((sessionID, id) => [
-      durableEvent("session.compaction.started", { sessionID, reason: "manual", recent: "", inputID: id }),
-      durableEvent("session.compaction.failed", { sessionID, reason: "manual", inputID: id, error: providerError }),
-    ])
-    await using acp = compacted.acp
-
-    expect(turnUpdates(acp.updates)).toEqual([
-      marker(acp.sessionId, { status: "started", messageId: compacted.id, reason: "manual" }),
-      marker(acp.sessionId, { status: "failed", messageId: compacted.id, reason: "manual", error: providerError }),
-    ])
-    expect(compacted.response.stopReason).toBe("end_turn")
-  })
-
-  test("marks an automatic compaction between steps with the ID its replayed message gets", async () => {
-    await using acp = await startSession({
-      onPrompt: ({ sessionID, id }) =>
-        turn(
-          sessionID,
-          id,
-          textDelta(sessionID, "msg_before", "before"),
-          stepEnded(sessionID, "msg_before"),
-          durableEvent("session.compaction.started", { sessionID, reason: "auto", recent: "" }),
-          ephemeralEvent("session.compaction.delta", { sessionID, text: summary }),
-          durableEvent("session.compaction.ended", { sessionID, reason: "auto", text: summary, recent: "" }),
-          textDelta(sessionID, "msg_after", "after"),
-          stepEnded(sessionID, "msg_after"),
-        ),
-    })
-    using events = await watchEvents(acp.server.url)
-
-    const response = await acp.prompt(acp.sessionId, "hello")
-
-    const messageId = await events.messageID("session.compaction.started")
-    expect(turnUpdates(acp.updates)).toEqual([
-      chunk(acp.sessionId, "msg_before", "before"),
-      marker(acp.sessionId, { status: "started", messageId, reason: "auto" }),
-      marker(acp.sessionId, { status: "completed", messageId, reason: "auto" }),
-      chunk(acp.sessionId, "msg_after", "after"),
-    ])
-    expect(response.stopReason).toBe("end_turn")
-
-    const live = turnUpdates(acp.updates)
-    acp.server.messages.set(acp.sessionId, [
-      {
-        id: messageId,
-        type: "compaction",
-        status: "completed",
-        reason: "auto",
-        summary,
-        recent: "",
-        time: { created: 1 },
-      },
-    ])
-    await acp.request("session/load", { cwd: "/workspace", sessionId: acp.sessionId, mcpServers: [] })
-
-    expect(turnUpdates(acp.updates).slice(live.length)).toEqual([
-      marker(acp.sessionId, { status: "completed", messageId, reason: "auto" }),
-    ])
-  })
-
-  test("marks automatic compaction failures before and after the compaction starts", async () => {
-    await using acp = await startSession({
-      onPrompt: ({ sessionID, id }) =>
-        turn(
-          sessionID,
-          id,
-          durableEvent("session.compaction.failed", {
-            sessionID,
-            reason: "auto",
-            error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
-          }),
-          durableEvent("session.compaction.started", { sessionID, reason: "auto", recent: "" }),
-          durableEvent("session.compaction.failed", { sessionID, reason: "auto", error: providerError }),
-        ),
-    })
-    using events = await watchEvents(acp.server.url)
-
-    await acp.prompt(acp.sessionId, "hello")
-
-    const unstarted = await events.messageID("session.compaction.failed")
-    const started = await events.messageID("session.compaction.started")
-    expect(turnUpdates(acp.updates)).toEqual([
-      marker(acp.sessionId, {
-        status: "failed",
-        messageId: unstarted,
-        reason: "auto",
-        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
-      }),
-      marker(acp.sessionId, { status: "started", messageId: started, reason: "auto" }),
-      marker(acp.sessionId, { status: "failed", messageId: started, reason: "auto", error: providerError }),
-    ])
-  })
-
-  test("projects child session compaction markers onto the parent turn", async () => {
-    await using acp = await startSession({
-      onPrompt: ({ sessionID, id }) =>
-        turn(
-          sessionID,
-          id,
-          childCreated("ses_child", sessionID, "Explore"),
-          durableEvent("session.compaction.started", { sessionID: "ses_child", reason: "auto", recent: "" }),
-          ephemeralEvent("session.compaction.delta", { sessionID: "ses_child", text: summary }),
-          durableEvent("session.compaction.ended", {
-            sessionID: "ses_child",
-            reason: "auto",
-            text: summary,
-            recent: "",
-          }),
-          succeeded("ses_child"),
-        ),
-    })
-    using events = await watchEvents(acp.server.url)
-
-    await acp.prompt(acp.sessionId, "hello")
-
-    const messageId = await events.messageID("session.compaction.started")
-    const child = { id: "ses_child", parentID: acp.sessionId, depth: 1, title: "Explore" }
-    expect(turnUpdates(acp.updates).map((item) => item.update._meta)).toEqual([
-      { "opencode/compaction": { status: "started", messageId, reason: "auto" }, "opencode/child-session": child },
-      { "opencode/compaction": { status: "completed", messageId, reason: "auto" }, "opencode/child-session": child },
-    ])
-  })
-
-  test("replays settled compactions at their position on session/load", async () => {
-    await using acp = await startWire()
-    acp.server.sessions.set("ses_compacted", makeSession("ses_compacted"))
-    acp.server.messages.set("ses_compacted", compactedHistory())
-    await acp.initialize()
-
-    await acp.request("session/load", { cwd: "/workspace", sessionId: "ses_compacted", mcpServers: [] })
-
-    expect(turnUpdates(acp.updates)).toEqual([
-      {
-        sessionId: "ses_compacted",
-        update: {
-          sessionUpdate: "user_message_chunk",
-          messageId: "msg_user",
-          content: { type: "text", text: "hello" },
-        },
-      },
-      marker("ses_compacted", {
-        status: "failed",
-        messageId: "msg_compaction_failed",
-        reason: "auto",
-        error: providerError,
-      }),
-      marker("ses_compacted", { status: "completed", messageId: "msg_compaction", reason: "manual" }),
-      chunk("ses_compacted", "msg_after", "after"),
-    ])
-  })
-})
-
-// Holds the compact response so the test can publish the turn's events while the request is in flight.
-async function compactTurn(events: (sessionID: string, id: string) => OpenCodeEvent[]) {
-  const held = Promise.withResolvers<Response>()
-  const acp = await startSession({ fetch: (request) => (request.path.endsWith("/compact") ? held.promise : undefined) })
-  const response = acp.prompt(acp.sessionId, "/compact")
-  const request = await acp.until(
-    () => acp.server.requests.find((item) => item.path.endsWith("/compact")),
-    "compact request",
-  )
-  const id = decodeCompact(request.body).id
-  acp.server.send(...turn(acp.sessionId, id, ...events(acp.sessionId, id)))
-  held.resolve(Response.json({ data: {} }))
-  return { acp, id, response: await response }
-}
-
-// Core derives an automatic compaction's message ID from the event ID the server stamps on publish.
-async function watchEvents(url: string) {
-  const controller = new AbortController()
-  const stream = OpenCode.make({ baseUrl: url }).event.subscribe({ signal: controller.signal })[Symbol.asyncIterator]()
-  await stream.next()
-  return {
-    async messageID(type: OpenCodeEvent["type"]) {
-      while (true) {
-        const next = await stream.next()
-        if (next.done) throw new Error(`event stream ended before ${type}`)
-        if (next.value.type === type) return SessionMessage.ID.fromEvent(Event.ID.make(next.value.id))
-      }
-    },
-    [Symbol.dispose]: () => controller.abort(),
-  }
-}
-
-function marker(sessionId: string, value: Record<string, unknown>): SessionNotification {
-  return { sessionId, update: { sessionUpdate: "session_info_update", _meta: { "opencode/compaction": value } } }
-}
-
-function chunk(sessionId: string, messageId: string, text: string): SessionNotification {
-  return { sessionId, update: { sessionUpdate: "agent_message_chunk", messageId, content: { type: "text", text } } }
-}
-
-function turnUpdates(updates: readonly SessionNotification[]) {
-  return updates.filter(
-    (item) => item.update.sessionUpdate !== "available_commands_update" && item.update.sessionUpdate !== "usage_update",
-  )
-}
-
-function compactedHistory(): SessionMessageInfo[] {
-  return [
-    { id: "msg_user", type: "user", text: "hello", time: { created: 1 } },
-    {
-      id: "msg_compaction_failed",
-      type: "compaction",
-      status: "failed",
-      reason: "auto",
-      error: providerError,
-      time: { created: 2 },
-    },
-    {
-      id: "msg_compaction",
-      type: "compaction",
-      status: "completed",
-      reason: "manual",
-      summary,
-      recent: "",
-      time: { created: 3 },
-    },
-    {
-      id: "msg_compaction_running",
-      type: "compaction",
-      status: "running",
-      reason: "auto",
-      summary: "",
-      recent: "",
-      time: { created: 4 },
-    },
-    assistantMessage("msg_after", { time: { created: 5, completed: 6 }, content: [{ type: "text", text: "after" }] }),
-  ]
-}

packages/cli/test/acp/session.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import type { McpServer } from "@agentclientprotocol/sdk"
 import { currentValue } from "./select-options"
-import { ephemeralEvent, makeSession, rpcError, secondModel, startSession, startWire, testModel } from "./wire-fixture"
+import { makeSession, rpcError, secondModel, startSession, startWire } from "./wire-fixture"
 
 describe("acp session lifecycle over the wire", () => {
   test("initialize advertises capabilities and terminal auth only when the client asks", async () => {
@@ -226,33 +226,4 @@ describe("acp session lifecycle over the wire", () => {
       config: { type: "remote", url: "https://example.com/mcp", headers: { Authorization: "Bearer x" }, oauth: false },
     })
   })
-  test("leaves a session detached when re-attaching it fails", async () => {
-    const broken: McpServer = { name: "broken", command: "bun", args: [], env: [] }
-    await using acp = await startWire({
-      fetch: (request) =>
-        request.method === "PUT" && request.path === "/api/experimental/mcp/broken"
-          ? new Response(null, { status: 500 })
-          : undefined,
-    })
-    await acp.initialize()
-    const failed = await acp.newSession()
-    const other = await acp.newSession()
-
-    expect(
-      await rpcError(
-        acp.request("session/resume", { cwd: "/workspace", sessionId: failed.sessionId, mcpServers: [broken] }),
-      ),
-    ).toMatchObject({ code: -32603 })
-    const since = acp.updates.length
-    acp.server.catalog.models = [testModel]
-    acp.server.send(ephemeralEvent("model.updated", {}))
-    await acp.until(() => acp.updates.length > since, "config options for the attached session")
-
-    expect(acp.updates.slice(since).map((item) => item.sessionId)).toEqual([other.sessionId])
-    expect(
-      await rpcError(
-        acp.request("session/set_config_option", { sessionId: failed.sessionId, configId: "mode", value: "plan" }),
-      ),
-    ).toMatchObject({ code: -32602, data: { sessionId: failed.sessionId } })
-  })
 })

packages/core/src/models-dev/snapshot.txt

@@ -1 +1 @@
-{"deepinfra":{"id":"deepinfra","env":["DEEPINFRA_API_KEY"],"npm":"@ai-sdk/deepinfra","name":"Deep Infra","doc":"https://deepinfra.com/models","models":{"tencent/Hy3":{"id":"tencent/Hy3","name":"Hy3","description":"Tencent Hy reasoning model for coding, instruction following, and agent tasks","family":"Hy","attachment":false,"reasoning":true,"reasoning_options":[],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-07-06","last_updated":"2026-07-06","modalities":{"input":["text"],"output":["text"]},"open_weights":true,"limit":{"context":262144,"input":192000,"output":128000},"cost":{"input":0.13,"output":0.53,"cache_read":0.033},"canonical_model_id":"tencent/hy3"},"tencent/Hy4-preview":{"id":"tencent/Hy4-preview","name":"Hy4 preview","description":"A next-generation productivity model with significantly enhanced Agent and complex task execution capabilities.","family":"Hy","attachment":false,"reasoning":true,"reasoning_options":[{"type":"effort","values":["none","high"]}],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-08-28","last_updated":"2026-08-28","modalities":{"input":["text"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":64000},"cost":{"input":0.834,"output":2.501,"cache_read":0.042},"canonical_model_id":"tencent/hy4-preview"},"meta-llama/Llama-3.3-70B-Instruct-Turbo":{"id":"meta-llama/Llama-3.3-70B-Instruct-Turbo","name":"Llama 3.3 70B Turbo","description":"Compact Llama instruction model for fast chat and local deployment","family":"llama","attachment":false,"reasoning":false,"tool_call":true,"structured_output":true,"release_date":"2024-12-06","last_updated":"2024-12-06","modalities":{"input":["text"],"output":["text"]},"open_weights":true,"limit":{"context":131072,"output":16384},"cost":{"input":0.1,"output":0.32}},"meta-llama/Llama-4-Scout-17B-16E-Instruct":{"id":"meta-llama/Llama-4-Scout-17B-16E-Instruct","name":"Llama 4 Scout 17B","description":"Open multimodal Llama model for long-context analysis and efficient agents","family":"llama","attachment":true,"reasoning":false,"tool_call":true,"structured_output":true,"release_date":"2025-04-05","last_updated":"2025-04-05","modalities":{"input":["text","image"],"output":["text"]},"open_weights":true,"limit":{"context":327680,"output":16384},"cost":{"input":0.1,"output":0.3}},"meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8":{"id":"meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8","name":"Llama 4 Maverick 17B FP8","description":"Open multimodal Llama model for strong reasoning and fast responses","family":"llama","attachment":true,"reasoning":false,"tool_call":false,"structured_output":true,"release_date":"2025-04-05","last_updated":"2025-04-05","modalities":{"input":["text","image"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":16384},"cost":{"input":0.2,"output":0.8}},"XiaomiMiMo/MiMo-V2.6-Pro":{"id":"XiaomiMiMo/MiMo-V2.6-Pro","name":"MiMo-V2.6-Pro","description":"Stronger MiMo Pro tier for multimodal reasoning and coding-agent execution","family":"mimo","attachment":true,"reasoning":true,"reasoning_options":[{"type":"toggle"}],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-09-22","last_updated":"2026-09-22","modalities":{"input":["text","image","audio","video"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":131072},"cost":{"input":0.43,"output":0.87,"cache_read":0.0036},"canonical_model_id":"xiaomi/mimo-v2.6-pro"},"XiaomiMiMo/MiMo-V2.5-Pro":{"id":"XiaomiMiMo/MiMo-V2.5-Pro","name":"MiMo-V2.5-Pro","description":"Stronger MiMo Pro tier for multimodal reasoning and coding-agent execution","family":"mimo","attachment":true,"reasoning":true,"reasoning_options":[{"type":"toggle"}],"tool_call":true,"interleaved":{"field":"reasoning_content"},"structured_output":true,"temperature":true,"knowledge":"2024-12","release_date":"2026-04-22","last_updated":"2026-04-22","modalities":{"input":["text","audio"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":16384},"status":"deprecated","cost":{"input":1,"output":3,"cache_read":0.2},"canonical_model_id":"xiaomi/mimo-v2.5-pro"},"XiaomiMiMo/MiMo-V2.6-Flash":{"id":"XiaomiMiMo/MiMo-V2.6-Flash","name":"MiMo-V2.6-Flash","description":"MiMo Flash model for multimodal coding agents and long-context automation","family":"mimo","attachment":true,"reasoning":true,"reasoning_options":[{"type":"toggle"}],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-09-22","last_updated":"2026-09-22","modalities":{"input":["text","image","audio","video"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":131072},"cost":{"input":0.14,"output":0.28,"cache_read":0.0028},"canonical_model_id":"xiaomi/mimo-v2.6-flash"},"XiaomiMiMo/MiMo-V2.5":{"id":"XiaomiMiMo/MiMo-V2.5","name":"MiMo-V2.5","description":"Open MiMo model for multimodal coding agents and long-context automation","famLine truncated
+{"deepinfra":{"id":"deepinfra","env":["DEEPINFRA_API_KEY"],"npm":"@ai-sdk/deepinfra","name":"Deep Infra","doc":"https://deepinfra.com/models","models":{"tencent/Hy3":{"id":"tencent/Hy3","name":"Hy3","description":"Tencent Hy reasoning model for coding, instruction following, and agent tasks","family":"Hy","attachment":false,"reasoning":true,"reasoning_options":[],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-07-06","last_updated":"2026-07-06","modalities":{"input":["text"],"output":["text"]},"open_weights":true,"limit":{"context":262144,"input":192000,"output":128000},"cost":{"input":0.13,"output":0.53,"cache_read":0.033},"canonical_model_id":"tencent/hy3"},"tencent/Hy4-preview":{"id":"tencent/Hy4-preview","name":"Hy4 preview","description":"A next-generation productivity model with significantly enhanced Agent and complex task execution capabilities.","family":"Hy","attachment":false,"reasoning":true,"reasoning_options":[{"type":"effort","values":["none","high"]}],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-08-28","last_updated":"2026-08-28","modalities":{"input":["text"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":64000},"cost":{"input":0.834,"output":2.501,"cache_read":0.042},"canonical_model_id":"tencent/hy4-preview"},"meta-llama/Llama-3.3-70B-Instruct-Turbo":{"id":"meta-llama/Llama-3.3-70B-Instruct-Turbo","name":"Llama 3.3 70B Turbo","description":"Compact Llama instruction model for fast chat and local deployment","family":"llama","attachment":false,"reasoning":false,"tool_call":true,"structured_output":true,"release_date":"2024-12-06","last_updated":"2024-12-06","modalities":{"input":["text"],"output":["text"]},"open_weights":true,"limit":{"context":131072,"output":16384},"cost":{"input":0.1,"output":0.32}},"meta-llama/Llama-4-Scout-17B-16E-Instruct":{"id":"meta-llama/Llama-4-Scout-17B-16E-Instruct","name":"Llama 4 Scout 17B","description":"Open multimodal Llama model for long-context analysis and efficient agents","family":"llama","attachment":true,"reasoning":false,"tool_call":true,"structured_output":true,"release_date":"2025-04-05","last_updated":"2025-04-05","modalities":{"input":["text","image"],"output":["text"]},"open_weights":true,"limit":{"context":327680,"output":16384},"cost":{"input":0.1,"output":0.3}},"meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8":{"id":"meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8","name":"Llama 4 Maverick 17B FP8","description":"Open multimodal Llama model for strong reasoning and fast responses","family":"llama","attachment":true,"reasoning":false,"tool_call":false,"structured_output":true,"release_date":"2025-04-05","last_updated":"2025-04-05","modalities":{"input":["text","image"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":16384},"cost":{"input":0.2,"output":0.8}},"XiaomiMiMo/MiMo-V2.6-Pro":{"id":"XiaomiMiMo/MiMo-V2.6-Pro","name":"MiMo-V2.6-Pro","description":"Stronger MiMo Pro tier for multimodal reasoning and coding-agent execution","family":"mimo","attachment":true,"reasoning":true,"reasoning_options":[{"type":"toggle"}],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-09-22","last_updated":"2026-09-22","modalities":{"input":["text","image","audio","video"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":131072},"cost":{"input":0.43,"output":0.87,"cache_read":0.0036},"canonical_model_id":"xiaomi/mimo-v2.6-pro"},"XiaomiMiMo/MiMo-V2.5-Pro":{"id":"XiaomiMiMo/MiMo-V2.5-Pro","name":"MiMo-V2.5-Pro","description":"Stronger MiMo Pro tier for multimodal reasoning and coding-agent execution","family":"mimo","attachment":true,"reasoning":true,"reasoning_options":[{"type":"toggle"}],"tool_call":true,"interleaved":{"field":"reasoning_content"},"structured_output":true,"temperature":true,"knowledge":"2024-12","release_date":"2026-04-22","last_updated":"2026-04-22","modalities":{"input":["text","audio"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":16384},"status":"deprecated","cost":{"input":1,"output":3,"cache_read":0.2},"canonical_model_id":"xiaomi/mimo-v2.5-pro"},"XiaomiMiMo/MiMo-V2.6-Flash":{"id":"XiaomiMiMo/MiMo-V2.6-Flash","name":"MiMo-V2.6-Flash","description":"MiMo Flash model for multimodal coding agents and long-context automation","family":"mimo","attachment":true,"reasoning":true,"reasoning_options":[{"type":"toggle"}],"tool_call":true,"structured_output":true,"temperature":true,"release_date":"2026-09-22","last_updated":"2026-09-22","modalities":{"input":["text","image","audio","video"],"output":["text"]},"open_weights":true,"limit":{"context":1048576,"output":131072},"cost":{"input":0.14,"output":0.28,"cache_read":0.0028},"canonical_model_id":"xiaomi/mimo-v2.6-flash"},"XiaomiMiMo/MiMo-V2.5":{"id":"XiaomiMiMo/MiMo-V2.5","name":"MiMo-V2.5","description":"Open MiMo model for multimodal coding agents and long-context automation","famLine truncated

packages/protocol/openapi.json

@@ -48,6 +48,106 @@
         "summary": "Get server info"
       }
     },
+    "/api/pair": {
+      "post": {
+        "tags": ["server"],
+        "operationId": "server.pair",
+        "parameters": [],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "PairingCode",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PairingCode"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "Create a short-lived, single-use code for a /auth/connect/:code pairing link.",
+        "summary": "Create pairing code"
+      }
+    },
+    "/auth/connect/{code}": {
+      "get": {
+        "tags": ["server"],
+        "operationId": "server.connect",
+        "parameters": [
+          {
+            "name": "code",
+            "in": "path",
+            "schema": {
+              "type": "string"
+            },
+            "required": true
+          }
+        ],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "PairingSession",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PairingSession"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                    },
+                    {
+                      "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        },
+        "description": "Redeem a pairing code. Browsers receive a session cookie and a redirect to the web app; requests that accept JSON receive a session token to use as the password.",
+        "summary": "Redeem pairing code"
+      }
+    },
     "/api/location": {
       "get": {
         "tags": ["location"],
@@ -886,9 +986,19 @@
                 }
               }
             }
+          },
+          "404": {
+            "description": "SessionNotFoundError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
+                }
+              }
+            }
           }
         },
-        "description": "Create a session at the requested location.",
+        "description": "Create a session at the requested location. A parentID creates a linked child session at its parent's location.",
         "summary": "Create session",
         "requestBody": {
           "content": {
@@ -907,6 +1017,17 @@
                       }
                     ]
                   },
+                  "parentID": {
+                    "anyOf": [
+                      {
+                        "type": "string",
+                        "pattern": "^ses"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ]
+                  },
                   "title": {
                     "anyOf": [
                       {
@@ -4508,6 +4629,21 @@
               "pattern": "^frm_"
             },
             "required": true
+          },
+          {
+            "name": "message",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "required": false
           }
         ],
         "security": [],
@@ -4591,21 +4727,6 @@
               "pattern": "^frm_"
             },
             "required": true
-          },
-          {
-            "name": "message",
-            "in": "query",
-            "schema": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "required": false
           }
         ],
         "security": [],
@@ -7197,6 +7318,125 @@
         "summary": "List MCP resources"
       }
     },
+    "/api/credential": {
+      "get": {
+        "tags": ["credential"],
+        "operationId": "credential.list",
+        "parameters": [],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "data": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/components/schemas/Credential.Entry"
+                      }
+                    }
+                  },
+                  "required": ["data"],
+                  "additionalProperties": false
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "List every stored integration credential, including its secret value.",
+        "summary": "List credentials"
+      },
+      "post": {
+        "tags": ["credential"],
+        "operationId": "credential.create",
+        "parameters": [],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "data": {
+                      "$ref": "#/components/schemas/Credential.Entry"
+                    }
+                  },
+                  "required": ["data"],
+                  "additionalProperties": false
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          },
+          "409": {
+            "description": "ConflictError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ConflictErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "Store an integration credential. It becomes the integration's active credential unless activate is false and the integration already has one. Fails with a conflict when the requested ID already exists.",
+        "summary": "Create credential",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/Credential.CreateInput"
+              }
+            }
+          },
+          "required": true
+        }
+      }
+    },
     "/api/credential/{credentialID}": {
       "patch": {
         "tags": ["credential"],
@@ -13631,6 +13871,9 @@
           "method": {
             "type": "string",
             "enum": ["key", "oauth"]
+          },
+          "status": {
+            "$ref": "#/components/schemas/Connection.Status"
           }
         },
         "required": ["type", "id", "label", "method"],
@@ -13645,6 +13888,9 @@
           },
           "name": {
             "type": "string"
+          },
+          "status": {
+            "$ref": "#/components/schemas/Connection.Status"
           }
         },
         "required": ["type", "name"],
@@ -13660,6 +13906,128 @@
           }
         ]
       },
+      "Connection.Status": {
+        "type": "object",
+        "properties": {
+          "status": {
+            "anyOf": [
+              {
+                "type": "string",
+                "enum": ["needs_auth"]
+              }
+            ]
+          },
+          "message": {
+            "type": "string"
+          },
+          "url": {
+            "type": "string"
+          }
+        },
+        "required": ["status", "message"],
+        "additionalProperties": false
+      },
+      "Credential.CreateInput": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "integrationID": {
+            "type": "string"
+          },
+          "label": {
+            "type": "string"
+          },
+          "value": {
+            "$ref": "#/components/schemas/Credential.Value"
+          },
+          "activate": {
+            "type": "boolean"
+          }
+        },
+        "required": ["integrationID", "value"],
+        "additionalProperties": false
+      },
+      "Credential.Entry": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "integrationID": {
+            "type": "string"
+          },
+          "label": {
+            "type": "string"
+          },
+          "active": {
+            "type": "boolean"
+          },
+          "value": {
+            "$ref": "#/components/schemas/Credential.Value"
+          }
+        },
+        "required": ["id", "integrationID", "label", "active", "value"],
+        "additionalProperties": false
+      },
+      "Credential.Key": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": ["key"]
+          },
+          "key": {
+            "type": "string"
+          },
+          "metadata": {
+            "type": "object"
+          },
+          "configuration": {
+            "$ref": "#/components/schemas/Form.Answer_1"
+          }
+        },
+        "required": ["type", "key"],
+        "additionalProperties": false
+      },
+      "Credential.OAuth": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": ["oauth"]
+          },
+          "methodID": {
+            "type": "string"
+          },
+          "refresh": {
+            "type": "string"
+          },
+          "access": {
+            "type": "string"
+          },
+          "expires": {
+            "type": "integer",
+            "minimum": 0
+          },
+          "metadata": {
+            "type": "object"
+          }
+        },
+        "required": ["type", "methodID", "refresh", "access", "expires"],
+        "additionalProperties": false
+      },
+      "Credential.Value": {
+        "anyOf": [
+          {
+            "$ref": "#/components/schemas/Credential.OAuth"
+          },
+          {
+            "$ref": "#/components/schemas/Credential.Key"
+          }
+        ]
+      },
       "FileDiff.Info": {
         "type": "object",
         "properties": {
@@ -13746,6 +14114,12 @@
           "$ref": "#/components/schemas/Form.Value"
         }
       },
+      "Form.Answer_1": {
+        "type": "object",
+        "additionalProperties": {
+          "$ref": "#/components/schemas/Form.Value"
+        }
+      },
       "Form.BooleanField": {
         "type": "object",
         "properties": {
@@ -15709,6 +16083,29 @@
       "Money.USDPerMillionTokens": {
         "type": "number"
       },
+      "PairingCode": {
+        "type": "object",
+        "properties": {
+          "code": {
+            "type": "string"
+          },
+          "expires_in": {
+            "type": "integer"
+          }
+        },
+        "required": ["code", "expires_in"],
+        "additionalProperties": false
+      },
+      "PairingSession": {
+        "type": "object",
+        "properties": {
+          "token": {
+            "type": "string"
+          }
+        },
+        "required": ["token"],
+        "additionalProperties": false
+      },
       "Permission.Effect": {
         "type": "string",
         "enum": ["allow", "deny", "ask"]
@@ -18234,6 +18631,16 @@
             "type": "integer",
             "minimum": 100,
             "maximum": 599
+          },
+          "response": {
+            "type": "object",
+            "properties": {
+              "body": {
+                "type": "string"
+              }
+            },
+            "required": ["body"],
+            "additionalProperties": false
           }
         },
         "required": ["type", "message"],
@@ -18653,6 +19060,9 @@
           "exit": {
             "type": "number"
           },
+          "signal": {
+            "type": "string"
+          },
           "metadata": {
             "type": "object"
           },

services/www/openapi.json

@@ -48,6 +48,106 @@
         "summary": "Get server info"
       }
     },
+    "/api/pair": {
+      "post": {
+        "tags": ["server"],
+        "operationId": "server.pair",
+        "parameters": [],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "PairingCode",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PairingCode"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "Create a short-lived, single-use code for a /auth/connect/:code pairing link.",
+        "summary": "Create pairing code"
+      }
+    },
+    "/auth/connect/{code}": {
+      "get": {
+        "tags": ["server"],
+        "operationId": "server.connect",
+        "parameters": [
+          {
+            "name": "code",
+            "in": "path",
+            "schema": {
+              "type": "string"
+            },
+            "required": true
+          }
+        ],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "PairingSession",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PairingSession"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                    },
+                    {
+                      "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        },
+        "description": "Redeem a pairing code. Browsers receive a session cookie and a redirect to the web app; requests that accept JSON receive a session token to use as the password.",
+        "summary": "Redeem pairing code"
+      }
+    },
     "/api/location": {
       "get": {
         "tags": ["location"],
@@ -886,9 +986,19 @@
                 }
               }
             }
+          },
+          "404": {
+            "description": "SessionNotFoundError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
+                }
+              }
+            }
           }
         },
-        "description": "Create a session at the requested location.",
+        "description": "Create a session at the requested location. A parentID creates a linked child session at its parent's location.",
         "summary": "Create session",
         "requestBody": {
           "content": {
@@ -907,6 +1017,17 @@
                       }
                     ]
                   },
+                  "parentID": {
+                    "anyOf": [
+                      {
+                        "type": "string",
+                        "pattern": "^ses"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ]
+                  },
                   "title": {
                     "anyOf": [
                       {
@@ -4508,6 +4629,21 @@
               "pattern": "^frm_"
             },
             "required": true
+          },
+          {
+            "name": "message",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "required": false
           }
         ],
         "security": [],
@@ -4591,21 +4727,6 @@
               "pattern": "^frm_"
             },
             "required": true
-          },
-          {
-            "name": "message",
-            "in": "query",
-            "schema": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "required": false
           }
         ],
         "security": [],
@@ -7197,6 +7318,125 @@
         "summary": "List MCP resources"
       }
     },
+    "/api/credential": {
+      "get": {
+        "tags": ["credential"],
+        "operationId": "credential.list",
+        "parameters": [],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "data": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/components/schemas/Credential.Entry"
+                      }
+                    }
+                  },
+                  "required": ["data"],
+                  "additionalProperties": false
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "List every stored integration credential, including its secret value.",
+        "summary": "List credentials"
+      },
+      "post": {
+        "tags": ["credential"],
+        "operationId": "credential.create",
+        "parameters": [],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "data": {
+                      "$ref": "#/components/schemas/Credential.Entry"
+                    }
+                  },
+                  "required": ["data"],
+                  "additionalProperties": false
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          },
+          "409": {
+            "description": "ConflictError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ConflictErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "Store an integration credential. It becomes the integration's active credential unless activate is false and the integration already has one. Fails with a conflict when the requested ID already exists.",
+        "summary": "Create credential",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/Credential.CreateInput"
+              }
+            }
+          },
+          "required": true
+        }
+      }
+    },
     "/api/credential/{credentialID}": {
       "patch": {
         "tags": ["credential"],
@@ -13631,6 +13871,9 @@
           "method": {
             "type": "string",
             "enum": ["key", "oauth"]
+          },
+          "status": {
+            "$ref": "#/components/schemas/Connection.Status"
           }
         },
         "required": ["type", "id", "label", "method"],
@@ -13645,6 +13888,9 @@
           },
           "name": {
             "type": "string"
+          },
+          "status": {
+            "$ref": "#/components/schemas/Connection.Status"
           }
         },
         "required": ["type", "name"],
@@ -13660,6 +13906,128 @@
           }
         ]
       },
+      "Connection.Status": {
+        "type": "object",
+        "properties": {
+          "status": {
+            "anyOf": [
+              {
+                "type": "string",
+                "enum": ["needs_auth"]
+              }
+            ]
+          },
+          "message": {
+            "type": "string"
+          },
+          "url": {
+            "type": "string"
+          }
+        },
+        "required": ["status", "message"],
+        "additionalProperties": false
+      },
+      "Credential.CreateInput": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "integrationID": {
+            "type": "string"
+          },
+          "label": {
+            "type": "string"
+          },
+          "value": {
+            "$ref": "#/components/schemas/Credential.Value"
+          },
+          "activate": {
+            "type": "boolean"
+          }
+        },
+        "required": ["integrationID", "value"],
+        "additionalProperties": false
+      },
+      "Credential.Entry": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "integrationID": {
+            "type": "string"
+          },
+          "label": {
+            "type": "string"
+          },
+          "active": {
+            "type": "boolean"
+          },
+          "value": {
+            "$ref": "#/components/schemas/Credential.Value"
+          }
+        },
+        "required": ["id", "integrationID", "label", "active", "value"],
+        "additionalProperties": false
+      },
+      "Credential.Key": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": ["key"]
+          },
+          "key": {
+            "type": "string"
+          },
+          "metadata": {
+            "type": "object"
+          },
+          "configuration": {
+            "$ref": "#/components/schemas/Form.Answer_1"
+          }
+        },
+        "required": ["type", "key"],
+        "additionalProperties": false
+      },
+      "Credential.OAuth": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": ["oauth"]
+          },
+          "methodID": {
+            "type": "string"
+          },
+          "refresh": {
+            "type": "string"
+          },
+          "access": {
+            "type": "string"
+          },
+          "expires": {
+            "type": "integer",
+            "minimum": 0
+          },
+          "metadata": {
+            "type": "object"
+          }
+        },
+        "required": ["type", "methodID", "refresh", "access", "expires"],
+        "additionalProperties": false
+      },
+      "Credential.Value": {
+        "anyOf": [
+          {
+            "$ref": "#/components/schemas/Credential.OAuth"
+          },
+          {
+            "$ref": "#/components/schemas/Credential.Key"
+          }
+        ]
+      },
       "FileDiff.Info": {
         "type": "object",
         "properties": {
@@ -13746,6 +14114,12 @@
           "$ref": "#/components/schemas/Form.Value"
         }
       },
+      "Form.Answer_1": {
+        "type": "object",
+        "additionalProperties": {
+          "$ref": "#/components/schemas/Form.Value"
+        }
+      },
       "Form.BooleanField": {
         "type": "object",
         "properties": {
@@ -15709,6 +16083,29 @@
       "Money.USDPerMillionTokens": {
         "type": "number"
       },
+      "PairingCode": {
+        "type": "object",
+        "properties": {
+          "code": {
+            "type": "string"
+          },
+          "expires_in": {
+            "type": "integer"
+          }
+        },
+        "required": ["code", "expires_in"],
+        "additionalProperties": false
+      },
+      "PairingSession": {
+        "type": "object",
+        "properties": {
+          "token": {
+            "type": "string"
+          }
+        },
+        "required": ["token"],
+        "additionalProperties": false
+      },
       "Permission.Effect": {
         "type": "string",
         "enum": ["allow", "deny", "ask"]
@@ -18234,6 +18631,16 @@
             "type": "integer",
             "minimum": 100,
             "maximum": 599
+          },
+          "response": {
+            "type": "object",
+            "properties": {
+              "body": {
+                "type": "string"
+              }
+            },
+            "required": ["body"],
+            "additionalProperties": false
           }
         },
         "required": ["type", "message"],
@@ -18653,6 +19060,9 @@
           "exit": {
             "type": "number"
           },
+          "signal": {
+            "type": "string"
+          },
           "metadata": {
             "type": "object"
           },

services/www/public/openapi.json

@@ -48,6 +48,106 @@
         "summary": "Get server info"
       }
     },
+    "/api/pair": {
+      "post": {
+        "tags": ["server"],
+        "operationId": "server.pair",
+        "parameters": [],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "PairingCode",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PairingCode"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "Create a short-lived, single-use code for a /auth/connect/:code pairing link.",
+        "summary": "Create pairing code"
+      }
+    },
+    "/auth/connect/{code}": {
+      "get": {
+        "tags": ["server"],
+        "operationId": "server.connect",
+        "parameters": [
+          {
+            "name": "code",
+            "in": "path",
+            "schema": {
+              "type": "string"
+            },
+            "required": true
+          }
+        ],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "PairingSession",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PairingSession"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                    },
+                    {
+                      "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        },
+        "description": "Redeem a pairing code. Browsers receive a session cookie and a redirect to the web app; requests that accept JSON receive a session token to use as the password.",
+        "summary": "Redeem pairing code"
+      }
+    },
     "/api/location": {
       "get": {
         "tags": ["location"],
@@ -886,9 +986,19 @@
                 }
               }
             }
+          },
+          "404": {
+            "description": "SessionNotFoundError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
+                }
+              }
+            }
           }
         },
-        "description": "Create a session at the requested location.",
+        "description": "Create a session at the requested location. A parentID creates a linked child session at its parent's location.",
         "summary": "Create session",
         "requestBody": {
           "content": {
@@ -907,6 +1017,17 @@
                       }
                     ]
                   },
+                  "parentID": {
+                    "anyOf": [
+                      {
+                        "type": "string",
+                        "pattern": "^ses"
+                      },
+                      {
+                        "type": "null"
+                      }
+                    ]
+                  },
                   "title": {
                     "anyOf": [
                       {
@@ -4508,6 +4629,21 @@
               "pattern": "^frm_"
             },
             "required": true
+          },
+          {
+            "name": "message",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "required": false
           }
         ],
         "security": [],
@@ -4591,21 +4727,6 @@
               "pattern": "^frm_"
             },
             "required": true
-          },
-          {
-            "name": "message",
-            "in": "query",
-            "schema": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "required": false
           }
         ],
         "security": [],
@@ -7197,6 +7318,125 @@
         "summary": "List MCP resources"
       }
     },
+    "/api/credential": {
+      "get": {
+        "tags": ["credential"],
+        "operationId": "credential.list",
+        "parameters": [],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "data": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/components/schemas/Credential.Entry"
+                      }
+                    }
+                  },
+                  "required": ["data"],
+                  "additionalProperties": false
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "List every stored integration credential, including its secret value.",
+        "summary": "List credentials"
+      },
+      "post": {
+        "tags": ["credential"],
+        "operationId": "credential.create",
+        "parameters": [],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "data": {
+                      "$ref": "#/components/schemas/Credential.Entry"
+                    }
+                  },
+                  "required": ["data"],
+                  "additionalProperties": false
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          },
+          "409": {
+            "description": "ConflictError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ConflictErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "Store an integration credential. It becomes the integration's active credential unless activate is false and the integration already has one. Fails with a conflict when the requested ID already exists.",
+        "summary": "Create credential",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/Credential.CreateInput"
+              }
+            }
+          },
+          "required": true
+        }
+      }
+    },
     "/api/credential/{credentialID}": {
       "patch": {
         "tags": ["credential"],
@@ -13631,6 +13871,9 @@
           "method": {
             "type": "string",
             "enum": ["key", "oauth"]
+          },
+          "status": {
+            "$ref": "#/components/schemas/Connection.Status"
           }
         },
         "required": ["type", "id", "label", "method"],
@@ -13645,6 +13888,9 @@
           },
           "name": {
             "type": "string"
+          },
+          "status": {
+            "$ref": "#/components/schemas/Connection.Status"
           }
         },
         "required": ["type", "name"],
@@ -13660,6 +13906,128 @@
           }
         ]
       },
+      "Connection.Status": {
+        "type": "object",
+        "properties": {
+          "status": {
+            "anyOf": [
+              {
+                "type": "string",
+                "enum": ["needs_auth"]
+              }
+            ]
+          },
+          "message": {
+            "type": "string"
+          },
+          "url": {
+            "type": "string"
+          }
+        },
+        "required": ["status", "message"],
+        "additionalProperties": false
+      },
+      "Credential.CreateInput": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "integrationID": {
+            "type": "string"
+          },
+          "label": {
+            "type": "string"
+          },
+          "value": {
+            "$ref": "#/components/schemas/Credential.Value"
+          },
+          "activate": {
+            "type": "boolean"
+          }
+        },
+        "required": ["integrationID", "value"],
+        "additionalProperties": false
+      },
+      "Credential.Entry": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "integrationID": {
+            "type": "string"
+          },
+          "label": {
+            "type": "string"
+          },
+          "active": {
+            "type": "boolean"
+          },
+          "value": {
+            "$ref": "#/components/schemas/Credential.Value"
+          }
+        },
+        "required": ["id", "integrationID", "label", "active", "value"],
+        "additionalProperties": false
+      },
+      "Credential.Key": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": ["key"]
+          },
+          "key": {
+            "type": "string"
+          },
+          "metadata": {
+            "type": "object"
+          },
+          "configuration": {
+            "$ref": "#/components/schemas/Form.Answer_1"
+          }
+        },
+        "required": ["type", "key"],
+        "additionalProperties": false
+      },
+      "Credential.OAuth": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": ["oauth"]
+          },
+          "methodID": {
+            "type": "string"
+          },
+          "refresh": {
+            "type": "string"
+          },
+          "access": {
+            "type": "string"
+          },
+          "expires": {
+            "type": "integer",
+            "minimum": 0
+          },
+          "metadata": {
+            "type": "object"
+          }
+        },
+        "required": ["type", "methodID", "refresh", "access", "expires"],
+        "additionalProperties": false
+      },
+      "Credential.Value": {
+        "anyOf": [
+          {
+            "$ref": "#/components/schemas/Credential.OAuth"
+          },
+          {
+            "$ref": "#/components/schemas/Credential.Key"
+          }
+        ]
+      },
       "FileDiff.Info": {
         "type": "object",
         "properties": {
@@ -13746,6 +14114,12 @@
           "$ref": "#/components/schemas/Form.Value"
         }
       },
+      "Form.Answer_1": {
+        "type": "object",
+        "additionalProperties": {
+          "$ref": "#/components/schemas/Form.Value"
+        }
+      },
       "Form.BooleanField": {
         "type": "object",
         "properties": {
@@ -15709,6 +16083,29 @@
       "Money.USDPerMillionTokens": {
         "type": "number"
       },
+      "PairingCode": {
+        "type": "object",
+        "properties": {
+          "code": {
+            "type": "string"
+          },
+          "expires_in": {
+            "type": "integer"
+          }
+        },
+        "required": ["code", "expires_in"],
+        "additionalProperties": false
+      },
+      "PairingSession": {
+        "type": "object",
+        "properties": {
+          "token": {
+            "type": "string"
+          }
+        },
+        "required": ["token"],
+        "additionalProperties": false
+      },
       "Permission.Effect": {
         "type": "string",
         "enum": ["allow", "deny", "ask"]
@@ -18234,6 +18631,16 @@
             "type": "integer",
             "minimum": 100,
             "maximum": 599
+          },
+          "response": {
+            "type": "object",
+            "properties": {
+              "body": {
+                "type": "string"
+              }
+            },
+            "required": ["body"],
+            "additionalProperties": false
           }
         },
         "required": ["type", "message"],
@@ -18653,6 +19060,9 @@
           "exit": {
             "type": "number"
           },
+          "signal": {
+            "type": "string"
+          },
           "metadata": {
             "type": "object"
           },