@posthog/agent 1.25.0 → 1.27.0

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

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