acp-extension-claude 0.13.1

package/dist/acp-agent.js

@@ -0,0 +1,944 @@
+import { AgentSideConnection, ndJsonStream, RequestError, } from "@agentclientprotocol/sdk";
+import { SettingsManager } from "./settings.js";
+import { query, } from "@anthropic-ai/claude-agent-sdk";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./utils.js";
+import { createMcpServer } from "./mcp-server.js";
+import { EDIT_TOOL_NAMES, acpToolNames } from "./tools.js";
+import { toolInfoFromToolUse, planEntries, toolUpdateFromToolResult, registerHookCallback, createPostToolUseHook, createPreToolUseHook, } from "./tools.js";
+import packageJson from '../package.json' with { type: 'json' };
+import { randomUUID } from "node:crypto";
+import { EXT_METHOD_NAME } from 'acp-extension-core';
+export const CLAUDE_CONFIG_DIR = process.env.CLAUDE ?? path.join(os.homedir(), ".claude");
+// Bypass Permissions doesn't work if we are a root/sudo user
+const IS_ROOT = (process.geteuid?.() ?? process.getuid?.()) === 0;
+// Implement the ACP Agent interface
+export class ClaudeAcpAgent {
+    constructor(client, logger) {
+        this.backgroundTerminals = {};
+        this.sessions = {};
+        this.client = client;
+        this.toolUseCache = {};
+        this.logger = logger ?? console;
+    }
+    async initialize(request) {
+        this.clientCapabilities = request.clientCapabilities;
+        // Default authMethod
+        const authMethod = {
+            description: "Run `claude /login` in the terminal",
+            name: "Log in with Claude Code",
+            id: "claude-login",
+        };
+        // If client supports terminal-auth capability, use that instead.
+        // if (request.clientCapabilities?._meta?.["terminal-auth"] === true) {
+        //   const cliPath = fileURLToPath(import.meta.resolve("@anthropic-ai/claude-agent-sdk/cli.js"));
+        //   authMethod._meta = {
+        //     "terminal-auth": {
+        //       command: "node",
+        //       args: [cliPath, "/login"],
+        //       label: "Claude Code Login",
+        //     },
+        //   };
+        // }
+        return {
+            protocolVersion: 1,
+            agentCapabilities: {
+                promptCapabilities: {
+                    image: true,
+                    embeddedContext: true,
+                },
+                mcpCapabilities: {
+                    http: true,
+                    sse: true,
+                },
+                sessionCapabilities: {
+                    fork: {},
+                    resume: {},
+                },
+            },
+            agentInfo: {
+                name: packageJson.name,
+                title: "Claude Code",
+                version: packageJson.version,
+            },
+            authMethods: [authMethod],
+        };
+    }
+    async newSession(params) {
+        if (fs.existsSync(path.resolve(os.homedir(), ".claude.json.backup")) &&
+            !fs.existsSync(path.resolve(os.homedir(), ".claude.json"))) {
+            throw RequestError.authRequired();
+        }
+        return await this.createSession(params, {
+            // Revisit these meta values once we support resume
+            resume: params._meta?.claudeCode?.options?.resume,
+        });
+    }
+    async unstable_forkSession(params) {
+        return await this.createSession({
+            cwd: params.cwd,
+            mcpServers: params.mcpServers ?? [],
+            _meta: params._meta,
+        }, {
+            resume: params.sessionId,
+            forkSession: true,
+        });
+    }
+    async unstable_resumeSession(params) {
+        const response = await this.createSession({
+            cwd: params.cwd,
+            mcpServers: params.mcpServers ?? [],
+            _meta: params._meta,
+        }, {
+            resume: params.sessionId,
+        });
+        return response;
+    }
+    async authenticate(_params) {
+        throw new Error("Method not implemented.");
+    }
+    async prompt(params) {
+        if (!this.sessions[params.sessionId]) {
+            throw new Error("Session not found");
+        }
+        this.sessions[params.sessionId].cancelled = false;
+        const { query, input } = this.sessions[params.sessionId];
+        input.push(promptToClaude(params));
+        while (true) {
+            const { value: message, done } = await query.next();
+            if (done || !message) {
+                if (this.sessions[params.sessionId].cancelled) {
+                    return { stopReason: "cancelled" };
+                }
+                break;
+            }
+            switch (message.type) {
+                case "system":
+                    switch (message.subtype) {
+                        case "init":
+                            break;
+                        case "compact_boundary":
+                        case "hook_response":
+                        case "status":
+                            // Todo: process via status api: https://docs.claude.com/en/docs/claude-code/hooks#hook-output
+                            break;
+                        default:
+                            unreachable(message, this.logger);
+                            break;
+                    }
+                    break;
+                case "result": {
+                    if (this.sessions[params.sessionId].cancelled) {
+                        return { stopReason: "cancelled" };
+                    }
+                    switch (message.subtype) {
+                        case "success": {
+                            if (message.result.includes("Please run /login")) {
+                                throw RequestError.authRequired();
+                            }
+                            if (message.is_error) {
+                                throw RequestError.internalError(undefined, message.result);
+                            }
+                            const modelUsage = {};
+                            for (const [model, usage] of Object.entries(message.modelUsage)) {
+                                // TODO: mapping model name
+                                modelUsage[model] = {
+                                    inputTokens: usage.inputTokens,
+                                    outputTokens: usage.outputTokens,
+                                    cacheReadInputTokens: usage.cacheReadInputTokens,
+                                    cacheCreationInputTokens: usage.cacheCreationInputTokens,
+                                    webSearchRequests: usage.webSearchRequests,
+                                    costUSD: usage.costUSD
+                                };
+                            }
+                            const usages = {
+                                usage: {
+                                    inputTokens: message.usage.input_tokens,
+                                    outputTokens: message.usage.output_tokens,
+                                    cacheCreationInputTokens: message.usage.cache_creation_input_tokens,
+                                    cacheReadInputTokens: message.usage.cache_read_input_tokens,
+                                },
+                                modelUsage,
+                            };
+                            await this.client.extMethod(EXT_METHOD_NAME.usage_update, usages);
+                            return { stopReason: "end_turn" };
+                        }
+                        case "error_during_execution":
+                            if (message.is_error) {
+                                throw RequestError.internalError(undefined, message.errors.join(", ") || message.subtype);
+                            }
+                            return { stopReason: "end_turn" };
+                        case "error_max_budget_usd":
+                        case "error_max_turns":
+                        case "error_max_structured_output_retries":
+                            if (message.is_error) {
+                                throw RequestError.internalError(undefined, message.errors.join(", ") || message.subtype);
+                            }
+                            return { stopReason: "max_turn_requests" };
+                        default:
+                            unreachable(message, this.logger);
+                            break;
+                    }
+                    break;
+                }
+                case "stream_event": {
+                    for (const notification of streamEventToAcpNotifications(message, params.sessionId, this.toolUseCache, this.client, this.logger)) {
+                        await this.client.sessionUpdate(notification);
+                    }
+                    break;
+                }
+                case "user":
+                case "assistant": {
+                    if (this.sessions[params.sessionId].cancelled) {
+                        break;
+                    }
+                    // Slash commands like /compact can generate invalid output... doesn't match
+                    // their own docs: https://docs.anthropic.com/en/docs/claude-code/sdk/sdk-slash-commands#%2Fcompact-compact-conversation-history
+                    if (typeof message.message.content === "string" &&
+                        message.message.content.includes("<local-command-stdout>")) {
+                        this.logger.log(message.message.content);
+                        break;
+                    }
+                    if (typeof message.message.content === "string" &&
+                        message.message.content.includes("<local-command-stderr>")) {
+                        this.logger.error(message.message.content);
+                        break;
+                    }
+                    // Skip these user messages for now, since they seem to just be messages we don't want in the feed
+                    if (message.type === "user" &&
+                        (typeof message.message.content === "string" ||
+                            (Array.isArray(message.message.content) &&
+                                message.message.content.length === 1 &&
+                                message.message.content[0].type === "text"))) {
+                        break;
+                    }
+                    if (message.type === "assistant" &&
+                        message.message.model === "<synthetic>" &&
+                        Array.isArray(message.message.content) &&
+                        message.message.content.length === 1 &&
+                        message.message.content[0].type === "text" &&
+                        message.message.content[0].text.includes("Please run /login")) {
+                        throw RequestError.authRequired();
+                    }
+                    const content = message.type === "assistant"
+                        ? // Handled by stream events above
+                            message.message.content.filter((item) => !["text", "thinking"].includes(item.type))
+                        : message.message.content;
+                    for (const notification of toAcpNotifications(content, message.message.role, params.sessionId, this.toolUseCache, this.client, this.logger)) {
+                        await this.client.sessionUpdate(notification);
+                    }
+                    break;
+                }
+                case "tool_progress":
+                    break;
+                case "auth_status":
+                    break;
+                default:
+                    unreachable(message);
+                    break;
+            }
+        }
+        throw new Error("Session did not end in result");
+    }
+    async cancel(params) {
+        if (!this.sessions[params.sessionId]) {
+            throw new Error("Session not found");
+        }
+        this.sessions[params.sessionId].cancelled = true;
+        await this.sessions[params.sessionId].query.interrupt();
+    }
+    async unstable_setSessionModel(params) {
+        if (!this.sessions[params.sessionId]) {
+            throw new Error("Session not found");
+        }
+        await this.sessions[params.sessionId].query.setModel(params.modelId);
+    }
+    async setSessionMode(params) {
+        if (!this.sessions[params.sessionId]) {
+            throw new Error("Session not found");
+        }
+        switch (params.modeId) {
+            case "default":
+            case "acceptEdits":
+            case "bypassPermissions":
+            case "dontAsk":
+            case "plan":
+                this.sessions[params.sessionId].permissionMode = params.modeId;
+                try {
+                    await this.sessions[params.sessionId].query.setPermissionMode(params.modeId);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error && error.message ? error.message : "Invalid Mode";
+                    throw new Error(errorMessage);
+                }
+                return {};
+            default:
+                throw new Error("Invalid Mode");
+        }
+    }
+    async readTextFile(params) {
+        const response = await this.client.readTextFile(params);
+        return response;
+    }
+    async writeTextFile(params) {
+        const response = await this.client.writeTextFile(params);
+        return response;
+    }
+    canUseTool(sessionId) {
+        return async (toolName, toolInput, { signal, suggestions, toolUseID }) => {
+            const session = this.sessions[sessionId];
+            if (!session) {
+                return {
+                    behavior: "deny",
+                    message: "Session not found",
+                    interrupt: true,
+                };
+            }
+            if (toolName === "ExitPlanMode") {
+                const response = await this.client.requestPermission({
+                    options: [
+                        {
+                            kind: "allow_always",
+                            name: "Yes, and auto-accept edits",
+                            optionId: "acceptEdits",
+                        },
+                        { kind: "allow_once", name: "Yes, and manually approve edits", optionId: "default" },
+                        { kind: "reject_once", name: "No, keep planning", optionId: "plan" },
+                    ],
+                    sessionId,
+                    toolCall: {
+                        toolCallId: toolUseID,
+                        rawInput: toolInput,
+                        title: toolInfoFromToolUse({ name: toolName, input: toolInput }).title,
+                    },
+                });
+                if (signal.aborted || response.outcome?.outcome === "cancelled") {
+                    throw new Error("Tool use aborted");
+                }
+                if (response.outcome?.outcome === "selected" &&
+                    (response.outcome.optionId === "default" || response.outcome.optionId === "acceptEdits")) {
+                    session.permissionMode = response.outcome.optionId;
+                    await this.client.sessionUpdate({
+                        sessionId,
+                        update: {
+                            sessionUpdate: "current_mode_update",
+                            currentModeId: response.outcome.optionId,
+                        },
+                    });
+                    return {
+                        behavior: "allow",
+                        updatedInput: toolInput,
+                        updatedPermissions: suggestions ?? [
+                            { type: "setMode", mode: response.outcome.optionId, destination: "session" },
+                        ],
+                    };
+                }
+                else {
+                    return {
+                        behavior: "deny",
+                        message: "User rejected request to exit plan mode.",
+                        interrupt: true,
+                    };
+                }
+            }
+            if (session.permissionMode === "bypassPermissions" ||
+                (session.permissionMode === "acceptEdits" && EDIT_TOOL_NAMES.includes(toolName))) {
+                return {
+                    behavior: "allow",
+                    updatedInput: toolInput,
+                    updatedPermissions: suggestions ?? [
+                        { type: "addRules", rules: [{ toolName }], behavior: "allow", destination: "session" },
+                    ],
+                };
+            }
+            const response = await this.client.requestPermission({
+                options: [
+                    {
+                        kind: "allow_always",
+                        name: "Always Allow",
+                        optionId: "allow_always",
+                    },
+                    { kind: "allow_once", name: "Allow", optionId: "allow" },
+                    { kind: "reject_once", name: "Reject", optionId: "reject" },
+                ],
+                sessionId,
+                toolCall: {
+                    toolCallId: toolUseID,
+                    rawInput: toolInput,
+                    title: toolInfoFromToolUse({ name: toolName, input: toolInput }).title,
+                },
+            });
+            if (signal.aborted || response.outcome?.outcome === "cancelled") {
+                throw new Error("Tool use aborted");
+            }
+            if (response.outcome?.outcome === "selected" &&
+                (response.outcome.optionId === "allow" || response.outcome.optionId === "allow_always")) {
+                // If Claude Code has suggestions, it will update their settings already
+                if (response.outcome.optionId === "allow_always") {
+                    return {
+                        behavior: "allow",
+                        updatedInput: toolInput,
+                        updatedPermissions: suggestions ?? [
+                            {
+                                type: "addRules",
+                                rules: [{ toolName }],
+                                behavior: "allow",
+                                destination: "session",
+                            },
+                        ],
+                    };
+                }
+                return {
+                    behavior: "allow",
+                    updatedInput: toolInput,
+                };
+            }
+            else {
+                return {
+                    behavior: "deny",
+                    message: "User refused permission to run tool",
+                    interrupt: true,
+                };
+            }
+        };
+    }
+    async createSession(params, creationOpts = {}) {
+        // We want to create a new session id unless it is resume,
+        // but not resume + forkSession.
+        let sessionId;
+        if (creationOpts.forkSession) {
+            sessionId = randomUUID();
+        }
+        else if (creationOpts.resume) {
+            sessionId = creationOpts.resume;
+        }
+        else {
+            sessionId = randomUUID();
+        }
+        const input = new Pushable();
+        const settingsManager = new SettingsManager(params.cwd, {
+            logger: this.logger,
+        });
+        await settingsManager.initialize();
+        const mcpServers = {};
+        if (Array.isArray(params.mcpServers)) {
+            for (const server of params.mcpServers) {
+                if ("type" in server) {
+                    mcpServers[server.name] = {
+                        type: server.type,
+                        url: server.url,
+                        headers: server.headers
+                            ? Object.fromEntries(server.headers.map((e) => [e.name, e.value]))
+                            : undefined,
+                    };
+                }
+                else {
+                    mcpServers[server.name] = {
+                        type: "stdio",
+                        command: server.command,
+                        args: server.args,
+                        env: server.env
+                            ? Object.fromEntries(server.env.map((e) => [e.name, e.value]))
+                            : undefined,
+                    };
+                }
+            }
+        }
+        // Only add the acp MCP server if built-in tools are not disabled
+        if (!params._meta?.disableBuiltInTools) {
+            const server = createMcpServer(this, sessionId, this.clientCapabilities);
+            mcpServers["acp"] = {
+                type: "sdk",
+                name: "acp",
+                instance: server,
+            };
+        }
+        let systemPrompt = { type: "preset", preset: "claude_code" };
+        if (params._meta?.systemPrompt) {
+            const customPrompt = params._meta.systemPrompt;
+            if (typeof customPrompt === "string") {
+                systemPrompt = customPrompt;
+            }
+            else if (typeof customPrompt === "object" &&
+                "append" in customPrompt &&
+                typeof customPrompt.append === "string") {
+                systemPrompt.append = customPrompt.append;
+            }
+        }
+        const permissionMode = "default";
+        // Extract options from _meta if provided
+        const userProvidedOptions = params._meta?.claudeCode?.options;
+        const extraArgs = { ...userProvidedOptions?.extraArgs };
+        if (creationOpts?.resume === undefined || creationOpts?.forkSession) {
+            // Set our own session id if not resuming an existing session.
+            extraArgs["session-id"] = sessionId;
+        }
+        // Configure thinking tokens from environment variable
+        const maxThinkingTokens = process.env.MAX_THINKING_TOKENS
+            ? parseInt(process.env.MAX_THINKING_TOKENS, 10)
+            : undefined;
+        const options = {
+            systemPrompt,
+            settingSources: ["user", "project", "local"],
+            stderr: (err) => this.logger.error(err),
+            ...(maxThinkingTokens !== undefined && { maxThinkingTokens }),
+            ...userProvidedOptions,
+            // Override certain fields that must be controlled by ACP
+            cwd: params.cwd,
+            includePartialMessages: true,
+            mcpServers: { ...(userProvidedOptions?.mcpServers || {}), ...mcpServers },
+            extraArgs,
+            // If we want bypassPermissions to be an option, we have to allow it here.
+            // But it doesn't work in root mode, so we only activate it if it will work.
+            allowDangerouslySkipPermissions: !IS_ROOT,
+            permissionMode,
+            canUseTool: this.canUseTool(sessionId),
+            // note: although not documented by the types, passing an absolute path
+            // here works to find zed's managed node version.
+            executable: process.execPath,
+            ...(process.env.CLAUDE_CODE_EXECUTABLE && {
+                pathToClaudeCodeExecutable: process.env.CLAUDE_CODE_EXECUTABLE,
+            }),
+            tools: { type: "preset", preset: "claude_code" },
+            hooks: {
+                ...userProvidedOptions?.hooks,
+                PreToolUse: [
+                    ...(userProvidedOptions?.hooks?.PreToolUse || []),
+                    {
+                        hooks: [createPreToolUseHook(settingsManager, this.logger)],
+                    },
+                ],
+                PostToolUse: [
+                    ...(userProvidedOptions?.hooks?.PostToolUse || []),
+                    {
+                        hooks: [createPostToolUseHook(this.logger)],
+                    },
+                ],
+            },
+            ...creationOpts,
+        };
+        const allowedTools = [];
+        // Disable this for now, not a great way to expose this over ACP at the moment (in progress work so we can revisit)
+        const disallowedTools = ["AskUserQuestion"];
+        // Check if built-in tools should be disabled
+        const disableBuiltInTools = params._meta?.disableBuiltInTools === true;
+        if (!disableBuiltInTools) {
+            if (this.clientCapabilities?.fs?.readTextFile) {
+                allowedTools.push(acpToolNames.read);
+                disallowedTools.push("Read");
+            }
+            if (this.clientCapabilities?.fs?.writeTextFile) {
+                disallowedTools.push("Write", "Edit");
+            }
+            if (this.clientCapabilities?.terminal) {
+                allowedTools.push(acpToolNames.bashOutput, acpToolNames.killShell);
+                disallowedTools.push("Bash", "BashOutput", "KillShell");
+            }
+        }
+        else {
+            // When built-in tools are disabled, explicitly disallow all of them
+            disallowedTools.push(acpToolNames.read, acpToolNames.write, acpToolNames.edit, acpToolNames.bash, acpToolNames.bashOutput, acpToolNames.killShell, "Read", "Write", "Edit", "Bash", "BashOutput", "KillShell", "Glob", "Grep", "Task", "TodoWrite", "ExitPlanMode", "WebSearch", "WebFetch", "AskUserQuestion", "SlashCommand", "Skill", "NotebookEdit");
+        }
+        if (allowedTools.length > 0) {
+            options.allowedTools = allowedTools;
+        }
+        if (disallowedTools.length > 0) {
+            options.disallowedTools = disallowedTools;
+        }
+        // Handle abort controller from meta options
+        const abortController = userProvidedOptions?.abortController;
+        if (abortController?.signal.aborted) {
+            throw new Error("Cancelled");
+        }
+        const q = query({
+            prompt: input,
+            options,
+        });
+        this.sessions[sessionId] = {
+            query: q,
+            input: input,
+            cancelled: false,
+            permissionMode,
+            settingsManager,
+        };
+        const availableCommands = await getAvailableSlashCommands(q);
+        const models = await getAvailableModels(q);
+        // Needs to happen after we return the session
+        setTimeout(() => {
+            this.client.sessionUpdate({
+                sessionId,
+                update: {
+                    sessionUpdate: "available_commands_update",
+                    availableCommands,
+                },
+            });
+        }, 0);
+        const availableModes = [
+            {
+                id: "default",
+                name: "Default",
+                description: "Standard behavior, prompts for dangerous operations",
+            },
+            {
+                id: "acceptEdits",
+                name: "Accept Edits",
+                description: "Auto-accept file edit operations",
+            },
+            {
+                id: "plan",
+                name: "Plan Mode",
+                description: "Planning mode, no actual tool execution",
+            },
+            {
+                id: "dontAsk",
+                name: "Don't Ask",
+                description: "Don't prompt for permissions, deny if not pre-approved",
+            },
+        ];
+        // Only works in non-root mode
+        if (!IS_ROOT) {
+            availableModes.push({
+                id: "bypassPermissions",
+                name: "Bypass Permissions",
+                description: "Bypass all permission checks",
+            });
+        }
+        return {
+            sessionId,
+            models,
+            modes: {
+                currentModeId: permissionMode,
+                availableModes,
+            },
+        };
+    }
+}
+async function getAvailableModels(query) {
+    const models = await query.supportedModels();
+    // Query doesn't give us access to the currently selected model, so we just choose the first model in the list.
+    const currentModel = models[0];
+    await query.setModel(currentModel.value);
+    const availableModels = models.map((model) => ({
+        modelId: model.value,
+        name: model.displayName,
+        description: model.description,
+    }));
+    return {
+        availableModels,
+        currentModelId: currentModel.value,
+    };
+}
+async function getAvailableSlashCommands(query) {
+    const UNSUPPORTED_COMMANDS = [
+        "context",
+        "cost",
+        "login",
+        "logout",
+        "output-style:new",
+        "release-notes",
+        "todos",
+    ];
+    const commands = await query.supportedCommands();
+    return commands
+        .map((command) => {
+        const input = command.argumentHint
+            ? {
+                hint: Array.isArray(command.argumentHint)
+                    ? command.argumentHint.join(" ")
+                    : command.argumentHint,
+            }
+            : null;
+        let name = command.name;
+        if (command.name.endsWith(" (MCP)")) {
+            name = `mcp:${name.replace(" (MCP)", "")}`;
+        }
+        return {
+            name,
+            description: command.description || "",
+            input,
+        };
+    })
+        .filter((command) => !UNSUPPORTED_COMMANDS.includes(command.name));
+}
+function formatUriAsLink(uri) {
+    try {
+        if (uri.startsWith("file://")) {
+            const path = uri.slice(7); // Remove "file://"
+            const name = path.split("/").pop() || path;
+            return `[@${name}](${uri})`;
+        }
+        else if (uri.startsWith("zed://")) {
+            const parts = uri.split("/");
+            const name = parts[parts.length - 1] || uri;
+            return `[@${name}](${uri})`;
+        }
+        return uri;
+    }
+    catch {
+        return uri;
+    }
+}
+export function promptToClaude(prompt) {
+    const content = [];
+    const context = [];
+    for (const chunk of prompt.prompt) {
+        switch (chunk.type) {
+            case "text": {
+                let text = chunk.text;
+                // change /mcp:server:command args -> /server:command (MCP) args
+                const mcpMatch = text.match(/^\/mcp:([^:\s]+):(\S+)(\s+.*)?$/);
+                if (mcpMatch) {
+                    const [, server, command, args] = mcpMatch;
+                    text = `/${server}:${command} (MCP)${args || ""}`;
+                }
+                content.push({ type: "text", text });
+                break;
+            }
+            case "resource_link": {
+                const formattedUri = formatUriAsLink(chunk.uri);
+                content.push({
+                    type: "text",
+                    text: formattedUri,
+                });
+                break;
+            }
+            case "resource": {
+                if ("text" in chunk.resource) {
+                    const formattedUri = formatUriAsLink(chunk.resource.uri);
+                    content.push({
+                        type: "text",
+                        text: formattedUri,
+                    });
+                    context.push({
+                        type: "text",
+                        text: `\n<context ref="${chunk.resource.uri}">\n${chunk.resource.text}\n</context>`,
+                    });
+                }
+                // Ignore blob resources (unsupported)
+                break;
+            }
+            case "image":
+                if (chunk.data) {
+                    content.push({
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            data: chunk.data,
+                            media_type: chunk.mimeType,
+                        },
+                    });
+                }
+                else if (chunk.uri && chunk.uri.startsWith("http")) {
+                    content.push({
+                        type: "image",
+                        source: {
+                            type: "url",
+                            url: chunk.uri,
+                        },
+                    });
+                }
+                break;
+            // Ignore audio and other unsupported types
+            default:
+                break;
+        }
+    }
+    content.push(...context);
+    return {
+        type: "user",
+        message: {
+            role: "user",
+            content: content,
+        },
+        session_id: prompt.sessionId,
+        parent_tool_use_id: null,
+    };
+}
+/**
+ * Convert an SDKAssistantMessage (Claude) to a SessionNotification (ACP).
+ * Only handles text, image, and thinking chunks for now.
+ */
+export function toAcpNotifications(content, role, sessionId, toolUseCache, client, logger) {
+    if (typeof content === "string") {
+        return [
+            {
+                sessionId,
+                update: {
+                    sessionUpdate: role === "assistant" ? "agent_message_chunk" : "user_message_chunk",
+                    content: {
+                        type: "text",
+                        text: content,
+                    },
+                },
+            },
+        ];
+    }
+    const output = [];
+    // Only handle the first chunk for streaming; extend as needed for batching
+    for (const chunk of content) {
+        let update = null;
+        switch (chunk.type) {
+            case "text":
+            case "text_delta":
+                update = {
+                    sessionUpdate: role === "assistant" ? "agent_message_chunk" : "user_message_chunk",
+                    content: {
+                        type: "text",
+                        text: chunk.text,
+                    },
+                };
+                break;
+            case "image":
+                update = {
+                    sessionUpdate: role === "assistant" ? "agent_message_chunk" : "user_message_chunk",
+                    content: {
+                        type: "image",
+                        data: chunk.source.type === "base64" ? chunk.source.data : "",
+                        mimeType: chunk.source.type === "base64" ? chunk.source.media_type : "",
+                        uri: chunk.source.type === "url" ? chunk.source.url : undefined,
+                    },
+                };
+                break;
+            case "thinking":
+            case "thinking_delta":
+                update = {
+                    sessionUpdate: "agent_thought_chunk",
+                    content: {
+                        type: "text",
+                        text: chunk.thinking,
+                    },
+                };
+                break;
+            case "tool_use":
+            case "server_tool_use":
+            case "mcp_tool_use": {
+                toolUseCache[chunk.id] = chunk;
+                if (chunk.name === "TodoWrite") {
+                    // @ts-expect-error - sometimes input is empty object
+                    if (Array.isArray(chunk.input.todos)) {
+                        update = {
+                            sessionUpdate: "plan",
+                            entries: planEntries(chunk.input),
+                        };
+                    }
+                }
+                else {
+                    // Register hook callback to receive the structured output from the hook
+                    registerHookCallback(chunk.id, {
+                        onPostToolUseHook: async (toolUseId, toolInput, toolResponse) => {
+                            const toolUse = toolUseCache[toolUseId];
+                            if (toolUse) {
+                                const update = {
+                                    _meta: {
+                                        claudeCode: {
+                                            toolResponse,
+                                            toolName: toolUse.name,
+                                        },
+                                    },
+                                    toolCallId: toolUseId,
+                                    sessionUpdate: "tool_call_update",
+                                };
+                                await client.sessionUpdate({
+                                    sessionId,
+                                    update,
+                                });
+                            }
+                            else {
+                                logger.error(`[claude-code-acp] Got a tool response for tool use that wasn't tracked: ${toolUseId}`);
+                            }
+                        },
+                    });
+                    let rawInput;
+                    try {
+                        rawInput = JSON.parse(JSON.stringify(chunk.input));
+                    }
+                    catch {
+                        // ignore if we can't turn it to JSON
+                    }
+                    update = {
+                        _meta: {
+                            claudeCode: {
+                                toolName: chunk.name,
+                            },
+                        },
+                        toolCallId: chunk.id,
+                        sessionUpdate: "tool_call",
+                        rawInput,
+                        status: "pending",
+                        ...toolInfoFromToolUse(chunk),
+                    };
+                }
+                break;
+            }
+            case "tool_result":
+            case "tool_search_tool_result":
+            case "web_fetch_tool_result":
+            case "web_search_tool_result":
+            case "code_execution_tool_result":
+            case "bash_code_execution_tool_result":
+            case "text_editor_code_execution_tool_result":
+            case "mcp_tool_result": {
+                const toolUse = toolUseCache[chunk.tool_use_id];
+                if (!toolUse) {
+                    logger.error(`[claude-code-acp] Got a tool result for tool use that wasn't tracked: ${chunk.tool_use_id}`);
+                    break;
+                }
+                if (toolUse.name !== "TodoWrite") {
+                    update = {
+                        _meta: {
+                            claudeCode: {
+                                toolName: toolUse.name,
+                            },
+                        },
+                        toolCallId: chunk.tool_use_id,
+                        sessionUpdate: "tool_call_update",
+                        status: "is_error" in chunk && chunk.is_error ? "failed" : "completed",
+                        ...toolUpdateFromToolResult(chunk, toolUseCache[chunk.tool_use_id]),
+                    };
+                }
+                break;
+            }
+            case "document":
+            case "search_result":
+            case "redacted_thinking":
+            case "input_json_delta":
+            case "citations_delta":
+            case "signature_delta":
+            case "container_upload":
+                break;
+            default:
+                unreachable(chunk, logger);
+                break;
+        }
+        if (update) {
+            output.push({ sessionId, update });
+        }
+    }
+    return output;
+}
+export function streamEventToAcpNotifications(message, sessionId, toolUseCache, client, logger) {
+    const event = message.event;
+    switch (event.type) {
+        case "content_block_start":
+            return toAcpNotifications([event.content_block], "assistant", sessionId, toolUseCache, client, logger);
+        case "content_block_delta":
+            return toAcpNotifications([event.delta], "assistant", sessionId, toolUseCache, client, logger);
+        // No content
+        case "message_start":
+        case "message_delta":
+        case "message_stop":
+        case "content_block_stop":
+            return [];
+        default:
+            unreachable(event, logger);
+            return [];
+    }
+}
+export function runAcp() {
+    const input = nodeToWebWritable(process.stdout);
+    const output = nodeToWebReadable(process.stdin);
+    const stream = ndJsonStream(input, output);
+    new AgentSideConnection((client) => new ClaudeAcpAgent(client), stream);
+}