saeeol 1.4.2 → 1.4.4

package/src/acp/agent-message.ts

@@ -1,97 +0,0 @@
-import { parse as parseDataUrl } from "@/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

@@ -1,149 +0,0 @@
-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

@@ -1,196 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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>>
-}