@posthog/agent 1.24.2 → 1.25.0

package/dist/src/adapters/claude/claude.js

@@ -0,0 +1,1112 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { AgentSideConnection, RequestError } from '../../../node_modules/@agentclientprotocol/sdk/dist/acp.js';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { Logger } from '../../utils/logger.js';
+import { createTappedWritableStream } from '../../utils/tapped-stream.js';
+import packageJson from '../../../package.json.js';
+import { createMcpServer, EDIT_TOOL_NAMES, toolNames } from './mcp-server.js';
+import { createPostToolUseHook, toolInfoFromToolUse, toolUpdateFromToolResult, planEntries, registerHookCallback } from './tools.js';
+import { createBidirectionalStreams, Pushable, unreachable } from './utils.js';
+import { ndJsonStream } from '../../../node_modules/@agentclientprotocol/sdk/dist/stream.js';
+import v7 from '../../../node_modules/uuid/dist/v7.js';
+
+/**
+ * The claude adapter has been based on the original claude-code-acp adapter,
+ * and could use some cleanup.
+ *
+ * https://github.com/zed-industries/claude-code-acp
+ */
+/**
+ * Clears the statsig cache to work around a claude-agent-sdk bug where cached
+ * tool definitions include input_examples which causes API errors.
+ * See: https://github.com/anthropics/claude-code/issues/11678
+ */
+function clearStatsigCache() {
+    const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+    const statsigPath = path.join(configDir, "statsig");
+    try {
+        if (fs.existsSync(statsigPath)) {
+            fs.rmSync(statsigPath, { recursive: true, force: true });
+        }
+    }
+    catch {
+        // Ignore errors - cache clearing is best-effort
+    }
+}
+// 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
+class ClaudeAcpAgent {
+    sessions;
+    client;
+    toolUseCache;
+    fileContentCache;
+    backgroundTerminals = {};
+    clientCapabilities;
+    logger = new Logger({ debug: false, prefix: "[ClaudeAcpAgent]" });
+    sessionStore;
+    constructor(client, sessionStore) {
+        this.sessions = {};
+        this.client = client;
+        this.toolUseCache = {};
+        this.fileContentCache = {};
+        this.sessionStore = sessionStore;
+    }
+    createSession(sessionId, q, input, permissionMode) {
+        const session = {
+            query: q,
+            input,
+            cancelled: false,
+            permissionMode,
+            notificationHistory: [],
+        };
+        this.sessions[sessionId] = session;
+        return session;
+    }
+    appendNotification(sessionId, notification) {
+        // In-memory only - S3 persistence is now automatic via tapped stream
+        this.sessions[sessionId]?.notificationHistory.push(notification);
+    }
+    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,
+                },
+                loadSession: true,
+                _meta: {
+                    posthog: {
+                        resumeSession: true,
+                    },
+                },
+            },
+            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();
+        }
+        // Allow caller to specify sessionId via _meta (e.g. taskRunId in our case)
+        const sessionId = params._meta?.sessionId ||
+            v7();
+        const input = new Pushable();
+        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 options = {
+            systemPrompt,
+            settingSources: ["user", "project", "local"],
+            stderr: (err) => this.logger.error(err),
+            ...userProvidedOptions,
+            // Override certain fields that must be controlled by ACP
+            cwd: params.cwd,
+            includePartialMessages: true,
+            mcpServers: { ...(userProvidedOptions?.mcpServers || {}), ...mcpServers },
+            // 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,
+            }),
+            hooks: {
+                ...userProvidedOptions?.hooks,
+                PostToolUse: [
+                    ...(userProvidedOptions?.hooks?.PostToolUse || []),
+                    {
+                        hooks: [createPostToolUseHook(this.logger)],
+                    },
+                ],
+            },
+        };
+        const allowedTools = [];
+        const disallowedTools = [];
+        // Check if built-in tools should be disabled
+        const disableBuiltInTools = params._meta?.disableBuiltInTools === true;
+        if (!disableBuiltInTools) {
+            if (this.clientCapabilities?.fs?.readTextFile) {
+                allowedTools.push(toolNames.read);
+                disallowedTools.push("Read");
+            }
+            if (this.clientCapabilities?.fs?.writeTextFile) {
+                disallowedTools.push("Write", "Edit");
+            }
+            if (this.clientCapabilities?.terminal) {
+                allowedTools.push(toolNames.bashOutput, toolNames.killShell);
+                disallowedTools.push("Bash", "BashOutput", "KillShell");
+            }
+        }
+        else {
+            // When built-in tools are disabled, explicitly disallow all of them
+            disallowedTools.push(toolNames.read, toolNames.write, toolNames.edit, toolNames.bash, toolNames.bashOutput, toolNames.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");
+        }
+        // Clear statsig cache before creating query to avoid input_examples bug
+        clearStatsigCache();
+        const q = query({
+            prompt: input,
+            options,
+        });
+        this.createSession(sessionId, q, input, permissionMode);
+        // Register for S3 persistence if config provided
+        const persistence = params._meta?.persistence;
+        if (persistence && this.sessionStore) {
+            this.sessionStore.register(sessionId, persistence);
+        }
+        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: "Always Ask",
+                description: "Prompts for permission on first use of each tool",
+            },
+            {
+                id: "acceptEdits",
+                name: "Accept Edits",
+                description: "Automatically accepts file edit permissions for the session",
+            },
+            {
+                id: "plan",
+                name: "Plan Mode",
+                description: "Claude can analyze but not modify files or execute commands",
+            },
+        ];
+        // Only works in non-root mode
+        if (!IS_ROOT) {
+            availableModes.push({
+                id: "bypassPermissions",
+                name: "Bypass Permissions",
+                description: "Skips all permission prompts",
+            });
+        }
+        return {
+            sessionId,
+            models,
+            modes: {
+                currentModeId: permissionMode,
+                availableModes,
+            },
+        };
+    }
+    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];
+        // Capture and store user message for replay
+        for (const chunk of params.prompt) {
+            const userNotification = {
+                sessionId: params.sessionId,
+                update: {
+                    sessionUpdate: "user_message_chunk",
+                    content: chunk,
+                },
+            };
+            await this.client.sessionUpdate(userNotification);
+            this.appendNotification(params.sessionId, userNotification);
+        }
+        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;
+            }
+            this.logger.debug("SDK message received", {
+                type: message.type,
+                subtype: message.subtype,
+            });
+            switch (message.type) {
+                case "system":
+                    switch (message.subtype) {
+                        case "init":
+                            // Capture SDK session ID and notify client for persistence
+                            if (message.session_id) {
+                                const session = this.sessions[params.sessionId];
+                                if (session && !session.sdkSessionId) {
+                                    session.sdkSessionId = message.session_id;
+                                    this.client.extNotification("_posthog/sdk_session", {
+                                        sessionId: params.sessionId,
+                                        sdkSessionId: message.session_id,
+                                    });
+                                }
+                            }
+                            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);
+                            }
+                            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": {
+                    this.logger.debug("Stream event", { eventType: message.event?.type });
+                    for (const notification of streamEventToAcpNotifications(message, params.sessionId, this.toolUseCache, this.fileContentCache, this.client, this.logger)) {
+                        await this.client.sessionUpdate(notification);
+                        this.appendNotification(params.sessionId, 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.info(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();
+                    }
+                    // For assistant messages, text/thinking are normally streamed via stream_event.
+                    // But some gateways (like LiteLLM) don't stream, so we process all content.
+                    const content = message.message.content;
+                    for (const notification of toAcpNotifications(content, message.message.role, params.sessionId, this.toolUseCache, this.fileContentCache, this.client, this.logger)) {
+                        await this.client.sessionUpdate(notification);
+                        this.appendNotification(params.sessionId, notification);
+                    }
+                    break;
+                }
+                case "tool_progress":
+                    break;
+                case "auth_status":
+                    break;
+                default:
+                    unreachable(message, this.logger);
+                    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 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 "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);
+        if (!params.limit && !params.line) {
+            this.fileContentCache[params.path] = response.content;
+        }
+        return response;
+    }
+    async writeTextFile(params) {
+        const response = await this.client.writeTextFile(params);
+        this.fileContentCache[params.path] = params.content;
+        return response;
+    }
+    /**
+     * Load session delegates to resumeSession since we have no need to replay history.
+     * Client is responsible for fetching and rendering history from S3.
+     */
+    async loadSession(params) {
+        return this.resumeSession(params);
+    }
+    canUseTool(sessionId) {
+        return async (toolName, toolInput, { 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 }, this.fileContentCache, this.logger).title,
+                    },
+                });
+                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 }, this.fileContentCache, this.logger).title,
+                },
+            });
+            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,
+                };
+            }
+        };
+    }
+    /**
+     * Handle custom extension methods.
+     * Per ACP spec, extension methods start with underscore.
+     */
+    async extMethod(method, params) {
+        if (method === "_posthog/session/resume") {
+            await this.resumeSession(params);
+            return {};
+        }
+        throw RequestError.methodNotFound(method);
+    }
+    /**
+     * Resume a session without replaying history.
+     * Client is responsible for fetching and rendering history from S3.
+     * This basically implemetns the ACP session/resume RFD:
+     * https://agentclientprotocol.com/rfds/session-resume
+     */
+    async resumeSession(params) {
+        const { sessionId } = params;
+        // Extract persistence config and SDK session ID from _meta
+        const persistence = params._meta?.persistence;
+        const sdkSessionId = params._meta?.sdkSessionId;
+        if (!this.sessions[sessionId]) {
+            const input = new Pushable();
+            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,
+                        };
+                    }
+                }
+            }
+            const server = createMcpServer(this, sessionId, this.clientCapabilities);
+            mcpServers.acp = {
+                type: "sdk",
+                name: "acp",
+                instance: server,
+            };
+            const permissionMode = "default";
+            const options = {
+                cwd: params.cwd,
+                includePartialMessages: true,
+                mcpServers,
+                systemPrompt: { type: "preset", preset: "claude_code" },
+                settingSources: ["user", "project", "local"],
+                allowDangerouslySkipPermissions: !IS_ROOT,
+                permissionMode,
+                canUseTool: this.canUseTool(sessionId),
+                stderr: (err) => this.logger.error(err),
+                executable: process.execPath,
+                ...(process.env.CLAUDE_CODE_EXECUTABLE && {
+                    pathToClaudeCodeExecutable: process.env.CLAUDE_CODE_EXECUTABLE,
+                }),
+                // Resume from SDK session if available
+                ...(sdkSessionId && { resume: sdkSessionId }),
+                hooks: {
+                    PostToolUse: [
+                        {
+                            hooks: [createPostToolUseHook(this.logger)],
+                        },
+                    ],
+                },
+            };
+            // Clear statsig cache before creating query to avoid input_examples bug
+            clearStatsigCache();
+            const q = query({
+                prompt: input,
+                options,
+            });
+            const availableCommands = await getAvailableSlashCommands(q);
+            const newSession = this.createSession(sessionId, q, input, permissionMode);
+            // Store SDK session ID if resuming
+            if (sdkSessionId) {
+                newSession.sdkSessionId = sdkSessionId;
+            }
+            // Register for future persistence
+            if (persistence && this.sessionStore) {
+                this.sessionStore.register(sessionId, persistence);
+            }
+            setTimeout(() => {
+                this.client.sessionUpdate({
+                    sessionId,
+                    update: {
+                        sessionUpdate: "available_commands_update",
+                        availableCommands,
+                    },
+                });
+            }, 0);
+        }
+        return {};
+    }
+}
+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: 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;
+    }
+}
+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?.startsWith("http")) {
+                    content.push({
+                        type: "image",
+                        source: {
+                            type: "url",
+                            url: chunk.uri,
+                        },
+                    });
+                }
+                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.
+ */
+function toAcpNotifications(content, role, sessionId, toolUseCache, fileContentCache, 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, fileContentCache, logger),
+                    };
+                }
+                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;
+}
+function streamEventToAcpNotifications(message, sessionId, toolUseCache, fileContentCache, client, logger) {
+    const event = message.event;
+    switch (event.type) {
+        case "content_block_start":
+            return toAcpNotifications([event.content_block], "assistant", sessionId, toolUseCache, fileContentCache, client, logger);
+        case "content_block_delta":
+            return toAcpNotifications([event.delta], "assistant", sessionId, toolUseCache, fileContentCache, client, logger);
+        // No content
+        case "message_start":
+        case "message_delta":
+        case "message_stop":
+        case "content_block_stop":
+            return [];
+        default:
+            unreachable(event, logger);
+            return [];
+    }
+}
+function createAcpConnection(config = {}) {
+    const logger = new Logger({ debug: true, prefix: "[AcpConnection]" });
+    const streams = createBidirectionalStreams();
+    const { sessionStore } = config;
+    // Tap both streams for automatic persistence
+    // All messages (bidirectional) will be persisted as they flow through
+    let agentWritable = streams.agent.writable;
+    let clientWritable = streams.client.writable;
+    if (config.sessionId && sessionStore) {
+        // Register session for persistence BEFORE tapping streams
+        // This ensures all messages from the start get persisted
+        if (!sessionStore.isRegistered(config.sessionId)) {
+            sessionStore.register(config.sessionId, {
+                taskId: config.taskId ?? config.sessionId,
+                runId: config.sessionId,
+                logUrl: "", // Will be updated when we get the real logUrl
+            });
+        }
+        // Tap agent→client stream
+        agentWritable = createTappedWritableStream(streams.agent.writable, {
+            onMessage: (line) => {
+                sessionStore.appendRawLine(config.sessionId, line);
+            },
+            logger,
+        });
+        // Tap client→agent stream
+        clientWritable = createTappedWritableStream(streams.client.writable, {
+            onMessage: (line) => {
+                sessionStore.appendRawLine(config.sessionId, line);
+            },
+            logger,
+        });
+    }
+    else {
+        logger.info("Tapped streams NOT enabled", {
+            hasSessionId: !!config.sessionId,
+            hasSessionStore: !!sessionStore,
+        });
+    }
+    const agentStream = ndJsonStream(agentWritable, streams.agent.readable);
+    const agentConnection = new AgentSideConnection((client) => new ClaudeAcpAgent(client, sessionStore), agentStream);
+    return {
+        agentConnection,
+        clientStreams: {
+            readable: streams.client.readable,
+            writable: clientWritable,
+        },
+    };
+}
+
+export { ClaudeAcpAgent, createAcpConnection, promptToClaude, streamEventToAcpNotifications, toAcpNotifications };
+//# sourceMappingURL=claude.js.map