saeeol 1.1.0 → 1.1.1

package/src/acp/agent-message.ts

@@ -0,0 +1,97 @@
+import { parse as parseDataUrl } from "@saeeol/boxes/dataurl"
+import { pathToFileURL } from "url"
+import type { Role, ToolCallContent } from "@agentclientprotocol/sdk"
+import type { SessionMessageResponse, ToolPart } from "@saeeol/sdk/v2"
+import { Result } from "effect"
+import type { AgentDeps } from "./agent-types"
+import { log, decodeTodos, toToolKind, toLocations } from "./agent-utils"
+import { bashOutput, toolStart } from "./agent-events"
+
+export async function processMessage(deps: AgentDeps, message: SessionMessageResponse) {
+  log.debug("process message", message)
+  if (message.info.role !== "assistant" && message.info.role !== "user") return
+  const sessionId = message.info.sessionID
+  for (const part of message.parts) {
+    if (part.type === "tool") {
+      await processToolPart(deps, sessionId, part)
+    } else if (part.type === "text") {
+      await processTextPart(deps, sessionId, message, part)
+    } else if (part.type === "file") {
+      await processFilePart(deps, sessionId, message, part)
+    } else if (part.type === "reasoning") {
+      await processReasoningPart(deps, sessionId, message, part)
+    }
+  }
+}
+
+async function processToolPart(deps: AgentDeps, sessionId: string, part: ToolPart) {
+  await toolStart(deps, sessionId, part)
+  switch (part.state.status) {
+    case "pending": deps.bashSnapshots.delete(part.callID); break
+    case "running": {
+      const output = bashOutput(deps, part)
+      const runningContent: ToolCallContent[] = []
+      if (output) runningContent.push({ type: "content", content: { type: "text", text: output } })
+      await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "tool_call_update", toolCallId: part.callID, status: "in_progress", kind: toToolKind(part.tool), title: part.tool, locations: toLocations(part.tool, part.state.input), rawInput: part.state.input, ...(runningContent.length > 0 && { content: runningContent }) } }).catch((err: any) => { log.error("failed to send tool in_progress to ACP", { error: err }) })
+      break
+    }
+    case "completed": {
+      deps.toolStarts.delete(part.callID)
+      deps.bashSnapshots.delete(part.callID)
+      const kind = toToolKind(part.tool)
+      const content: ToolCallContent[] = [{ type: "content", content: { type: "text", text: part.state.output } }]
+      if (kind === "edit") {
+        const input = part.state.input
+        content.push({ type: "diff", path: typeof input["filePath"] === "string" ? input["filePath"] : "", oldText: typeof input["oldString"] === "string" ? input["oldString"] : "", newText: typeof input["newString"] === "string" ? input["newString"] : typeof input["content"] === "string" ? input["content"] : "" })
+      }
+      if (part.tool === "todowrite") {
+        const parsedTodos = decodeTodos(part.state.output)
+        if (Result.isSuccess(parsedTodos)) {
+          await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "plan", entries: parsedTodos.success.map((todo) => ({ priority: "medium" as const, status: (todo.status === "cancelled" ? "completed" : todo.status) as any, content: todo.content })) } }).catch((err: any) => { log.error("failed to send session update for todo", { error: err }) })
+        } else { log.error("failed to parse todo output", { error: parsedTodos.failure }) }
+      }
+      await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "tool_call_update", toolCallId: part.callID, status: "completed", kind, content, title: part.state.title, rawInput: part.state.input, rawOutput: { output: part.state.output, metadata: part.state.metadata } } }).catch((err: any) => { log.error("failed to send tool completed to ACP", { error: err }) })
+      break
+    }
+    case "error": {
+      deps.toolStarts.delete(part.callID)
+      deps.bashSnapshots.delete(part.callID)
+      await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "tool_call_update", toolCallId: part.callID, status: "failed", kind: toToolKind(part.tool), title: part.tool, rawInput: part.state.input, content: [{ type: "content", content: { type: "text", text: part.state.error } }], rawOutput: { error: part.state.error, metadata: part.state.metadata } } }).catch((err: any) => { log.error("failed to send tool error to ACP", { error: err }) })
+      break
+    }
+  }
+}
+
+async function processTextPart(deps: AgentDeps, sessionId: string, message: SessionMessageResponse, part: any) {
+  if (!part.text) return
+  const audience: Role[] | undefined = part.synthetic ? ["assistant"] : part.ignored ? ["user"] : undefined
+  await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: message.info.role === "user" ? "user_message_chunk" : "agent_message_chunk", messageId: message.info.id, content: { type: "text", text: part.text, ...(audience && { annotations: { audience } }) } } }).catch((err: any) => { log.error("failed to send text to ACP", { error: err }) })
+}
+
+async function processFilePart(deps: AgentDeps, sessionId: string, message: SessionMessageResponse, part: any) {
+  const url = part.url
+  const filename = part.filename ?? "file"
+  const mime = part.mime || "application/octet-stream"
+  const messageChunk = message.info.role === "user" ? "user_message_chunk" : "agent_message_chunk"
+  if (url.startsWith("file://")) {
+    await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: messageChunk, messageId: message.info.id, content: { type: "resource_link", uri: url, name: filename, mimeType: mime } } }).catch((err: any) => { log.error("failed to send resource_link to ACP", { error: err }) })
+  } else if (url.startsWith("data:")) {
+    const parsed = parseDataUrl(url)
+    const dataMime = parsed?.mime
+    const base64Data = parsed?.base64 ?? ""
+    const effectiveMime = dataMime || mime
+    if (effectiveMime.startsWith("image/")) {
+      await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: messageChunk, messageId: message.info.id, content: { type: "image", mimeType: effectiveMime, data: base64Data, uri: pathToFileURL(filename).href } } }).catch((err: any) => { log.error("failed to send image to ACP", { error: err }) })
+    } else {
+      const isText = effectiveMime.startsWith("text/") || effectiveMime === "application/json"
+      const fileUri = pathToFileURL(filename).href
+      const resource = isText ? { uri: fileUri, mimeType: effectiveMime, text: Buffer.from(base64Data, "base64").toString("utf-8") } : { uri: fileUri, mimeType: effectiveMime, blob: base64Data }
+      await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: messageChunk, messageId: message.info.id, content: { type: "resource", resource } } }).catch((err: any) => { log.error("failed to send resource to ACP", { error: err }) })
+    }
+  }
+}
+
+async function processReasoningPart(deps: AgentDeps, sessionId: string, message: SessionMessageResponse, part: any) {
+  if (!part.text) return
+  await deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "agent_thought_chunk", messageId: message.info.id, content: { type: "text", text: part.text } } }).catch((err: any) => { log.error("failed to send reasoning to ACP", { error: err }) })
+}

package/src/acp/agent-prompt.ts

@@ -0,0 +1,149 @@
+import { RequestError, type CancelNotification, type SetSessionModelRequest, type SetSessionModeRequest, type SetSessionModeResponse, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse, type PromptRequest } from "@agentclientprotocol/sdk"
+import { ProviderID, ModelID } from "../provider/schema"
+import { AppRuntime } from "@/effect/app-runtime"
+import { Agent as AgentModule } from "../agent/agent"
+import type { AgentDeps } from "./agent-types"
+import { log, defaultModel, sortProvidersByName, modelVariantsFromProviders, buildAvailableModels, formatModelIdWithVariant, buildVariantMeta, buildConfigOptions, sendUsageUpdate, buildUsage, parseUri, parseModelSelection } from "./agent-utils"
+
+export async function prompt(deps: AgentDeps, params: PromptRequest) {
+  const sessionID = params.sessionId
+  const session = deps.sessionManager.get(sessionID)
+  const directory = session.cwd
+  const current = session.model
+  const model = current ?? (await defaultModel(deps.config, directory))
+  if (!current) deps.sessionManager.setModel(session.id, model)
+  const agent = session.modeId ?? (await AppRuntime.runPromise(AgentModule.Service.use((svc: any) => svc.defaultAgent())))
+
+  const parts: Array<{ type: "text"; text: string; synthetic?: boolean; ignored?: boolean } | { type: "file"; url: string; filename: string; mime: string }> = []
+  for (const part of params.prompt) {
+    switch (part.type) {
+      case "text": {
+        const audience = part.annotations?.audience
+        const forAssistant = audience?.length === 1 && audience[0] === "assistant"
+        const forUser = audience?.length === 1 && audience[0] === "user"
+        parts.push({ type: "text" as const, text: part.text, ...(forAssistant && { synthetic: true }), ...(forUser && { ignored: true }) })
+        break
+      }
+      case "image": {
+        const parsed = parseUri(part.uri ?? "")
+        const filename = parsed.type === "file" ? parsed.filename : "image"
+        if (part.data) parts.push({ type: "file", url: `data:${part.mimeType};base64,${part.data}`, filename, mime: part.mimeType })
+        else if (part.uri && part.uri.startsWith("http:")) parts.push({ type: "file", url: part.uri, filename, mime: part.mimeType })
+        break
+      }
+      case "resource_link": {
+        const parsed = parseUri(part.uri)
+        if (part.name && parsed.type === "file") parsed.filename = part.name
+        parts.push(parsed)
+        break
+      }
+      case "resource": {
+        const resource = part.resource
+        if ("text" in resource && resource.text) parts.push({ type: "text", text: resource.text })
+        else if ("blob" in resource && resource.blob && resource.mimeType) {
+          const parsed = parseUri(resource.uri ?? "")
+          const filename = parsed.type === "file" ? parsed.filename : "file"
+          parts.push({ type: "file", url: `data:${resource.mimeType};base64,${resource.blob}`, filename, mime: resource.mimeType })
+        }
+        break
+      }
+    }
+  }
+  log.info("parts", { parts })
+
+  const cmd = (() => {
+    const text = parts.filter((p): p is { type: "text"; text: string } => p.type === "text").map((p) => p.text).join("").trim()
+    if (!text.startsWith("/")) return
+    const [name, ...rest] = text.slice(1).split(/\s+/)
+    return { name, args: rest.join(" ").trim() }
+  })()
+
+  if (!cmd) {
+    const response = await deps.sdk.session.prompt({ sessionID, model: { providerID: model.providerID, modelID: model.modelID }, variant: deps.sessionManager.getVariant(sessionID), parts, agent, directory })
+    const msg = response.data?.info
+    await sendUsageUpdate(deps.connection, deps.sdk, sessionID, directory)
+    return { stopReason: "end_turn" as const, usage: msg ? buildUsage(msg) : undefined, _meta: {} }
+  }
+
+  const command = await deps.config.sdk.command.list({ directory }, { throwOnError: true }).then((x: any) => x.data!.find((c: any) => c.name === cmd.name))
+  if (command) {
+    const response = await deps.sdk.session.command({ sessionID, command: command.name, arguments: cmd.args, model: model.providerID + "/" + model.modelID, agent, directory })
+    const msg = response.data?.info
+    await sendUsageUpdate(deps.connection, deps.sdk, sessionID, directory)
+    return { stopReason: "end_turn" as const, usage: msg ? buildUsage(msg) : undefined, _meta: {} }
+  }
+
+  switch (cmd.name) {
+    case "compact":
+      await deps.config.sdk.session.summarize({ sessionID, directory, providerID: model.providerID, modelID: model.modelID }, { throwOnError: true })
+      break
+  }
+  await sendUsageUpdate(deps.connection, deps.sdk, sessionID, directory)
+  return { stopReason: "end_turn" as const, _meta: {} }
+}
+
+export async function cancel(deps: AgentDeps, params: CancelNotification) {
+  const session = deps.sessionManager.get(params.sessionId)
+  await deps.config.sdk.session.abort({ sessionID: params.sessionId, directory: session.cwd }, { throwOnError: true })
+}
+
+export async function setSessionModel(deps: AgentDeps, params: SetSessionModelRequest) {
+  const session = deps.sessionManager.get(params.sessionId)
+  const providers = await deps.sdk.config.providers({ directory: session.cwd }, { throwOnError: true }).then((x: any) => x.data!.providers)
+  const selection = parseModelSelection(params.modelId, providers)
+  deps.sessionManager.setModel(session.id, selection.model)
+  deps.sessionManager.setVariant(session.id, selection.variant)
+  const entries = sortProvidersByName(providers)
+  const availableVariants = modelVariantsFromProviders(entries as any, selection.model)
+  return { _meta: buildVariantMeta({ model: selection.model, variant: selection.variant, availableVariants }) }
+}
+
+export async function setSessionMode(deps: AgentDeps, params: SetSessionModeRequest): Promise<SetSessionModeResponse | void> {
+  const session = deps.sessionManager.get(params.sessionId)
+  const availableModes = await loadAvailableModes(deps, session.cwd)
+  if (!availableModes.some((mode: { id: string }) => mode.id === params.modeId)) throw new Error(`Agent not found: ${params.modeId}`)
+  deps.sessionManager.setMode(params.sessionId, params.modeId)
+}
+
+export async function setSessionConfigOption(deps: AgentDeps, params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse> {
+  const session = deps.sessionManager.get(params.sessionId)
+  const providers = await deps.sdk.config.providers({ directory: session.cwd }, { throwOnError: true }).then((x: any) => x.data!.providers)
+  const entries = sortProvidersByName(providers)
+  if (params.configId === "model") {
+    if (typeof params.value !== "string") throw RequestError.invalidParams("model value must be a string")
+    const selection = parseModelSelection(params.value, providers)
+    deps.sessionManager.setModel(session.id, selection.model)
+    deps.sessionManager.setVariant(session.id, selection.variant)
+  } else if (params.configId === "mode") {
+    if (typeof params.value !== "string") throw RequestError.invalidParams("mode value must be a string")
+    const availableModes = await loadAvailableModes(deps, session.cwd)
+    if (!availableModes.some((mode: { id: string }) => mode.id === params.value)) throw RequestError.invalidParams(JSON.stringify({ error: `Mode not found: ${params.value}` }))
+    deps.sessionManager.setMode(session.id, params.value)
+  } else {
+    throw RequestError.invalidParams(JSON.stringify({ error: `Unknown config option: ${params.configId}` }))
+  }
+  const updatedSession = deps.sessionManager.get(session.id)
+  const model = updatedSession.model ?? (await defaultModel(deps.config, session.cwd))
+  const availableVariants = modelVariantsFromProviders(entries as any, model)
+  const currentModelId = formatModelIdWithVariant(model, updatedSession.variant, availableVariants, true)
+  const availableModels = buildAvailableModels(entries as any, { includeVariants: true })
+  const modeState = await resolveModeState(deps, session.cwd, session.id)
+  const modes = modeState.currentModeId ? { availableModes: modeState.availableModes, currentModeId: modeState.currentModeId } : undefined
+  return { configOptions: buildConfigOptions({ currentModelId, availableModels, modes }) }
+}
+
+async function loadAvailableModes(deps: AgentDeps, directory: string) {
+  return deps.config.sdk.app.agents({ directory }, { throwOnError: true }).then((resp: any) => resp.data!.filter((agent: any) => agent.mode !== "subagent" && !agent.hidden).map((agent: any) => ({ id: agent.name, name: agent.name, description: agent.description })))
+}
+
+async function resolveModeState(deps: AgentDeps, directory: string, sessionId: string) {
+  const availableModes = await loadAvailableModes(deps, directory)
+  const currentModeId = deps.sessionManager.get(sessionId).modeId || await (async () => {
+    if (!availableModes.length) return undefined
+    const defaultAgentName = await AppRuntime.runPromise(AgentModule.Service.use((svc: any) => svc.defaultAgent()))
+    const resolvedModeId = availableModes.find((mode: any) => mode.name === defaultAgentName)?.id ?? availableModes[0].id
+    deps.sessionManager.setMode(sessionId, resolvedModeId)
+    return resolvedModeId
+  })()
+  return { availableModes, currentModeId }
+}

package/src/acp/agent-session.ts

@@ -0,0 +1,196 @@
+import {
+  RequestError,
+  type AgentSideConnection,
+  type AuthenticateRequest,
+  type InitializeRequest,
+  type InitializeResponse,
+  type ListSessionsRequest,
+  type ListSessionsResponse,
+  type LoadSessionRequest,
+  type NewSessionRequest,
+  type ForkSessionRequest,
+  type ForkSessionResponse,
+  type ResumeSessionRequest,
+  type ResumeSessionResponse,
+  type SessionInfo,
+} from "@agentclientprotocol/sdk"
+import { LoadAPIKeyError } from "ai"
+import type { SaeeolClient } from "@saeeol/sdk/v2"
+import { ProviderID, ModelID } from "../provider/schema"
+import { MessageV2 } from "@/session/message-v2"
+import { ConfigMCP } from "@/config/mcp"
+import { AppRuntime } from "@/effect/app-runtime"
+import { Agent as AgentModule } from "../agent/agent"
+import { InstallationVersion } from "@saeeol/core/installation/version"
+import type { ACPConfig } from "./types"
+import type { ACPSessionManager } from "./session"
+import type { AgentDeps, ModeOption } from "./agent-types"
+import { log, defaultModel, sendUsageUpdate, sortProvidersByName, modelVariantsFromProviders, buildAvailableModels, formatModelIdWithVariant, buildVariantMeta, buildConfigOptions } from "./agent-utils"
+import { processMessage } from "./agent-message"
+
+export async function initialize(params: InitializeRequest): Promise<InitializeResponse> {
+  log.info("initialize", { protocolVersion: params.protocolVersion })
+  const authMethod = { description: "Run `saeeol auth login` in the terminal", name: "Login with Saeeol", id: "saeeol-login" } as any
+  if (params.clientCapabilities?._meta?.["terminal-auth"] === true) {
+    authMethod._meta = { "terminal-auth": { command: "saeeol", args: ["auth", "login"], label: "Saeeol Login" } }
+  }
+  return {
+    protocolVersion: 1,
+    agentCapabilities: { loadSession: true, mcpCapabilities: { http: true, sse: true }, promptCapabilities: { embeddedContext: true, image: true }, sessionCapabilities: { fork: {}, list: {}, resume: {} } },
+    authMethods: [authMethod],
+    agentInfo: { name: "Saeeol", version: InstallationVersion },
+  }
+}
+
+export async function newSession(deps: AgentDeps, params: NewSessionRequest) {
+  const directory = params.cwd
+  try {
+    const model = await defaultModel(deps.config, directory)
+    const state = await deps.sessionManager.create(params.cwd, params.mcpServers, model)
+    const sessionId = state.id
+    log.info("creating_session", { sessionId, mcpServers: params.mcpServers.length })
+    const load = await loadSessionMode(deps, { cwd: directory, mcpServers: params.mcpServers, sessionId })
+    return { sessionId, configOptions: load.configOptions, models: load.models, modes: load.modes, _meta: load._meta }
+  } catch (e) {
+    const error = MessageV2.fromError(e, { providerID: ProviderID.make(deps.config.defaultModel?.providerID ?? "unknown") })
+    if (LoadAPIKeyError.isInstance(error)) throw RequestError.authRequired()
+    throw e
+  }
+}
+
+export async function loadSession(deps: AgentDeps, params: LoadSessionRequest) {
+  const directory = params.cwd
+  const sessionId = params.sessionId
+  try {
+    const model = await defaultModel(deps.config, directory)
+    await deps.sessionManager.load(sessionId, params.cwd, params.mcpServers, model)
+    log.info("load_session", { sessionId, mcpServers: params.mcpServers.length })
+    const result = await loadSessionMode(deps, { cwd: directory, mcpServers: params.mcpServers, sessionId })
+    const messages = await deps.sdk.session.messages({ sessionID: sessionId, directory }, { throwOnError: true }).then((x: any) => x.data).catch((err: any) => { log.error("unexpected error when fetching message", { error: err }); return undefined })
+    const lastUser = messages?.findLast((m: any) => m.info.role === "user")?.info
+    if (lastUser?.role === "user") {
+      result.models.currentModelId = `${lastUser.model.providerID}/${lastUser.model.modelID}`
+      deps.sessionManager.setModel(sessionId, { providerID: ProviderID.make(lastUser.model.providerID), modelID: ModelID.make(lastUser.model.modelID) })
+      if (result.modes?.availableModes.some((m: any) => m.id === lastUser.agent)) { result.modes.currentModeId = lastUser.agent; deps.sessionManager.setMode(sessionId, lastUser.agent) }
+      result.configOptions = buildConfigOptions({ currentModelId: result.models.currentModelId, availableModels: result.models.availableModels, modes: result.modes })
+    }
+    for (const msg of messages ?? []) { log.debug("replay message", msg); await processMessage(deps, msg) }
+    await sendUsageUpdate(deps.connection, deps.sdk, sessionId, directory)
+    return result
+  } catch (e) {
+    const error = MessageV2.fromError(e, { providerID: ProviderID.make(deps.config.defaultModel?.providerID ?? "unknown") })
+    if (LoadAPIKeyError.isInstance(error)) throw RequestError.authRequired()
+    throw e
+  }
+}
+
+export async function listSessions(deps: AgentDeps, params: ListSessionsRequest): Promise<ListSessionsResponse> {
+  try {
+    const cursor = params.cursor ? Number(params.cursor) : undefined
+    const limit = 100
+    const sessions = await deps.sdk.session.list({ directory: params.cwd ?? undefined, roots: true }, { throwOnError: true }).then((x: any) => x.data ?? [])
+    const sorted = sessions.toSorted((a: any, b: any) => b.time.updated - a.time.updated)
+    const filtered = cursor ? sorted.filter((s: any) => s.time.updated < cursor) : sorted
+    const page = filtered.slice(0, limit)
+    const entries: SessionInfo[] = page.map((session: any) => ({ sessionId: session.id, cwd: session.directory, title: session.title, updatedAt: new Date(session.time.updated).toISOString() }))
+    const last = page[page.length - 1]
+    const next = filtered.length > limit && last ? String(last.time.updated) : undefined
+    const response: ListSessionsResponse = { sessions: entries }
+    if (next) response.nextCursor = next
+    return response
+  } catch (e) {
+    const error = MessageV2.fromError(e, { providerID: ProviderID.make(deps.config.defaultModel?.providerID ?? "unknown") })
+    if (LoadAPIKeyError.isInstance(error)) throw RequestError.authRequired()
+    throw e
+  }
+}
+
+export async function forkSession(deps: AgentDeps, params: ForkSessionRequest): Promise<ForkSessionResponse> {
+  const directory = params.cwd
+  const mcpServers = params.mcpServers ?? []
+  try {
+    const model = await defaultModel(deps.config, directory)
+    const forked = await deps.sdk.session.fork({ sessionID: params.sessionId, directory }, { throwOnError: true }).then((x: any) => x.data)
+    if (!forked) throw new Error("Fork session returned no data")
+    const sessionId = forked.id
+    await deps.sessionManager.load(sessionId, directory, mcpServers, model)
+    log.info("fork_session", { sessionId, mcpServers: mcpServers.length })
+    const mode = await loadSessionMode(deps, { cwd: directory, mcpServers, sessionId })
+    const messages = await deps.sdk.session.messages({ sessionID: sessionId, directory }, { throwOnError: true }).then((x: any) => x.data).catch((err: any) => { log.error("unexpected error when fetching message", { error: err }); return undefined })
+    for (const msg of messages ?? []) { log.debug("replay message", msg); await processMessage(deps, msg) }
+    await sendUsageUpdate(deps.connection, deps.sdk, sessionId, directory)
+    return mode
+  } catch (e) {
+    const error = MessageV2.fromError(e, { providerID: ProviderID.make(deps.config.defaultModel?.providerID ?? "unknown") })
+    if (LoadAPIKeyError.isInstance(error)) throw RequestError.authRequired()
+    throw e
+  }
+}
+
+export async function resumeSession(deps: AgentDeps, params: ResumeSessionRequest): Promise<ResumeSessionResponse> {
+  const directory = params.cwd
+  const sessionId = params.sessionId
+  const mcpServers = params.mcpServers ?? []
+  try {
+    const model = await defaultModel(deps.config, directory)
+    await deps.sessionManager.load(sessionId, directory, mcpServers, model)
+    log.info("resume_session", { sessionId, mcpServers: mcpServers.length })
+    const result = await loadSessionMode(deps, { cwd: directory, mcpServers, sessionId })
+    await sendUsageUpdate(deps.connection, deps.sdk, sessionId, directory)
+    return result
+  } catch (e) {
+    const error = MessageV2.fromError(e, { providerID: ProviderID.make(deps.config.defaultModel?.providerID ?? "unknown") })
+    if (LoadAPIKeyError.isInstance(error)) throw RequestError.authRequired()
+    throw e
+  }
+}
+
+async function loadAvailableModes(deps: AgentDeps, directory: string): Promise<ModeOption[]> {
+  const agents = await deps.config.sdk.app.agents({ directory }, { throwOnError: true }).then((resp: any) => resp.data!)
+  return agents.filter((agent: any) => agent.mode !== "subagent" && !agent.hidden).map((agent: any) => ({ id: agent.name, name: agent.name, description: agent.description }))
+}
+
+async function resolveModeState(deps: AgentDeps, directory: string, sessionId: string) {
+  const availableModes = await loadAvailableModes(deps, directory)
+  const currentModeId = deps.sessionManager.get(sessionId).modeId || await (async () => {
+    if (!availableModes.length) return undefined
+    const defaultAgentName = await AppRuntime.runPromise(AgentModule.Service.use((svc: any) => svc.defaultAgent()))
+    const resolvedModeId = availableModes.find((mode) => mode.name === defaultAgentName)?.id ?? availableModes[0].id
+    deps.sessionManager.setMode(sessionId, resolvedModeId)
+    return resolvedModeId
+  })()
+  return { availableModes, currentModeId }
+}
+
+async function loadSessionMode(deps: AgentDeps, params: LoadSessionRequest) {
+  const directory = params.cwd
+  const model = await defaultModel(deps.config, directory)
+  const sessionId = params.sessionId
+  const providers = await deps.sdk.config.providers({ directory }).then((x: any) => x.data!.providers)
+  const entries = sortProvidersByName(providers)
+  const availableVariants = modelVariantsFromProviders(entries as any, model)
+  const variant = deps.sessionManager.getVariant(sessionId)
+  const currentModelId = formatModelIdWithVariant(model, variant, availableVariants, true)
+    const availableModels = buildAvailableModels(entries as any, { includeVariants: true })
+  const modeState = await resolveModeState(deps, directory, sessionId)
+  const currentModeId = modeState.currentModeId
+  const modes = currentModeId ? { availableModes: modeState.availableModes, currentModeId } : undefined
+  const commands = await deps.config.sdk.command.list({ directory }, { throwOnError: true }).then((resp: any) => resp.data!)
+  const availableCommands = commands.map((command: any) => ({ name: command.name, description: command.description ?? "" }))
+  const names = new Set(availableCommands.map((c: any) => c.name))
+  if (!names.has("compact")) availableCommands.push({ name: "compact", description: "compact the session" })
+  const mcpServers: Record<string, ConfigMCP.Info> = {}
+  for (const server of params.mcpServers) {
+    if ("type" in server) { mcpServers[server.name] = { url: server.url, headers: server.headers.reduce<Record<string, string>>((acc: any, { name, value }: any) => { acc[name] = value; return acc }, {}), type: "remote" } }
+    else { mcpServers[server.name] = { type: "local", command: [server.command, ...server.args], environment: server.env.reduce<Record<string, string>>((acc: any, { name, value }: any) => { acc[name] = value; return acc }, {}) } }
+  }
+  await Promise.all(Object.entries(mcpServers).map(async ([key, mcp]) => { await deps.sdk.mcp.add({ directory, name: key, config: mcp }, { throwOnError: true }).catch((error: any) => { log.error("failed to add mcp server", { name: key, error }) }) }))
+  setTimeout(() => { void deps.connection.sessionUpdate({ sessionId, update: { sessionUpdate: "available_commands_update", availableCommands } }) }, 0)
+  return {
+    sessionId,
+    models: { currentModelId: formatModelIdWithVariant(model, variant, availableVariants, true), availableModels },
+    modes,
+    configOptions: buildConfigOptions({ currentModelId: formatModelIdWithVariant(model, variant, availableVariants, true), availableModels, modes }),
+    _meta: buildVariantMeta({ model, variant, availableVariants }),
+  }
+}

package/src/acp/agent-types.ts

@@ -0,0 +1,16 @@
+import type { SessionConfigOption } from "@agentclientprotocol/sdk"
+
+export type { SessionConfigOption }
+export type ModeOption = { id: string; name: string; description?: string }
+export type ModelOption = { modelId: string; name: string }
+
+export type AgentDeps = {
+  connection: any
+  config: any
+  sdk: any
+  sessionManager: import("./session").ACPSessionManager
+  permissionOptions: import("@agentclientprotocol/sdk").PermissionOption[]
+  bashSnapshots: Map<string, string>
+  toolStarts: Set<string>
+  permissionQueues: Map<string, Promise<void>>
+}