lorenz 0.1.0

package/vendor/claude-agent-acp/dist/acp-agent.js

@@ -0,0 +1,2693 @@
+import { AgentSideConnection, ndJsonStream, RequestError, } from "@agentclientprotocol/sdk";
+import { deleteSession, getSessionMessages, listSessions, query, } from "@anthropic-ai/claude-agent-sdk";
+import { randomUUID } from "node:crypto";
+import * as os from "node:os";
+import * as path from "node:path";
+import packageJson from "../package.json" with { type: "json" };
+import { SettingsManager } from "./settings.js";
+import { applyTaskCreate, applyTaskUpdate, createPostToolUseHook, createTaskHook, parseTaskCreateOutput, planEntries, registerHookCallback, taskStateToPlanEntries, toolInfoFromToolUse, toolUpdateFromDiffToolResponse, toolUpdateFromToolResult, } from "./tools.js";
+import { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./utils.js";
+export const CLAUDE_CONFIG_DIR = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
+const MAX_TITLE_LENGTH = 256;
+function sanitizeTitle(text) {
+    // Replace newlines and collapse whitespace
+    const sanitized = text
+        .replace(/[\r\n]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (sanitized.length <= MAX_TITLE_LENGTH) {
+        return sanitized;
+    }
+    return sanitized.slice(0, MAX_TITLE_LENGTH - 1) + "…";
+}
+const ZERO_USAGE = Object.freeze({
+    input_tokens: 0,
+    output_tokens: 0,
+    cache_read_input_tokens: 0,
+    cache_creation_input_tokens: 0,
+});
+const DEFAULT_CONTEXT_WINDOW = 200000;
+/** Compute a stable fingerprint of the session-defining params so we can
+ *  detect when a loadSession/resumeSession call requires tearing down and
+ *  recreating the underlying Query process.  MCP servers are sorted by name
+ *  so that ordering differences don't trigger unnecessary recreations. */
+function computeSessionFingerprint(params) {
+    const servers = [...(params.mcpServers ?? [])].sort((a, b) => a.name.localeCompare(b.name));
+    return JSON.stringify({ cwd: params.cwd, mcpServers: servers });
+}
+export async function claudeCliPath() {
+    if (process.env.CLAUDE_CODE_EXECUTABLE) {
+        return process.env.CLAUDE_CODE_EXECUTABLE;
+    }
+    // The SDK's CLI is a native binary shipped as a platform-specific optional
+    // dependency of @anthropic-ai/claude-agent-sdk. Resolve via a require bound
+    // to the SDK so nested installs are found even when npm doesn't hoist.
+    const { createRequire } = await import("node:module");
+    const req = createRequire(import.meta.resolve("@anthropic-ai/claude-agent-sdk"));
+    const ext = process.platform === "win32" ? ".exe" : "";
+    // On linux, both glibc and musl variants may be installed side-by-side
+    // (e.g. bunx hydrates every optional dep), so picking one by trial is
+    // unreliable: the wrong binary segfaults at runtime instead of failing to
+    // spawn. Detect the runtime libc and prefer the matching variant, falling
+    // back to the other only if the preferred one isn't installed.
+    const candidates = process.platform === "linux"
+        ? isMuslLibc()
+            ? [
+                `@anthropic-ai/claude-agent-sdk-linux-${process.arch}-musl/claude${ext}`,
+                `@anthropic-ai/claude-agent-sdk-linux-${process.arch}/claude${ext}`,
+            ]
+            : [
+                `@anthropic-ai/claude-agent-sdk-linux-${process.arch}/claude${ext}`,
+                `@anthropic-ai/claude-agent-sdk-linux-${process.arch}-musl/claude${ext}`,
+            ]
+        : [`@anthropic-ai/claude-agent-sdk-${process.platform}-${process.arch}/claude${ext}`];
+    for (const candidate of candidates) {
+        try {
+            return req.resolve(candidate);
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    throw new Error(`Claude native binary not found for ${process.platform}-${process.arch}. ` +
+        `Reinstall @anthropic-ai/claude-agent-sdk without --omit=optional, or set CLAUDE_CODE_EXECUTABLE.`);
+}
+function isMuslLibc() {
+    // process.report.getReport().header.glibcVersionRuntime is populated when
+    // Node is dynamically linked against glibc, and absent on musl.
+    const report = process.report?.getReport();
+    return !report?.header?.glibcVersionRuntime;
+}
+function shouldHideClaudeAuth() {
+    return process.argv.includes("--hide-claude-auth");
+}
+// Bypass Permissions doesn't work if we are a root/sudo user
+const IS_ROOT = (process.geteuid?.() ?? process.getuid?.()) === 0;
+const ALLOW_BYPASS = !IS_ROOT || !!process.env.IS_SANDBOX;
+// Slash commands that the SDK handles locally without replaying the user
+// message and without invoking the model.
+const LOCAL_ONLY_COMMANDS = new Set(["/context", "/heapdump", "/extra-usage"]);
+// The Claude SDK persists local slash command invocations (e.g. `/model`) and
+// their output as user messages in the session transcript, wrapping the
+// payload in these XML-like markers that the CLI uses for its own display.
+// The live prompt loop drops them; replay must strip them too or they leak
+// into the UI on session/load.
+const LOCAL_COMMAND_MARKERS = [
+    "command-name",
+    "command-message",
+    "command-args",
+    "local-command-stdout",
+    "local-command-stderr",
+].map((tag) => ({ open: `<${tag}>`, close: `</${tag}>` }));
+// Single-pass scanner that removes each `<tag>…</tag>` marker (matching the
+// nearest closing tag of the same name, like a lazy regex would).
+function stripMarkerTags(text) {
+    const dead = new Set();
+    let result = "";
+    let copiedUpTo = 0;
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] === "<") {
+            const marker = LOCAL_COMMAND_MARKERS.find((m) => !dead.has(m.open) && text.startsWith(m.open, i));
+            if (marker) {
+                const end = text.indexOf(marker.close, i + marker.open.length);
+                if (end !== -1) {
+                    result += text.slice(copiedUpTo, i);
+                    i = copiedUpTo = end + marker.close.length;
+                    continue;
+                }
+                // No closing marker remains anywhere ahead, and `indexOf` only ever
+                // searches forward from here on, so stop treating this tag as an
+                // opener — that avoids rescanning the tail for it on every match.
+                dead.add(marker.open);
+            }
+        }
+        i++;
+    }
+    return result + text.slice(copiedUpTo);
+}
+/**
+ * Return user-message content with local-command marker tags removed, or
+ * `null` if nothing meaningful remains (caller should skip the message).
+ * Preserves real prose that's mixed in alongside the markers — e.g. a
+ * message like `<command-name>…</command-name>hi` becomes `hi`.
+ */
+export function stripLocalCommandMetadata(content) {
+    if (typeof content === "string") {
+        const stripped = stripMarkerTags(content);
+        return stripped.trim() === "" ? null : stripped;
+    }
+    if (!Array.isArray(content))
+        return content;
+    const kept = [];
+    for (const block of content) {
+        if (block &&
+            typeof block === "object" &&
+            "type" in block &&
+            block.type === "text" &&
+            "text" in block &&
+            typeof block.text === "string") {
+            const stripped = stripMarkerTags(block.text);
+            if (stripped.trim() === "")
+                continue;
+            kept.push({ ...block, text: stripped });
+        }
+        else {
+            kept.push(block);
+        }
+    }
+    if (kept.length === 0)
+        return null;
+    return kept;
+}
+export function isLocalCommandMetadata(content) {
+    return stripLocalCommandMetadata(content) === null;
+}
+const PERMISSION_MODE_ALIASES = {
+    auto: "auto",
+    default: "default",
+    acceptedits: "acceptEdits",
+    dontask: "dontAsk",
+    plan: "plan",
+    bypasspermissions: "bypassPermissions",
+    bypass: "bypassPermissions",
+};
+export function resolvePermissionMode(defaultMode, logger = console) {
+    if (defaultMode === undefined) {
+        return "default";
+    }
+    if (typeof defaultMode !== "string") {
+        logger.error("Ignoring permissions.defaultMode from settings: expected a string.");
+        return "default";
+    }
+    const normalized = defaultMode.trim().toLowerCase();
+    if (normalized === "") {
+        logger.error("Ignoring permissions.defaultMode from settings: expected a non-empty string.");
+        return "default";
+    }
+    const mapped = PERMISSION_MODE_ALIASES[normalized];
+    if (!mapped) {
+        logger.error(`Ignoring permissions.defaultMode from settings: unknown value '${defaultMode}'.`);
+        return "default";
+    }
+    if (mapped === "bypassPermissions" && !ALLOW_BYPASS) {
+        logger.error("Ignoring permissions.defaultMode from settings: bypassPermissions is not available when running as root.");
+        return "default";
+    }
+    return mapped;
+}
+/**
+ * Builds the label for the "Always Allow" permission option so the user can see
+ * the exact scope they are committing to. Uses the SDK-provided suggestions
+ * when available (e.g. `Bash(npm test:*)`) and falls back to naming the whole
+ * tool so "Always Allow" is never a blank check without disclosure.
+ */
+export function describeAlwaysAllow(suggestions, toolName) {
+    if (!suggestions || suggestions.length === 0) {
+        return `Always Allow all ${toolName}`;
+    }
+    const ruleLabels = [];
+    const directories = [];
+    for (const update of suggestions) {
+        if (update.type === "addRules" && update.behavior === "allow") {
+            for (const rule of update.rules) {
+                ruleLabels.push(rule.ruleContent ? `${rule.toolName}(${rule.ruleContent})` : `all ${rule.toolName}`);
+            }
+        }
+        else if (update.type === "addDirectories") {
+            directories.push(...update.directories);
+        }
+    }
+    const parts = [];
+    if (ruleLabels.length > 0) {
+        parts.push(ruleLabels.join(", "));
+    }
+    if (directories.length > 0) {
+        parts.push(`access to ${directories.join(", ")}`);
+    }
+    if (parts.length === 0) {
+        return `Always Allow all ${toolName}`;
+    }
+    return `Always Allow ${parts.join(" and ")}`;
+}
+// Implement the ACP Agent interface
+export class ClaudeAcpAgent {
+    constructor(client, logger) {
+        this.backgroundTerminals = {};
+        this.sessions = {};
+        this.client = client;
+        this.toolUseCache = {};
+        this.logger = logger ?? console;
+    }
+    async initialize(request) {
+        this.clientCapabilities = request.clientCapabilities;
+        // Bypasses standard auth by routing requests through a custom Anthropic-protocol gateway.
+        // Only offered when the client advertises `auth._meta.gateway` capability.
+        const supportsGatewayAuth = request.clientCapabilities?.auth?._meta?.gateway === true;
+        const gatewayAuthMethod = {
+            id: "gateway",
+            name: "Custom model gateway",
+            description: "Use a custom gateway to authenticate and access models",
+            _meta: {
+                gateway: {
+                    protocol: "anthropic",
+                },
+            },
+        };
+        const gatewayBedrockAuthMethod = {
+            id: "gateway-bedrock",
+            name: "Custom model gateway",
+            description: "Use a custom gateway to authenticate and access models",
+            _meta: {
+                gateway: {
+                    protocol: "bedrock",
+                },
+            },
+        };
+        const supportsTerminalAuth = request.clientCapabilities?.auth?.terminal === true;
+        const supportsMetaTerminalAuth = request.clientCapabilities?._meta?.["terminal-auth"] === true;
+        // Detect remote environments where the OAuth browser redirect to localhost
+        // won't work. This matches the SDK's internal isRemote check. In these cases,
+        // the `auth login` subcommand would fall back to a device-code-like manual
+        // flow, which doesn't work well over ACP, so we offer the TUI login instead.
+        const isRemote = !!(process.env.NO_BROWSER ||
+            process.env.SSH_CONNECTION ||
+            process.env.SSH_CLIENT ||
+            process.env.SSH_TTY ||
+            process.env.CLAUDE_CODE_REMOTE);
+        const terminalAuthMethods = [];
+        if (isRemote) {
+            const remoteLoginMethod = {
+                description: "Run `claude /login` in the terminal",
+                name: "Log in with Claude",
+                id: "claude-login",
+                type: "terminal",
+                args: ["--cli"],
+            };
+            if (supportsMetaTerminalAuth) {
+                remoteLoginMethod._meta = {
+                    "terminal-auth": {
+                        command: process.execPath,
+                        args: [...process.argv.slice(1), "--cli"],
+                        label: "Claude Login",
+                    },
+                };
+            }
+            if (!shouldHideClaudeAuth() && (supportsTerminalAuth || supportsMetaTerminalAuth)) {
+                terminalAuthMethods.push(remoteLoginMethod);
+            }
+        }
+        else {
+            const claudeLoginMethod = {
+                description: "Use Claude subscription ",
+                name: "Claude Subscription",
+                id: "claude-ai-login",
+                type: "terminal",
+                args: ["--cli", "auth", "login", "--claudeai"],
+            };
+            const consoleLoginMethod = {
+                description: "Use Anthropic Console (API usage billing)",
+                name: "Anthropic Console",
+                id: "console-login",
+                type: "terminal",
+                args: ["--cli", "auth", "login", "--console"],
+            };
+            if (supportsMetaTerminalAuth) {
+                const baseArgs = process.argv.slice(1);
+                claudeLoginMethod._meta = {
+                    "terminal-auth": {
+                        command: process.execPath,
+                        args: [...baseArgs, "--cli", "auth", "login", "--claudeai"],
+                        label: "Claude Login",
+                    },
+                };
+                consoleLoginMethod._meta = {
+                    "terminal-auth": {
+                        command: process.execPath,
+                        args: [...baseArgs, "--cli", "auth", "login", "--console"],
+                        label: "Anthropic Console Login",
+                    },
+                };
+            }
+            if (!shouldHideClaudeAuth() && (supportsTerminalAuth || supportsMetaTerminalAuth)) {
+                terminalAuthMethods.push(claudeLoginMethod);
+            }
+            if (supportsTerminalAuth || supportsMetaTerminalAuth) {
+                terminalAuthMethods.push(consoleLoginMethod);
+            }
+        }
+        return {
+            protocolVersion: 1,
+            agentCapabilities: {
+                _meta: {
+                    claudeCode: {
+                        promptQueueing: true,
+                    },
+                },
+                promptCapabilities: {
+                    image: true,
+                    embeddedContext: true,
+                },
+                mcpCapabilities: {
+                    http: true,
+                    sse: true,
+                },
+                loadSession: true,
+                sessionCapabilities: {
+                    additionalDirectories: {},
+                    close: {},
+                    delete: {},
+                    fork: {},
+                    list: {},
+                    resume: {},
+                },
+            },
+            agentInfo: {
+                name: packageJson.name,
+                title: "Claude Agent",
+                version: packageJson.version,
+            },
+            authMethods: [
+                ...terminalAuthMethods,
+                ...(supportsGatewayAuth ? [gatewayAuthMethod, gatewayBedrockAuthMethod] : []),
+            ],
+        };
+    }
+    async newSession(params) {
+        const response = await this.createSession(params, {
+            // Revisit these meta values once we support resume
+            resume: params._meta?.claudeCode?.options?.resume,
+        });
+        // Needs to happen after we return the session
+        setTimeout(() => {
+            this.sendAvailableCommandsUpdate(response.sessionId);
+        }, 0);
+        return response;
+    }
+    async unstable_forkSession(params) {
+        const response = await this.createSession({
+            cwd: params.cwd,
+            mcpServers: params.mcpServers ?? [],
+            additionalDirectories: params.additionalDirectories,
+            _meta: params._meta,
+        }, {
+            resume: params.sessionId,
+            forkSession: true,
+        });
+        // Needs to happen after we return the session
+        setTimeout(() => {
+            this.sendAvailableCommandsUpdate(response.sessionId);
+        }, 0);
+        return response;
+    }
+    async resumeSession(params) {
+        const result = await this.getOrCreateSession(params);
+        // Needs to happen after we return the session
+        setTimeout(() => {
+            this.sendAvailableCommandsUpdate(params.sessionId);
+        }, 0);
+        return result;
+    }
+    async loadSession(params) {
+        const result = await this.getOrCreateSession(params);
+        await this.replaySessionHistory(params.sessionId);
+        // Send available commands after replay so it doesn't interleave with history
+        setTimeout(() => {
+            this.sendAvailableCommandsUpdate(params.sessionId);
+        }, 0);
+        return result;
+    }
+    async listSessions(params) {
+        const sdk_sessions = await listSessions({ dir: params.cwd ?? undefined });
+        const sessions = [];
+        for (const session of sdk_sessions) {
+            if (!session.cwd)
+                continue;
+            sessions.push({
+                sessionId: session.sessionId,
+                cwd: session.cwd,
+                title: sanitizeTitle(session.summary),
+                updatedAt: new Date(session.lastModified).toISOString(),
+            });
+        }
+        return {
+            sessions,
+        };
+    }
+    async authenticate(_params) {
+        if (_params.methodId === "gateway" || _params.methodId === "gateway-bedrock") {
+            this.gatewayAuthRequest = _params;
+            return;
+        }
+        throw new Error("Method not implemented.");
+    }
+    async prompt(params) {
+        const session = this.sessions[params.sessionId];
+        if (!session) {
+            throw new Error("Session not found");
+        }
+        session.cancelled = false;
+        session.accumulatedUsage = {
+            inputTokens: 0,
+            outputTokens: 0,
+            cachedReadTokens: 0,
+            cachedWriteTokens: 0,
+        };
+        let lastAssistantTotalUsage = null;
+        let lastAssistantUsage = null;
+        let lastAssistantModel = null;
+        // When the Claude SDK classifies a turn as failed (e.g. rate limit, auth
+        // problem, billing), it sets a categorical `error` field on the
+        // `SDKAssistantMessage` that precedes the final `result` message. We
+        // capture it here so the subsequent `RequestError.internalError` can
+        // forward it to clients as structured `data`, sparing them from
+        // pattern-matching on the human-readable message text.
+        let lastAssistantError;
+        // Tracks whether we're inside a compaction. The SDK emits the terminal
+        // `status` (compact_result success/failed) twice for a single failed
+        // compaction, and the two messages are indistinguishable — so we report the
+        // outcome only while a compaction is in progress, then clear this. A fresh
+        // `compacting` status sets it again, so every distinct compaction (e.g.
+        // repeated auto-compactions in a long turn) is still shown.
+        let compactionInProgress = false;
+        const userMessage = promptToClaude(params);
+        const promptUuid = randomUUID();
+        userMessage.uuid = promptUuid;
+        // These local-only commands return a result without replaying the user
+        // message. Mark promptReplayed=true so their result isn't consumed as a
+        // background task result.
+        const firstText = params.prompt[0]?.type === "text" ? params.prompt[0].text : "";
+        const isLocalOnlyCommand = firstText.startsWith("/") && LOCAL_ONLY_COMMANDS.has(firstText.split(" ", 1)[0]);
+        if (session.promptRunning) {
+            session.input.push(userMessage);
+            const order = session.nextPendingOrder++;
+            const cancelled = await new Promise((resolve) => {
+                session.pendingMessages.set(promptUuid, { resolve, order });
+            });
+            if (cancelled) {
+                return { stopReason: "cancelled" };
+            }
+        }
+        else {
+            session.input.push(userMessage);
+        }
+        session.promptRunning = true;
+        let handedOff = false;
+        let errored = false;
+        let stopReason = "end_turn";
+        try {
+            while (true) {
+                const { value: message, done } = await session.query.next();
+                if (done || !message) {
+                    if (session.cancelled) {
+                        return { stopReason: "cancelled" };
+                    }
+                    break;
+                }
+                if (session.emitRawSDKMessages &&
+                    shouldEmitRawMessage(session.emitRawSDKMessages, message)) {
+                    await this.client.extNotification("_claude/sdkMessage", {
+                        sessionId: params.sessionId,
+                        message: message,
+                    });
+                }
+                switch (message.type) {
+                    case "system":
+                        switch (message.subtype) {
+                            case "init":
+                                break;
+                            case "status": {
+                                if (message.status === "compacting") {
+                                    compactionInProgress = true;
+                                    await this.client.sessionUpdate({
+                                        sessionId: message.session_id,
+                                        update: {
+                                            sessionUpdate: "agent_message_chunk",
+                                            content: { type: "text", text: "Compacting..." },
+                                        },
+                                    });
+                                }
+                                else if (message.compact_result === "success" && compactionInProgress) {
+                                    // The SDK signals manual `/compact` completion with a status
+                                    // message carrying `compact_result`, not the `compact_boundary`
+                                    // message (which only fires when there's content to compact).
+                                    compactionInProgress = false;
+                                    await this.client.sessionUpdate({
+                                        sessionId: message.session_id,
+                                        update: {
+                                            sessionUpdate: "agent_message_chunk",
+                                            content: { type: "text", text: "\n\nCompacting completed." },
+                                        },
+                                    });
+                                }
+                                else if (message.compact_result === "failed" && compactionInProgress) {
+                                    compactionInProgress = false;
+                                    const reason = message.compact_error ? `: ${message.compact_error}` : ".";
+                                    await this.client.sessionUpdate({
+                                        sessionId: message.session_id,
+                                        update: {
+                                            sessionUpdate: "agent_message_chunk",
+                                            content: { type: "text", text: `\n\nCompacting failed${reason}` },
+                                        },
+                                    });
+                                }
+                                break;
+                            }
+                            case "compact_boundary": {
+                                // Send used:0 immediately so the client doesn't keep showing
+                                // the stale pre-compaction context size until the next turn.
+                                //
+                                // This is a deliberate approximation: we don't know the exact
+                                // post-compaction token count (only the SDK's next API call
+                                // reveals that). But used:0 is directionally correct — context
+                                // just dropped dramatically — and the real value replaces it
+                                // within seconds when the next result message arrives.
+                                // The alternative (no update) leaves the client showing e.g.
+                                // "944k/1m" right after the user sees "Compacting completed",
+                                // which is confusing and wrong.
+                                //
+                                // The "Compacting completed." text is emitted from the `status`
+                                // handler (keyed on `compact_result`), not here, so the failure
+                                // path gets a message too.
+                                lastAssistantTotalUsage = 0;
+                                lastAssistantUsage = null;
+                                await this.client.sessionUpdate({
+                                    sessionId: message.session_id,
+                                    update: {
+                                        sessionUpdate: "usage_update",
+                                        used: 0,
+                                        size: session.contextWindowSize,
+                                    },
+                                });
+                                break;
+                            }
+                            case "local_command_output": {
+                                await this.client.sessionUpdate({
+                                    sessionId: message.session_id,
+                                    update: {
+                                        sessionUpdate: "agent_message_chunk",
+                                        content: { type: "text", text: message.content },
+                                    },
+                                });
+                                break;
+                            }
+                            case "session_state_changed": {
+                                if (message.state === "idle") {
+                                    if (session.cancelled) {
+                                        stopReason = "cancelled";
+                                    }
+                                    return { stopReason, usage: sessionUsage(session) };
+                                }
+                                break;
+                            }
+                            case "memory_recall": {
+                                const isSynthesis = message.mode === "synthesize";
+                                const locations = isSynthesis
+                                    ? []
+                                    : message.memories.map((m) => ({ path: m.path }));
+                                const content = isSynthesis
+                                    ? message.memories
+                                        .filter((m) => typeof m.content === "string")
+                                        .map((m) => ({
+                                        type: "content",
+                                        content: { type: "text", text: m.content },
+                                    }))
+                                    : [];
+                                const count = message.memories.length;
+                                const title = isSynthesis
+                                    ? "Recalled synthesized memory"
+                                    : `Recalled ${count} ${count === 1 ? "memory" : "memories"}`;
+                                await this.client.sessionUpdate({
+                                    sessionId: message.session_id,
+                                    update: {
+                                        sessionUpdate: "tool_call",
+                                        toolCallId: message.uuid,
+                                        title,
+                                        kind: "read",
+                                        status: "completed",
+                                        ...(locations.length > 0 && { locations }),
+                                        ...(content.length > 0 && { content }),
+                                        _meta: {
+                                            claudeCode: {
+                                                toolName: "memory_recall",
+                                                toolResponse: { mode: message.mode },
+                                            },
+                                        },
+                                    },
+                                });
+                                break;
+                            }
+                            case "hook_started":
+                            case "hook_progress":
+                            case "hook_response":
+                            case "files_persisted":
+                            case "task_started":
+                            case "task_notification":
+                            case "task_progress":
+                            case "task_updated":
+                            case "elicitation_complete":
+                            case "plugin_install":
+                            case "notification":
+                            case "api_retry":
+                            case "mirror_error":
+                            case "permission_denied":
+                            case "thinking_tokens":
+                                // 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": {
+                        // Accumulate usage from this result
+                        session.accumulatedUsage.inputTokens += message.usage.input_tokens;
+                        session.accumulatedUsage.outputTokens += message.usage.output_tokens;
+                        session.accumulatedUsage.cachedReadTokens += message.usage.cache_read_input_tokens;
+                        session.accumulatedUsage.cachedWriteTokens += message.usage.cache_creation_input_tokens;
+                        const matchingModelUsage = lastAssistantModel
+                            ? getMatchingModelUsage(message.modelUsage, lastAssistantModel)
+                            : null;
+                        // Only overwrite when we have an authoritative value — a miss
+                        // (e.g. a turn with no top-level assistant message) would
+                        // otherwise discard the window learned on a prior turn and
+                        // leave the next prompt's mid-stream updates reporting 200k.
+                        if (matchingModelUsage) {
+                            session.contextWindowSize = matchingModelUsage.contextWindow;
+                        }
+                        // Task-notification followups are autonomous work triggered by a
+                        // task-notification system message, not by the user's prompt.
+                        // They should not influence the user-turn lifecycle (stop reason,
+                        // slash-command output forwarding) but their cost is real.
+                        const isTaskNotification = message.origin?.kind === "task-notification";
+                        // Send usage_update notification
+                        if (lastAssistantTotalUsage !== null) {
+                            await this.client.sessionUpdate({
+                                sessionId: params.sessionId,
+                                update: {
+                                    sessionUpdate: "usage_update",
+                                    used: lastAssistantTotalUsage,
+                                    size: session.contextWindowSize,
+                                    cost: {
+                                        amount: message.total_cost_usd,
+                                        currency: "USD",
+                                    },
+                                    ...(message.origin && {
+                                        _meta: { "_claude/origin": message.origin },
+                                    }),
+                                },
+                            });
+                        }
+                        if (session.cancelled) {
+                            if (!isTaskNotification) {
+                                stopReason = "cancelled";
+                            }
+                            break;
+                        }
+                        switch (message.subtype) {
+                            case "success": {
+                                if (message.result.includes("Please run /login")) {
+                                    throw RequestError.authRequired();
+                                }
+                                if (message.stop_reason === "max_tokens") {
+                                    if (!isTaskNotification) {
+                                        stopReason = "max_tokens";
+                                    }
+                                    break;
+                                }
+                                if (message.is_error) {
+                                    throw RequestError.internalError(errorKindData(lastAssistantError), message.result);
+                                }
+                                // For local-only commands (no model invocation), the result
+                                // text is the command output — forward it to the client.
+                                // Task-notification followups never originate from a user
+                                // slash command, so skip the forwarding for them.
+                                if (isLocalOnlyCommand && !isTaskNotification) {
+                                    for (const notification of toAcpNotifications(message.result, "assistant", params.sessionId, this.toolUseCache, this.client, this.logger)) {
+                                        await this.client.sessionUpdate(notification);
+                                    }
+                                }
+                                break;
+                            }
+                            case "error_during_execution": {
+                                if (message.stop_reason === "max_tokens") {
+                                    if (!isTaskNotification) {
+                                        stopReason = "max_tokens";
+                                    }
+                                    break;
+                                }
+                                if (message.is_error) {
+                                    throw RequestError.internalError(errorKindData(lastAssistantError), message.errors.join(", ") || message.subtype);
+                                }
+                                if (!isTaskNotification) {
+                                    stopReason = "end_turn";
+                                }
+                                break;
+                            }
+                            case "error_max_budget_usd":
+                            case "error_max_turns":
+                            case "error_max_structured_output_retries":
+                                if (message.is_error) {
+                                    throw RequestError.internalError(errorKindData(lastAssistantError), message.errors.join(", ") || message.subtype);
+                                }
+                                if (!isTaskNotification) {
+                                    stopReason = "max_turn_requests";
+                                }
+                                break;
+                            default:
+                                unreachable(message, this.logger);
+                                break;
+                        }
+                        break;
+                    }
+                    case "stream_event": {
+                        if (message.parent_tool_use_id === null &&
+                            (message.event.type === "message_start" || message.event.type === "message_delta")) {
+                            if (message.event.type === "message_start") {
+                                lastAssistantUsage = snapshotFromUsage(message.event.message.usage);
+                                const model = message.event.message.model;
+                                if (model && model !== "<synthetic>") {
+                                    lastAssistantModel = model;
+                                    // Only upgrade from the default — once a `result` has given
+                                    // us an authoritative window, trust it over the heuristic.
+                                    // Model switches invalidate the cached window via
+                                    // `syncSessionConfigState`, which resets us back to the
+                                    // default so this branch runs again for the new model.
+                                    if (session.contextWindowSize === DEFAULT_CONTEXT_WINDOW) {
+                                        const inferred = inferContextWindowFromModel(model);
+                                        if (inferred !== null) {
+                                            session.contextWindowSize = inferred;
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                const usage = message.event.usage;
+                                const prev = lastAssistantUsage ?? ZERO_USAGE;
+                                // Per Anthropic API, message_delta usage fields are *cumulative*;
+                                // nullable fields (input_tokens and the cache fields) fall back
+                                // to the prior snapshot when the server omits them from this
+                                // delta. Only output_tokens is guaranteed non-null.
+                                lastAssistantUsage = {
+                                    input_tokens: usage.input_tokens ?? prev.input_tokens,
+                                    output_tokens: usage.output_tokens,
+                                    cache_read_input_tokens: usage.cache_read_input_tokens ?? prev.cache_read_input_tokens,
+                                    cache_creation_input_tokens: usage.cache_creation_input_tokens ?? prev.cache_creation_input_tokens,
+                                };
+                            }
+                            const nextUsage = totalTokens(lastAssistantUsage);
+                            if (nextUsage !== lastAssistantTotalUsage) {
+                                lastAssistantTotalUsage = nextUsage;
+                                await this.client.sessionUpdate({
+                                    sessionId: params.sessionId,
+                                    update: {
+                                        sessionUpdate: "usage_update",
+                                        used: nextUsage,
+                                        size: session.contextWindowSize,
+                                    },
+                                });
+                            }
+                        }
+                        for (const notification of streamEventToAcpNotifications(message, params.sessionId, this.toolUseCache, this.client, this.logger, {
+                            clientCapabilities: this.clientCapabilities,
+                            cwd: session.cwd,
+                            taskState: session.taskState,
+                        })) {
+                            await this.client.sessionUpdate(notification);
+                        }
+                        break;
+                    }
+                    case "user":
+                    case "assistant": {
+                        if (session.cancelled) {
+                            break;
+                        }
+                        // Check for prompt replay
+                        if (message.type === "user" && "uuid" in message && message.uuid) {
+                            if (message.uuid === promptUuid) {
+                                break;
+                            }
+                            const pending = session.pendingMessages.get(message.uuid);
+                            if (pending) {
+                                pending.resolve(false);
+                                session.pendingMessages.delete(message.uuid);
+                                handedOff = true;
+                                // the current loop stops with end_turn,
+                                // the loop of the next prompt continues running
+                                return { stopReason: "end_turn", usage: sessionUsage(session) };
+                            }
+                            if ("isReplay" in message && message.isReplay) {
+                                // not pending or unrelated replay message
+                                break;
+                            }
+                        }
+                        // Snapshot the latest top-level assistant usage and model so the
+                        // next `result` can emit a usage_update tied to the right context
+                        // window. Subagent messages are excluded to keep the snapshot
+                        // aligned with what the user's current selection is producing.
+                        if (message.type === "assistant" && message.parent_tool_use_id === null) {
+                            lastAssistantUsage = snapshotFromUsage(message.message.usage);
+                            lastAssistantTotalUsage = totalTokens(lastAssistantUsage);
+                            if (message.message.model && message.message.model !== "<synthetic>") {
+                                lastAssistantModel = message.message.model;
+                            }
+                            if (message.error) {
+                                lastAssistantError = message.error;
+                            }
+                        }
+                        // symphony-patch: every assistant message carries the final token
+                        // usage of exactly one model call (subagent calls included via
+                        // parent_tool_use_id), so surface it as a per-call bucket on
+                        // usage_update._meta for call-by-call accounting downstream.
+                        if (message.type === "assistant" &&
+                            message.message.usage &&
+                            message.message.model !== "<synthetic>") {
+                            const callUsage = message.message.usage;
+                            session.symphonyCallSeq = (session.symphonyCallSeq ?? 0) + 1;
+                            await this.client.sessionUpdate({
+                                sessionId: params.sessionId,
+                                update: {
+                                    sessionUpdate: "usage_update",
+                                    used: lastAssistantTotalUsage ?? 0,
+                                    size: session.contextWindowSize,
+                                    _meta: {
+                                        "symphony/callUsage": {
+                                            seq: session.symphonyCallSeq,
+                                            inputTokens: callUsage.input_tokens ?? 0,
+                                            outputTokens: callUsage.output_tokens ?? 0,
+                                            cachedReadTokens: callUsage.cache_read_input_tokens ?? 0,
+                                            cachedWriteTokens: callUsage.cache_creation_input_tokens ?? 0,
+                                            totalTokens: (callUsage.input_tokens ?? 0) +
+                                                (callUsage.output_tokens ?? 0) +
+                                                (callUsage.cache_read_input_tokens ?? 0) +
+                                                (callUsage.cache_creation_input_tokens ?? 0),
+                                        },
+                                    },
+                                },
+                            });
+                        }
+                        // Strip <command-*>/<local-command-stdout> markers and render any
+                        // remaining prose. Skill bodies and built-in slash commands (e.g.
+                        // /usage, /status, /model) arrive wrapped in these tags; pure-marker
+                        // payloads (e.g. /compact's malformed output) strip to null and are
+                        // skipped. Mirrors the replay path at replaySessionHistory.
+                        if (message.message.role !== "system" &&
+                            typeof message.message.content === "string" &&
+                            message.message.content.includes("<local-command-stdout>")) {
+                            const stripped = stripLocalCommandMetadata(message.message.content);
+                            if (typeof stripped === "string") {
+                                for (const notification of toAcpNotifications(stripped, message.message.role, params.sessionId, this.toolUseCache, this.client, this.logger, {
+                                    clientCapabilities: this.clientCapabilities,
+                                    parentToolUseId: message.parent_tool_use_id,
+                                    cwd: session.cwd,
+                                    taskState: session.taskState,
+                                })) {
+                                    await this.client.sessionUpdate(notification);
+                                }
+                            }
+                            else {
+                                this.logger.log(message.message.content);
+                            }
+                            break;
+                        }
+                        if (typeof message.message.content === "string" &&
+                            message.message.content.includes("<local-command-stderr>")) {
+                            this.logger.error(message.message.content);
+                            break;
+                        }
+                        // Skip these user messages for now, since they seem to just be messages we don't want in the feed
+                        if (message.type === "user" &&
+                            (typeof message.message.content === "string" ||
+                                (Array.isArray(message.message.content) &&
+                                    message.message.content.length === 1 &&
+                                    message.message.content[0].type === "text"))) {
+                            break;
+                        }
+                        if (message.message.role === "system") {
+                            break;
+                        }
+                        if (message.type === "assistant" &&
+                            message.message.model === "<synthetic>" &&
+                            Array.isArray(message.message.content) &&
+                            message.message.content.length === 1 &&
+                            message.message.content[0].type === "text" &&
+                            message.message.content[0].text.includes("Please run /login")) {
+                            throw RequestError.authRequired();
+                        }
+                        const content = message.type === "assistant"
+                            ? // Handled by stream events above
+                                message.message.content.filter((item) => !["text", "thinking"].includes(item.type))
+                            : message.message.content;
+                        for (const notification of toAcpNotifications(content, message.message.role, params.sessionId, this.toolUseCache, this.client, this.logger, {
+                            clientCapabilities: this.clientCapabilities,
+                            parentToolUseId: message.parent_tool_use_id,
+                            cwd: session.cwd,
+                            taskState: session.taskState,
+                        })) {
+                            await this.client.sessionUpdate(notification);
+                        }
+                        break;
+                    }
+                    case "tool_progress":
+                    case "tool_use_summary":
+                    case "auth_status":
+                    case "prompt_suggestion":
+                    case "rate_limit_event":
+                        break;
+                    default:
+                        unreachable(message);
+                        break;
+                }
+            }
+            throw new Error("Session did not end in result");
+        }
+        catch (error) {
+            errored = true;
+            // A failed turn typically leaves a trailing `session_state_changed: idle`
+            // (and possibly more) in the query iterator. If we don't drain it here,
+            // the next prompt's first `query.next()` consumes that stale idle and
+            // short-circuits to end_turn with zero usage
+            // Bounded so a misbehaving SDK can't hang the next prompt indefinitely.
+            try {
+                await session.query.interrupt();
+                const MAX_DRAIN = 100;
+                for (let i = 0; i < MAX_DRAIN; i++) {
+                    const { value: m, done } = await session.query.next();
+                    if (done || !m)
+                        break;
+                    if (m.type === "system" && m.subtype === "session_state_changed" && m.state === "idle") {
+                        break;
+                    }
+                    if (i === MAX_DRAIN - 1) {
+                        this.logger.error(`Session ${params.sessionId}: drained ${MAX_DRAIN} messages after error without observing idle`);
+                    }
+                }
+            }
+            catch (drainErr) {
+                this.logger.error(`Session ${params.sessionId}: failed to drain query after prompt error:`, drainErr);
+            }
+            if (error instanceof RequestError || !(error instanceof Error)) {
+                throw error;
+            }
+            const message = error.message;
+            if (message.includes("ProcessTransport") ||
+                message.includes("terminated process") ||
+                message.includes("process exited with") ||
+                message.includes("process terminated by signal") ||
+                message.includes("Failed to write to process stdin")) {
+                this.logger.error(`Session ${params.sessionId}: Claude Agent process died: ${message}`);
+                session.settingsManager.dispose();
+                session.input.end();
+                delete this.sessions[params.sessionId];
+                throw RequestError.internalError(undefined, "The Claude Agent process exited unexpectedly. Please start a new session.");
+            }
+            throw error;
+        }
+        finally {
+            if (!handedOff) {
+                session.promptRunning = false;
+                if (errored) {
+                    // The query stream was just drained — handing pending prompts off
+                    // onto it would let them race with the recovery. Cancel them so
+                    // each waiting prompt() returns stopReason: "cancelled" and the
+                    // client can decide whether to retry.
+                    for (const pending of session.pendingMessages.values()) {
+                        pending.resolve(true);
+                    }
+                    session.pendingMessages.clear();
+                }
+                else if (session.pendingMessages.size > 0) {
+                    // This usually should not happen, but in case the loop finishes
+                    // without claude sending all message replays, we resolve the
+                    // next pending prompt call to ensure no prompts get stuck.
+                    const next = [...session.pendingMessages.entries()].sort((a, b) => a[1].order - b[1].order)[0];
+                    if (next) {
+                        next[1].resolve(false);
+                        session.pendingMessages.delete(next[0]);
+                    }
+                }
+            }
+        }
+    }
+    async cancel(params) {
+        const session = this.sessions[params.sessionId];
+        if (!session) {
+            return;
+        }
+        session.cancelled = true;
+        for (const [, pending] of session.pendingMessages) {
+            pending.resolve(true);
+        }
+        session.pendingMessages.clear();
+        await session.query.interrupt();
+    }
+    /** Cleanly tear down a session: cancel in-flight work, dispose resources,
+     *  and remove it from the session map. */
+    async teardownSession(sessionId) {
+        const session = this.sessions[sessionId];
+        if (!session) {
+            return;
+        }
+        await this.cancel({ sessionId });
+        session.settingsManager.dispose();
+        session.abortController.abort();
+        session.query.close();
+        delete this.sessions[sessionId];
+    }
+    /** Tear down all active sessions. Called when the ACP connection closes. */
+    async dispose() {
+        await Promise.all(Object.keys(this.sessions).map((id) => this.teardownSession(id)));
+    }
+    async closeSession(params) {
+        if (!this.sessions[params.sessionId]) {
+            throw new Error("Session not found");
+        }
+        await this.teardownSession(params.sessionId);
+        return {};
+    }
+    async unstable_deleteSession(params) {
+        // Tear down any active in-memory state first so the on-disk file isn't
+        // recreated by an outstanding query writing to it.
+        if (this.sessions[params.sessionId]) {
+            await this.teardownSession(params.sessionId);
+        }
+        await deleteSession(params.sessionId);
+        return {};
+    }
+    async setSessionMode(params) {
+        if (!this.sessions[params.sessionId]) {
+            throw new Error("Session not found");
+        }
+        await this.applySessionMode(params.sessionId, params.modeId);
+        await this.updateConfigOption(params.sessionId, "mode", params.modeId);
+        return {};
+    }
+    async setSessionConfigOption(params) {
+        const session = this.sessions[params.sessionId];
+        if (!session) {
+            throw new Error("Session not found");
+        }
+        if (typeof params.value !== "string") {
+            throw new Error(`Invalid value for config option ${params.configId}: ${params.value}`);
+        }
+        const option = session.configOptions.find((o) => o.id === params.configId);
+        if (!option) {
+            throw new Error(`Unknown config option: ${params.configId}`);
+        }
+        const allValues = "options" in option && Array.isArray(option.options)
+            ? option.options.flatMap((o) => ("options" in o ? o.options : [o]))
+            : [];
+        let validValue = allValues.find((o) => o.value === params.value);
+        // For model options, fall back to resolveModelPreference when the exact
+        // value doesn't match.  This lets callers use human-friendly aliases like
+        // "opus" or "sonnet" instead of full model IDs like "claude-opus-4-6".
+        if (!validValue && params.configId === "model") {
+            const modelInfos = allValues.map((o) => ({
+                value: o.value,
+                displayName: o.name,
+                description: o.description ?? "",
+            }));
+            const resolved = resolveModelPreference(modelInfos, params.value);
+            if (resolved) {
+                validValue = allValues.find((o) => o.value === resolved.value);
+            }
+        }
+        if (!validValue) {
+            throw new Error(`Invalid value for config option ${params.configId}: ${params.value}`);
+        }
+        // Use the canonical option value so downstream code always receives the
+        // model ID rather than the caller-supplied alias.
+        const resolvedValue = validValue.value;
+        if (params.configId === "mode") {
+            await this.applySessionMode(params.sessionId, resolvedValue);
+            await this.client.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                    sessionUpdate: "current_mode_update",
+                    currentModeId: resolvedValue,
+                },
+            });
+        }
+        else if (params.configId === "model") {
+            await this.sessions[params.sessionId].query.setModel(resolvedValue);
+        }
+        // Effort SDK sync is handled inside applyConfigOptionValue so that direct
+        // effort changes and effort changes induced by a model switch go through
+        // the same path.
+        await this.applyConfigOptionValue(params.sessionId, session, params.configId, resolvedValue);
+        return { configOptions: session.configOptions };
+    }
+    async applySessionMode(sessionId, modeId) {
+        switch (modeId) {
+            case "auto":
+            case "default":
+            case "acceptEdits":
+            case "bypassPermissions":
+            case "dontAsk":
+            case "plan":
+                break;
+            default:
+                throw new Error("Invalid Mode");
+        }
+        const session = this.sessions[sessionId];
+        if (!session) {
+            throw new Error("Session not found");
+        }
+        if (!session.modes.availableModes.some((mode) => mode.id === modeId)) {
+            throw new Error(`Mode ${modeId} is not available in this session`);
+        }
+        try {
+            await session.query.setPermissionMode(modeId);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (!error.message) {
+                    error.message = "Invalid Mode";
+                }
+                throw error;
+            }
+            else {
+                // eslint-disable-next-line preserve-caught-error
+                throw new Error("Invalid Mode");
+            }
+        }
+    }
+    async replaySessionHistory(sessionId) {
+        const toolUseCache = {};
+        const messages = await getSessionMessages(sessionId);
+        for (const message of messages) {
+            // @ts-expect-error - untyped in SDK but we handle all of these
+            let content = message.message.content;
+            // @ts-expect-error - untyped in SDK but we handle all of these
+            if (message.message.role === "user") {
+                content = stripLocalCommandMetadata(content);
+                if (content === null)
+                    continue;
+            }
+            for (const notification of toAcpNotifications(
+            // @ts-expect-error - untyped in SDK but we handle all of these
+            content, 
+            // @ts-expect-error - untyped in SDK but we handle all of these
+            message.message.role, sessionId, toolUseCache, this.client, this.logger, {
+                registerHooks: false,
+                clientCapabilities: this.clientCapabilities,
+                cwd: this.sessions[sessionId]?.cwd,
+                taskState: this.sessions[sessionId]?.taskState,
+            })) {
+                await this.client.sessionUpdate(notification);
+            }
+        }
+    }
+    async readTextFile(params) {
+        const response = await this.client.readTextFile(params);
+        return response;
+    }
+    async writeTextFile(params) {
+        const response = await this.client.writeTextFile(params);
+        return response;
+    }
+    canUseTool(sessionId) {
+        return async (toolName, toolInput, { signal, suggestions, toolUseID }) => {
+            const alwaysAllowLabel = describeAlwaysAllow(suggestions, toolName);
+            const supportsTerminalOutput = this.clientCapabilities?._meta?.["terminal_output"] === true;
+            const session = this.sessions[sessionId];
+            if (!session) {
+                return {
+                    behavior: "deny",
+                    message: "Session not found",
+                };
+            }
+            if (toolName === "ExitPlanMode") {
+                const optionsAll = [
+                    { kind: "allow_always", name: 'Yes, and use "auto" mode', optionId: "auto" },
+                    {
+                        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" },
+                ];
+                if (ALLOW_BYPASS) {
+                    optionsAll.unshift({
+                        kind: "allow_always",
+                        name: "Yes, and bypass permissions",
+                        optionId: "bypassPermissions",
+                    });
+                }
+                // Filter against the session's currently-advertised modes so we never
+                // present options the active model can't honor (e.g. `auto` on Haiku).
+                // `bypassPermissions` is already covered by `availableModes` via
+                // `buildAvailableModes`/`ALLOW_BYPASS`. The `plan` option is a
+                // "keep planning" reject path; it's always present in `availableModes`.
+                const options = optionsAll.filter((o) => session.modes.availableModes.some((m) => m.id === o.optionId));
+                const response = await this.client.requestPermission({
+                    options,
+                    sessionId,
+                    toolCall: {
+                        toolCallId: toolUseID,
+                        rawInput: toolInput,
+                        ...toolInfoFromToolUse({ name: toolName, input: toolInput, id: toolUseID }, supportsTerminalOutput, session?.cwd),
+                    },
+                });
+                if (signal.aborted || response.outcome?.outcome === "cancelled") {
+                    throw new Error("Tool use aborted");
+                }
+                const selectedMode = response.outcome?.outcome === "selected" ? response.outcome.optionId : undefined;
+                const selectedModeWasOffered = options.some((option) => option.optionId === selectedMode);
+                if (selectedModeWasOffered &&
+                    (selectedMode === "default" ||
+                        selectedMode === "acceptEdits" ||
+                        selectedMode === "auto" ||
+                        selectedMode === "bypassPermissions")) {
+                    await this.client.sessionUpdate({
+                        sessionId,
+                        update: {
+                            sessionUpdate: "current_mode_update",
+                            currentModeId: selectedMode,
+                        },
+                    });
+                    await this.updateConfigOption(sessionId, "mode", selectedMode);
+                    return {
+                        behavior: "allow",
+                        updatedInput: toolInput,
+                        updatedPermissions: suggestions ?? [
+                            { type: "setMode", mode: selectedMode, destination: "session" },
+                        ],
+                    };
+                }
+                else {
+                    return {
+                        behavior: "deny",
+                        message: "User rejected request to exit plan mode.",
+                    };
+                }
+            }
+            if (session.modes.currentModeId === "bypassPermissions") {
+                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: alwaysAllowLabel,
+                        optionId: "allow_always",
+                    },
+                    { kind: "allow_once", name: "Allow", optionId: "allow" },
+                    { kind: "reject_once", name: "Reject", optionId: "reject" },
+                ],
+                sessionId,
+                toolCall: {
+                    toolCallId: toolUseID,
+                    rawInput: toolInput,
+                    ...toolInfoFromToolUse({ name: toolName, input: toolInput, id: toolUseID }, supportsTerminalOutput, session?.cwd),
+                },
+            });
+            if (signal.aborted || response.outcome?.outcome === "cancelled") {
+                throw new Error("Tool use aborted");
+            }
+            if (response.outcome?.outcome === "selected" &&
+                (response.outcome.optionId === "allow" || response.outcome.optionId === "allow_always")) {
+                // If Claude Code has suggestions, it will update their settings already
+                if (response.outcome.optionId === "allow_always") {
+                    return {
+                        behavior: "allow",
+                        updatedInput: toolInput,
+                        updatedPermissions: suggestions ?? [
+                            {
+                                type: "addRules",
+                                rules: [{ toolName }],
+                                behavior: "allow",
+                                destination: "session",
+                            },
+                        ],
+                    };
+                }
+                return {
+                    behavior: "allow",
+                    updatedInput: toolInput,
+                };
+            }
+            else {
+                return {
+                    behavior: "deny",
+                    message: "User refused permission to run tool",
+                };
+            }
+        };
+    }
+    async sendAvailableCommandsUpdate(sessionId) {
+        const session = this.sessions[sessionId];
+        if (!session)
+            return;
+        const commands = await session.query.supportedCommands();
+        await this.client.sessionUpdate({
+            sessionId,
+            update: {
+                sessionUpdate: "available_commands_update",
+                availableCommands: getAvailableSlashCommands(commands),
+            },
+        });
+    }
+    async updateConfigOption(sessionId, configId, value) {
+        const session = this.sessions[sessionId];
+        if (!session)
+            return;
+        await this.applyConfigOptionValue(sessionId, session, configId, value);
+        await this.client.sessionUpdate({
+            sessionId,
+            update: {
+                sessionUpdate: "config_option_update",
+                configOptions: session.configOptions,
+            },
+        });
+    }
+    async applyConfigOptionValue(sessionId, session, configId, value) {
+        if (configId === "mode") {
+            session.modes = { ...session.modes, currentModeId: value };
+            session.configOptions = session.configOptions.map((o) => o.id === configId && typeof o.currentValue === "string" ? { ...o, currentValue: value } : o);
+        }
+        else if (configId === "model") {
+            if (session.models.currentModelId !== value) {
+                // The cached context window was learned for the previous model; reset
+                // to the new model's heuristic so mid-stream updates between now and
+                // the next `result` reflect the user's selection instead of the old
+                // model's window.
+                session.contextWindowSize = inferContextWindowFromModel(value) ?? DEFAULT_CONTEXT_WINDOW;
+            }
+            session.models = { ...session.models, currentModelId: value };
+            // Recompute availableModes for the new model and clamp the current
+            // mode if the SDK no longer offers it (today: "auto" on Haiku).
+            // `ModelInfo.supportsAutoMode` is the canonical SDK signal.
+            const newModelInfo = session.modelInfos.find((m) => m.value === value);
+            const newAvailableModes = buildAvailableModes(newModelInfo);
+            // Capture BEFORE mutating session.modes so the log message reflects
+            // the invalidated mode rather than "default".
+            const previousModeId = session.modes.currentModeId;
+            let modeDowngraded = false;
+            if (!newAvailableModes.some((m) => m.id === previousModeId)) {
+                session.modes = {
+                    availableModes: newAvailableModes,
+                    currentModeId: "default",
+                };
+                try {
+                    await session.query.setPermissionMode("default");
+                }
+                catch (err) {
+                    // Failing the entire model switch over a bookkeeping sync error is
+                    // worse UX than logging and continuing; the user explicitly asked
+                    // to change models. The next setPermissionMode from the user will
+                    // either succeed or surface a fresh error.
+                    this.logger.error(`Failed to sync permissionMode to "default" after model switch invalidated "${previousModeId}":`, err);
+                }
+                modeDowngraded = true;
+            }
+            else {
+                session.modes = { ...session.modes, availableModes: newAvailableModes };
+            }
+            // Rebuild config options since effort levels depend on the selected model
+            const effortOpt = session.configOptions.find((o) => o.id === "effort");
+            const currentEffort = typeof effortOpt?.currentValue === "string" ? effortOpt.currentValue : undefined;
+            session.configOptions = buildConfigOptions(session.modes, session.models, session.modelInfos, currentEffort);
+            // Sync effort with the SDK if it changed after the model switch
+            const newEffortOpt = session.configOptions.find((o) => o.id === "effort");
+            const newEffort = typeof newEffortOpt?.currentValue === "string" ? newEffortOpt.currentValue : undefined;
+            if (newEffort !== currentEffort) {
+                await session.query.applyFlagSettings({
+                    effortLevel: toSdkEffortLevel(newEffort),
+                });
+            }
+            // Emit current_mode_update only after session.modes AND
+            // session.configOptions have been fully reconciled. This way, a failure
+            // in the configOptions/effort rebuild above can't leave the client with
+            // a clamped currentModeId but stale configOptions, and the notification
+            // still precedes the caller's config_option_update so order-sensitive
+            // clients update currentModeId before re-rendering the option list.
+            if (modeDowngraded) {
+                await this.client.sessionUpdate({
+                    sessionId,
+                    update: {
+                        sessionUpdate: "current_mode_update",
+                        currentModeId: "default",
+                    },
+                });
+            }
+        }
+        else {
+            session.configOptions = session.configOptions.map((o) => o.id === configId && typeof o.currentValue === "string" ? { ...o, currentValue: value } : o);
+            if (configId === "effort") {
+                await session.query.applyFlagSettings({
+                    effortLevel: toSdkEffortLevel(value),
+                });
+            }
+        }
+    }
+    async getOrCreateSession(params) {
+        const existingSession = this.sessions[params.sessionId];
+        if (existingSession) {
+            const fingerprint = computeSessionFingerprint(params);
+            if (fingerprint === existingSession.sessionFingerprint) {
+                return {
+                    sessionId: params.sessionId,
+                    modes: existingSession.modes,
+                    configOptions: existingSession.configOptions,
+                };
+            }
+            // Session-defining params changed (e.g. cwd pointed at a git worktree,
+            // or MCP servers reconfigured). Tear down the existing session and
+            // recreate it so the underlying Query process picks up the new values.
+            await this.teardownSession(params.sessionId);
+        }
+        const response = await this.createSession({
+            cwd: params.cwd,
+            mcpServers: params.mcpServers ?? [],
+            additionalDirectories: params.additionalDirectories,
+            _meta: params._meta,
+        }, {
+            resume: params.sessionId,
+        });
+        return {
+            sessionId: response.sessionId,
+            modes: response.modes,
+            configOptions: response.configOptions,
+        };
+    }
+    async createSession(params, creationOpts = {}) {
+        // We want to create a new session id unless it is resume,
+        // but not resume + forkSession.
+        let sessionId;
+        if (creationOpts.forkSession) {
+            sessionId = randomUUID();
+        }
+        else if (creationOpts.resume) {
+            sessionId = creationOpts.resume;
+        }
+        else {
+            sessionId = randomUUID();
+        }
+        const input = new Pushable();
+        const settingsManager = new SettingsManager(params.cwd, {
+            logger: this.logger,
+        });
+        await settingsManager.initialize();
+        // symphony-patch: overlay per-session settings supplied via session
+        // _meta (settings.json shape) on top of the resolved file settings.
+        // Everything the bridge derives from settings (permissions.defaultMode,
+        // model, availableModels, effortLevel) then works per session without
+        // writing settings files into the workspace.
+        const symphonySettings = params._meta?.["symphony/settings"];
+        if (symphonySettings &&
+            typeof symphonySettings === "object" &&
+            !Array.isArray(symphonySettings)) {
+            const baseGetSettings = settingsManager.getSettings.bind(settingsManager);
+            settingsManager.getSettings = () => mergeSymphonySettings(baseGetSettings(), symphonySettings);
+        }
+        const mcpServers = {};
+        if (Array.isArray(params.mcpServers)) {
+            for (const server of params.mcpServers) {
+                if ("type" in server && (server.type === "http" || server.type === "sse")) {
+                    // HTTP or SSE type MCP 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 if (!("type" in server)) {
+                    // Stdio type MCP server (with or without explicit type field)
+                    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,
+                    };
+                }
+            }
+        }
+        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" &&
+                customPrompt !== null &&
+                !Array.isArray(customPrompt)) {
+                // Forward all preset options (append, excludeDynamicSections, and
+                // anything the SDK adds later) while locking type/preset.
+                systemPrompt = {
+                    ...customPrompt,
+                    type: "preset",
+                    preset: "claude_code",
+                };
+            }
+        }
+        const permissionMode = resolvePermissionMode(settingsManager.getSettings().permissions?.defaultMode, this.logger);
+        // Extract options from _meta if provided
+        const sessionMeta = params._meta;
+        const userProvidedOptions = sessionMeta?.claudeCode?.options;
+        // Configure thinking tokens from environment variable
+        const maxThinkingTokens = process.env.MAX_THINKING_TOKENS
+            ? parseInt(process.env.MAX_THINKING_TOKENS, 10)
+            : undefined;
+        // Parse model configuration from environment (e.g. Bedrock model overrides)
+        const modelConfig = parseModelConfig(process.env.CLAUDE_MODEL_CONFIG);
+        // Disable this for now, not a great way to expose this over ACP at the moment (in progress work so we can revisit)
+        const disallowedTools = ["AskUserQuestion"];
+        // Resolve which built-in tools to expose.
+        // Explicit tools array from _meta.claudeCode.options takes precedence.
+        // disableBuiltInTools is a legacy shorthand for tools: [] — kept for
+        // backward compatibility but callers should prefer the tools array.
+        const tools = userProvidedOptions?.tools ??
+            (params._meta?.disableBuiltInTools === true ? [] : { type: "preset", preset: "claude_code" });
+        const abortController = userProvidedOptions?.abortController || new AbortController();
+        // Per-session task state. Created here (rather than in the session record
+        // below) so the TaskCreated/TaskCompleted hook callbacks can close over
+        // the same Map that the streaming message handler will read from.
+        const taskState = new Map();
+        const options = {
+            systemPrompt,
+            settingSources: ["user", "project", "local"],
+            ...(maxThinkingTokens !== undefined && { maxThinkingTokens }),
+            ...userProvidedOptions,
+            // CLAUDE_MODEL_CONFIG env var is a fallback for model
+            // configuration (e.g. Bedrock model ID overrides). When the caller
+            // provides settings via _meta, we intentionally ignore the env var —
+            // the caller is assumed to have full control over model configuration.
+            ...(!userProvidedOptions?.settings &&
+                modelConfig && {
+                settings: {
+                    ...(modelConfig.modelOverrides && { modelOverrides: modelConfig.modelOverrides }),
+                    ...(modelConfig.availableModels && { availableModels: modelConfig.availableModels }),
+                },
+            }),
+            env: {
+                ...process.env,
+                ...userProvidedOptions?.env,
+                ...createEnvForGateway(this.gatewayAuthRequest),
+                // Opt-in to session state events like when the agent is idle
+                CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS: "1",
+            },
+            // 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: ALLOW_BYPASS,
+            permissionMode,
+            canUseTool: this.canUseTool(sessionId),
+            pathToClaudeCodeExecutable: process.env.CLAUDE_CODE_EXECUTABLE ?? (await claudeCliPath()),
+            extraArgs: {
+                ...userProvidedOptions?.extraArgs,
+                "replay-user-messages": "",
+            },
+            disallowedTools: [...(userProvidedOptions?.disallowedTools || []), ...disallowedTools],
+            tools,
+            hooks: {
+                ...userProvidedOptions?.hooks,
+                PostToolUse: [
+                    ...(userProvidedOptions?.hooks?.PostToolUse || []),
+                    {
+                        hooks: [
+                            createPostToolUseHook(this.logger, {
+                                onEnterPlanMode: async () => {
+                                    await this.client.sessionUpdate({
+                                        sessionId,
+                                        update: {
+                                            sessionUpdate: "current_mode_update",
+                                            currentModeId: "plan",
+                                        },
+                                    });
+                                    await this.updateConfigOption(sessionId, "mode", "plan");
+                                },
+                            }),
+                        ],
+                    },
+                ],
+                TaskCreated: [
+                    ...(userProvidedOptions?.hooks?.TaskCreated || []),
+                    {
+                        hooks: [
+                            createTaskHook({
+                                taskState,
+                                onChange: async () => {
+                                    await this.client.sessionUpdate({
+                                        sessionId,
+                                        update: {
+                                            sessionUpdate: "plan",
+                                            entries: taskStateToPlanEntries(taskState),
+                                        },
+                                    });
+                                },
+                            }),
+                        ],
+                    },
+                ],
+                TaskCompleted: [
+                    ...(userProvidedOptions?.hooks?.TaskCompleted || []),
+                    {
+                        hooks: [
+                            createTaskHook({
+                                taskState,
+                                onChange: async () => {
+                                    await this.client.sessionUpdate({
+                                        sessionId,
+                                        update: {
+                                            sessionUpdate: "plan",
+                                            entries: taskStateToPlanEntries(taskState),
+                                        },
+                                    });
+                                },
+                            }),
+                        ],
+                    },
+                ],
+            },
+            ...creationOpts,
+            abortController,
+        };
+        // Prefer the official ACP `additionalDirectories` field. Fall back to the
+        // legacy `_meta.additionalRoots` extension for clients that haven't been
+        // updated yet. Either source is merged with directories supplied via
+        // `_meta.claudeCode.options.additionalDirectories` (SDK pass-through).
+        const acpAdditionalDirectories = params.additionalDirectories ?? sessionMeta?.additionalRoots ?? [];
+        options.additionalDirectories = [
+            ...(userProvidedOptions?.additionalDirectories ?? []),
+            ...acpAdditionalDirectories,
+        ];
+        if (creationOpts?.resume === undefined || creationOpts?.forkSession) {
+            // Set our own session id if not resuming an existing session.
+            options.sessionId = sessionId;
+        }
+        // Handle abort controller from meta options
+        if (abortController?.signal.aborted) {
+            throw new Error("Cancelled");
+        }
+        const q = query({
+            prompt: input,
+            options,
+        });
+        let initializationResult;
+        try {
+            initializationResult = await q.initializationResult();
+        }
+        catch (error) {
+            if (creationOpts.resume &&
+                error instanceof Error &&
+                (error.message === "Query closed before response received" ||
+                    error.message.includes("No conversation found with session ID"))) {
+                throw RequestError.resourceNotFound(sessionId);
+            }
+            throw error;
+        }
+        if (shouldHideClaudeAuth() &&
+            initializationResult.account.subscriptionType &&
+            !this.gatewayAuthRequest) {
+            throw RequestError.authRequired(undefined, "This integration does not support using claude.ai subscriptions.");
+        }
+        // Apply user's `availableModels` allowlist from settings.json before any
+        // downstream model handling. The SDK only enforces this allowlist in its
+        // own UI, not in `initializationResult.models`, so we filter here to keep
+        // configOptions, the current-model resolver, and the stored modelInfos
+        // consistent with what the user configured.
+        const settingsAvailableModels = settingsManager.getSettings().availableModels;
+        const allowedModels = Array.isArray(settingsAvailableModels)
+            ? applyAvailableModelsAllowlist(initializationResult.models, settingsAvailableModels)
+            : initializationResult.models;
+        const models = await getAvailableModels(q, allowedModels, initializationResult.models, settingsManager, this.logger);
+        // Gate `auto` (and future model-specific modes) on the resolved model's
+        // `ModelInfo`. See `buildAvailableModes` for the canonical SDK signal.
+        const currentModelInfo = allowedModels.find((m) => m.value === models.currentModelId);
+        const availableModes = buildAvailableModes(currentModelInfo);
+        // Clamp `permissionMode` if the resolved session does not offer it. The
+        // common case is `permissions.defaultMode: "auto"` resolving to a model
+        // that does not support auto mode (e.g. Haiku); without this clamp the
+        // SDK would later throw `"auto mode unavailable for this model"` from
+        // `setPermissionMode`. Keep `permissionMode` as the resolved user intent
+        // (matches what was passed into `options.permissionMode` above) and use
+        // `effectiveMode` for the post-clamp value the session actually runs in.
+        let effectiveMode = permissionMode;
+        if (!availableModes.some((m) => m.id === effectiveMode)) {
+            if (effectiveMode === "auto") {
+                this.logger.error(`permissions.defaultMode "auto" is not available for model ` +
+                    `"${models.currentModelId}"; falling back to "default".`);
+            }
+            else {
+                this.logger.error(`permissions.defaultMode "${effectiveMode}" is not available in ` +
+                    `this session; falling back to "default".`);
+            }
+            effectiveMode = "default";
+            // Sync the SDK so it doesn't keep "auto" cached internally. Wrapped in
+            // try/catch since failing here would abort session creation entirely.
+            try {
+                await q.setPermissionMode("default");
+            }
+            catch (err) {
+                this.logger.error("Failed to sync clamped permissionMode to SDK:", err);
+            }
+        }
+        const modes = {
+            currentModeId: effectiveMode,
+            availableModes,
+        };
+        const configOptions = buildConfigOptions(modes, models, allowedModels, settingsManager.getSettings().effortLevel);
+        // Apply the initial effort level to the SDK so it matches the UI default
+        const initialEffort = configOptions.find((o) => o.id === "effort");
+        if (initialEffort &&
+            typeof initialEffort.currentValue === "string" &&
+            initialEffort.currentValue !== "default") {
+            await q.applyFlagSettings({
+                effortLevel: initialEffort.currentValue,
+            });
+        }
+        this.sessions[sessionId] = {
+            query: q,
+            input: input,
+            cancelled: false,
+            cwd: params.cwd,
+            sessionFingerprint: computeSessionFingerprint(params),
+            settingsManager,
+            accumulatedUsage: {
+                inputTokens: 0,
+                outputTokens: 0,
+                cachedReadTokens: 0,
+                cachedWriteTokens: 0,
+            },
+            modes,
+            models,
+            modelInfos: allowedModels,
+            configOptions,
+            promptRunning: false,
+            pendingMessages: new Map(),
+            nextPendingOrder: 0,
+            abortController,
+            emitRawSDKMessages: sessionMeta?.claudeCode?.emitRawSDKMessages ?? false,
+            contextWindowSize: inferContextWindowFromModel(models.currentModelId) ?? DEFAULT_CONTEXT_WINDOW,
+            taskState,
+        };
+        return {
+            sessionId,
+            modes,
+            configOptions,
+        };
+    }
+}
+function shouldEmitRawMessage(config, message) {
+    if (config === true)
+        return true;
+    if (config === false)
+        return false;
+    return config.some((f) => f.type === message.type &&
+        (f.subtype === undefined || f.subtype === message.subtype) &&
+        (f.origin === undefined || f.origin === message.origin?.kind));
+}
+function sessionUsage(session) {
+    return {
+        inputTokens: session.accumulatedUsage.inputTokens,
+        outputTokens: session.accumulatedUsage.outputTokens,
+        cachedReadTokens: session.accumulatedUsage.cachedReadTokens,
+        cachedWriteTokens: session.accumulatedUsage.cachedWriteTokens,
+        totalTokens: session.accumulatedUsage.inputTokens +
+            session.accumulatedUsage.outputTokens +
+            session.accumulatedUsage.cachedReadTokens +
+            session.accumulatedUsage.cachedWriteTokens,
+    };
+}
+/** Sum all four fields as a proxy for post-turn context occupancy: the current
+ *  turn's output becomes next turn's input. Per the Anthropic API, input_tokens
+ *  excludes cache tokens — cache_read and cache_creation are reported
+ *  separately — so summing all four is not double-counting. */
+function totalTokens(usage) {
+    return (usage.input_tokens +
+        usage.output_tokens +
+        usage.cache_read_input_tokens +
+        usage.cache_creation_input_tokens);
+}
+/**
+ * Build the `data` payload attached to a `RequestError.internalError` when we
+ * have a categorical error from the Claude SDK. Returns `undefined` when no
+ * categorical error is available, matching the previous behavior of passing
+ * `undefined` to `RequestError.internalError`.
+ *
+ * The `errorKind` field is a convention for ACP clients to dispatch on
+ * without having to pattern-match the human-readable message text. Clients
+ * that don't understand it fall back to the existing message-based rendering.
+ */
+function errorKindData(errorKind) {
+    return errorKind ? { errorKind } : undefined;
+}
+// symphony-patch: two-level merge for per-session settings overlays. Nested
+// plain objects (e.g. permissions) merge key-wise so an overlay that only
+// sets permissions.defaultMode keeps the rest of the resolved permissions;
+// every other value replaces the base wholesale.
+function mergeSymphonySettings(base, overlay) {
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(overlay)) {
+        const baseValue = merged[key];
+        const bothPlainObjects = value !== null &&
+            typeof value === "object" &&
+            !Array.isArray(value) &&
+            baseValue !== null &&
+            typeof baseValue === "object" &&
+            !Array.isArray(baseValue);
+        merged[key] = bothPlainObjects ? { ...baseValue, ...value } : value;
+    }
+    return merged;
+}
+/** Project a nullable API usage object into our non-null snapshot shape.
+ *  Both SDK message_start and assistant message `usage` have `number | null`
+ *  cache fields; we coerce absent values to 0 so `totalTokens` never hits
+ *  NaN. `input_tokens`/`output_tokens` are typed `number` by the SDK but
+ *  synthetic or third-party-backend stream events have been observed emitting
+ *  them as null/undefined — coerce those too so a malformed upstream event
+ *  can't leak NaN into the wire `used` field. Delta events have different
+ *  semantics (cumulative + prev fallback) and are handled inline. */
+function snapshotFromUsage(usage) {
+    return {
+        input_tokens: usage.input_tokens ?? 0,
+        output_tokens: usage.output_tokens ?? 0,
+        cache_read_input_tokens: usage.cache_read_input_tokens ?? 0,
+        cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0,
+    };
+}
+function createEnvForGateway(request) {
+    if (!request?._meta) {
+        return {};
+    }
+    const customHeaders = Object.entries(request._meta.gateway.headers)
+        .map(([key, value]) => `${key}: ${value}`)
+        .join("\n");
+    if (request.methodId === "gateway-bedrock") {
+        return {
+            CLAUDE_CODE_USE_BEDROCK: "1",
+            AWS_BEARER_TOKEN_BEDROCK: " ", // Must be non-empty to bypass pass configuration check
+            ANTHROPIC_BEDROCK_BASE_URL: request._meta.gateway.baseUrl,
+            ANTHROPIC_CUSTOM_HEADERS: customHeaders,
+        };
+    }
+    return {
+        ANTHROPIC_BASE_URL: request._meta.gateway.baseUrl,
+        ANTHROPIC_CUSTOM_HEADERS: customHeaders,
+        ANTHROPIC_AUTH_TOKEN: " ", // Must be specified to bypass claude login requirement
+    };
+}
+/**
+ * Build the list of permission modes the agent will advertise for the given
+ * model. `auto` is gated by `ModelInfo.supportsAutoMode === true`, which is
+ * the SDK's model-level availability signal. `undefined`/`false` both exclude
+ * `auto`. `bypassPermissions` is still gated by `ALLOW_BYPASS`.
+ */
+function buildAvailableModes(modelInfo) {
+    const modes = [];
+    // Only advertise "auto" when the SDK reports the model supports it.
+    if (modelInfo?.supportsAutoMode === true) {
+        modes.push({
+            id: "auto",
+            name: "Auto",
+            description: "Use a model classifier to approve/deny permission prompts",
+        });
+    }
+    modes.push({
+        id: "default",
+        name: "Default",
+        description: "Standard behavior, prompts for dangerous operations",
+    }, {
+        id: "acceptEdits",
+        name: "Accept Edits",
+        description: "Auto-accept file edit operations",
+    }, {
+        id: "plan",
+        name: "Plan Mode",
+        description: "Planning mode, no actual tool execution",
+    }, {
+        id: "dontAsk",
+        name: "Don't Ask",
+        description: "Don't prompt for permissions, deny if not pre-approved",
+    });
+    if (ALLOW_BYPASS) {
+        modes.push({
+            id: "bypassPermissions",
+            name: "Bypass Permissions",
+            description: "Bypass all permission checks",
+        });
+    }
+    return modes;
+}
+// Translate a UI effort value into the flag-layer payload. The SDK
+// shallow-merges `applyFlagSettings`, drops `undefined` during JSON transport,
+// and only clears a key when an explicit `null` is sent — see
+// `applyFlagSettings` in @anthropic-ai/claude-agent-sdk. Mapping both the
+// `"default"` sentinel and `undefined` (effort option absent for the model) to
+// `null` ensures any previously-applied flag is actually cleared.
+function toSdkEffortLevel(value) {
+    return value === undefined || value === "default" ? null : value;
+}
+function buildConfigOptions(modes, models, modelInfos, currentEffortLevel) {
+    const options = [
+        {
+            id: "mode",
+            name: "Mode",
+            description: "Session permission mode",
+            category: "mode",
+            type: "select",
+            currentValue: modes.currentModeId,
+            options: modes.availableModes.map((m) => ({
+                value: m.id,
+                name: m.name,
+                description: m.description,
+            })),
+        },
+        {
+            id: "model",
+            name: "Model",
+            description: "AI model to use",
+            category: "model",
+            type: "select",
+            currentValue: models.currentModelId,
+            options: models.availableModels.map((m) => ({
+                value: m.modelId,
+                name: m.name,
+                description: m.description ?? undefined,
+            })),
+        },
+    ];
+    // Add effort level option based on the currently selected model
+    const currentModelInfo = modelInfos.find((m) => m.value === models.currentModelId);
+    const supportedLevels = currentModelInfo?.supportsEffort
+        ? (currentModelInfo.supportedEffortLevels ?? [])
+        : [];
+    if (supportedLevels.length > 0) {
+        const effortOptions = [
+            { value: "default", name: "Default" },
+            ...supportedLevels.map((level) => ({
+                value: level,
+                name: level
+                    .split(/[_-]/)
+                    .map((part) => (part ? part.charAt(0).toUpperCase() + part.slice(1) : part))
+                    .join(" "),
+            })),
+        ];
+        const includes = (l) => l === "default" || supportedLevels.includes(l);
+        const validEffort = currentEffortLevel && includes(currentEffortLevel) ? currentEffortLevel : "default";
+        options.push({
+            id: "effort",
+            name: "Effort",
+            description: "Available effort levels for this model",
+            category: "thought_level",
+            type: "select",
+            currentValue: validEffort,
+            options: effortOptions,
+        });
+    }
+    return options;
+}
+// Claude Code CLI persists display strings like "opus[1m]" in settings,
+// but the SDK model list uses IDs like "claude-opus-4-6-1m".
+const MODEL_CONTEXT_HINT_PATTERN = /\[(\d+m)\]$/i;
+// Captures a model family version such as `4-6` or `4.7` so we can keep
+// `claude-opus-4-6` from being copied onto the SDK's `opus` alias when that
+// alias currently resolves to a different family version (e.g. Opus 4.7).
+const MODEL_FAMILY_VERSION_PATTERN = /\b(\d+)[-.](\d+)\b/;
+function extractModelFamilyVersion(s) {
+    const match = s.match(MODEL_FAMILY_VERSION_PATTERN);
+    return match ? `${match[1]}.${match[2]}` : null;
+}
+function modelVersionsCompatible(preference, candidate) {
+    const preferred = extractModelFamilyVersion(preference);
+    if (!preferred)
+        return true;
+    const candidateVersion = extractModelFamilyVersion(candidate.value) ??
+        extractModelFamilyVersion(candidate.displayName) ??
+        extractModelFamilyVersion(candidate.description);
+    if (!candidateVersion)
+        return true;
+    return preferred === candidateVersion;
+}
+function tokenizeModelPreference(model) {
+    const lower = model.trim().toLowerCase();
+    const contextHint = lower.match(MODEL_CONTEXT_HINT_PATTERN)?.[1]?.toLowerCase();
+    const normalized = lower.replace(MODEL_CONTEXT_HINT_PATTERN, " $1 ");
+    const rawTokens = normalized.split(/[^a-z0-9]+/).filter(Boolean);
+    const tokens = rawTokens
+        .map((token) => {
+        if (token === "opusplan")
+            return "opus";
+        if (token === "best" || token === "default")
+            return "";
+        return token;
+    })
+        .filter((token) => token && token !== "claude")
+        .filter((token) => /[a-z]/.test(token) || token.endsWith("m"));
+    return { tokens, contextHint };
+}
+function scoreModelMatch(model, tokens, contextHint) {
+    const haystack = `${model.value} ${model.displayName}`.toLowerCase();
+    let score = 0;
+    for (const token of tokens) {
+        if (haystack.includes(token)) {
+            score += token === contextHint ? 3 : 1;
+        }
+    }
+    return score;
+}
+function resolveModelPreference(models, preference) {
+    const trimmed = preference.trim();
+    if (!trimmed)
+        return null;
+    const lower = trimmed.toLowerCase();
+    // Exact match on value or display name
+    const directMatch = models.find((model) => model.value === trimmed ||
+        model.value.toLowerCase() === lower ||
+        model.displayName.toLowerCase() === lower);
+    if (directMatch)
+        return directMatch;
+    // Substring match
+    const includesMatch = models.find((model) => {
+        if (!modelVersionsCompatible(trimmed, model))
+            return false;
+        const value = model.value.toLowerCase();
+        const display = model.displayName.toLowerCase();
+        return value.includes(lower) || display.includes(lower) || lower.includes(value);
+    });
+    if (includesMatch)
+        return includesMatch;
+    // Tokenized matching for aliases like "opus[1m]"
+    const { tokens, contextHint } = tokenizeModelPreference(trimmed);
+    if (tokens.length === 0)
+        return null;
+    let bestMatch = null;
+    let bestScore = 0;
+    for (const model of models) {
+        if (!modelVersionsCompatible(trimmed, model))
+            continue;
+        const score = scoreModelMatch(model, tokens, contextHint);
+        if (0 < score && (!bestMatch || bestScore < score)) {
+            bestMatch = model;
+            bestScore = score;
+        }
+    }
+    return bestMatch;
+}
+function resolveSettingsModel(models, settingsModel, logger) {
+    if (settingsModel === undefined) {
+        return null;
+    }
+    if (typeof settingsModel !== "string") {
+        const typeLabel = settingsModel === null ? "null" : typeof settingsModel;
+        logger.error(`Ignoring model from settings: expected a string, got ${typeLabel}.`);
+        return null;
+    }
+    return resolveModelPreference(models, settingsModel);
+}
+/**
+ * Restrict the SDK's model list to the user's `availableModels` allowlist
+ * (already merged-and-deduped across settings sources by `SettingsManager`).
+ * The user's exact entries become the model IDs surfaced via configOptions
+ * and passed to `setModel`, which prevents Claude Code from silently
+ * substituting a date-pinned variant (e.g. `haiku` →
+ * `claude-haiku-4-5-20251001`) that the user may not have access to.
+ *
+ * Display info and capability flags are copied from the closest SDK match so
+ * the UI still renders sensible names and effort levels.
+ *
+ * Semantics from https://code.claude.com/docs/en/model-config#restrict-model-selection:
+ * - `undefined` is handled by the caller (no allowlist applied).
+ * - The Default option is unaffected by `availableModels` — it always remains
+ *   available, even when the allowlist is `[]`.
+ */
+function applyAvailableModelsAllowlist(sdkModels, allowlist) {
+    // Default is always preserved per the docs. Synthesize one if the SDK
+    // didn't surface it so downstream code (e.g. `getAvailableModels` picking
+    // `models[0]` as a fallback) still has something to work with.
+    const defaultModel = sdkModels.find((m) => m.value === "default") ?? {
+        value: "default",
+        displayName: "Default",
+        description: "",
+    };
+    const result = [defaultModel];
+    const seen = new Set([defaultModel.value]);
+    const sdkModelsWithoutDefault = sdkModels.filter((m) => m.value !== "default");
+    for (const entry of allowlist) {
+        const trimmed = entry.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        const sdkMatch = resolveModelPreference(sdkModelsWithoutDefault, trimmed);
+        if (sdkMatch) {
+            result.push({ ...sdkMatch, value: trimmed });
+        }
+        else {
+            result.push({ value: trimmed, displayName: trimmed, description: "" });
+        }
+        seen.add(trimmed);
+    }
+    return result;
+}
+async function getAvailableModels(query, models, sdkModels, settingsManager, logger) {
+    const settings = settingsManager.getSettings();
+    let currentModel = models[0];
+    let resolvedFromInput;
+    // Model priority (highest to lowest):
+    // 1. ANTHROPIC_MODEL environment variable
+    // 2. settings.model (user configuration)
+    // 3. models[0] (default first model)
+    if (process.env.ANTHROPIC_MODEL) {
+        const match = resolveModelPreference(models, process.env.ANTHROPIC_MODEL);
+        if (match) {
+            currentModel = match;
+            resolvedFromInput = process.env.ANTHROPIC_MODEL;
+        }
+    }
+    else if (typeof settings.model === "string") {
+        const match = resolveSettingsModel(models, settings.model, logger);
+        if (match) {
+            currentModel = match;
+            resolvedFromInput = settings.model;
+        }
+    }
+    // Skip the setModel round-trip when we can prove the SDK has already landed
+    // on the same model. Two cases qualify:
+    //  (a) No override applied — currentModel stayed at models[0]; the SDK is on
+    //      its own default and we have nothing to sync.
+    //  (b) The resolver returned the user's input verbatim AND that value exists
+    //      in the SDK's original model list — meaning no fuzzy match or
+    //      allowlist rewrite was involved, and the SDK (which reads the same
+    //      ANTHROPIC_MODEL / settings.json) will have arrived at the same entry.
+    // Anything else (fuzzy match, allowlist-synthesized value, alias) gets a
+    // setModel call so we don't drift from the user's intended pin.
+    const sdkSawSameValue = sdkModels.some((m) => m.value === currentModel.value);
+    const skipSetModel = resolvedFromInput === undefined ||
+        (currentModel.value === resolvedFromInput && sdkSawSameValue);
+    if (!skipSetModel) {
+        await query.setModel(currentModel.value);
+    }
+    return {
+        availableModels: models.map((model) => ({
+            modelId: model.value,
+            name: model.displayName,
+            description: model.description,
+        })),
+        currentModelId: currentModel.value,
+    };
+}
+function getAvailableSlashCommands(commands) {
+    const UNSUPPORTED_COMMANDS = [
+        "clear",
+        "cost",
+        "keybindings-help",
+        "login",
+        "logout",
+        "output-style:new",
+        "release-notes",
+        "todos",
+    ];
+    return commands
+        .map((command) => {
+        const input = command.argumentHint
+            ? {
+                hint: Array.isArray(command.argumentHint)
+                    ? command.argumentHint.join(" ")
+                    : command.argumentHint,
+            }
+            : null;
+        let name = command.name;
+        if (command.name.endsWith(" (MCP)")) {
+            name = `mcp:${name.replace(" (MCP)", "")}`;
+        }
+        return {
+            name,
+            description: command.description || "",
+            input,
+        };
+    })
+        .filter((command) => !UNSUPPORTED_COMMANDS.includes(command.name));
+}
+function formatUriAsLink(uri) {
+    try {
+        if (uri.startsWith("file://")) {
+            const path = uri.slice(7); // Remove "file://"
+            const name = path.split("/").pop() || path;
+            return `[@${name}](${uri})`;
+        }
+        else if (uri.startsWith("zed://")) {
+            const parts = uri.split("/");
+            const name = parts[parts.length - 1] || uri;
+            return `[@${name}](${uri})`;
+        }
+        return uri;
+    }
+    catch {
+        return uri;
+    }
+}
+export function promptToClaude(prompt) {
+    const content = [];
+    const context = [];
+    for (const chunk of prompt.prompt) {
+        switch (chunk.type) {
+            case "text": {
+                let text = chunk.text;
+                // change /mcp:server:command args -> /server:command (MCP) args
+                const mcpMatch = text.match(/^\/mcp:([^:\s]+):(\S+)(?:\s(.*))?$/);
+                if (mcpMatch) {
+                    const [, server, command, args] = mcpMatch;
+                    text = `/${server}:${command} (MCP)${args ? ` ${args}` : ""}`;
+                }
+                content.push({ type: "text", text });
+                break;
+            }
+            case "resource_link": {
+                const formattedUri = formatUriAsLink(chunk.uri);
+                content.push({
+                    type: "text",
+                    text: formattedUri,
+                });
+                break;
+            }
+            case "resource": {
+                if ("text" in chunk.resource) {
+                    const formattedUri = formatUriAsLink(chunk.resource.uri);
+                    content.push({
+                        type: "text",
+                        text: formattedUri,
+                    });
+                    context.push({
+                        type: "text",
+                        text: `\n<context ref="${chunk.resource.uri}">\n${chunk.resource.text}\n</context>`,
+                    });
+                }
+                // Ignore blob resources (unsupported)
+                break;
+            }
+            case "image":
+                if (chunk.data) {
+                    content.push({
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            data: chunk.data,
+                            media_type: chunk.mimeType,
+                        },
+                    });
+                }
+                else if (chunk.uri && chunk.uri.startsWith("http")) {
+                    content.push({
+                        type: "image",
+                        source: {
+                            type: "url",
+                            url: chunk.uri,
+                        },
+                    });
+                }
+                break;
+            // Ignore audio and other unsupported types
+            default:
+                break;
+        }
+    }
+    content.push(...context);
+    return {
+        type: "user",
+        message: {
+            role: "user",
+            content: content,
+        },
+        session_id: prompt.sessionId,
+        parent_tool_use_id: null,
+    };
+}
+/**
+ * Convert an SDKAssistantMessage (Claude) to a SessionNotification (ACP).
+ * Only handles text, image, and thinking chunks for now.
+ */
+export function toAcpNotifications(content, role, sessionId, toolUseCache, client, logger, options) {
+    const taskState = options?.taskState ?? new Map();
+    const registerHooks = options?.registerHooks !== false;
+    const supportsTerminalOutput = options?.clientCapabilities?._meta?.["terminal_output"] === true;
+    if (typeof content === "string") {
+        const update = {
+            sessionUpdate: role === "assistant" ? "agent_message_chunk" : "user_message_chunk",
+            content: {
+                type: "text",
+                text: content,
+            },
+        };
+        if (options?.parentToolUseId) {
+            update._meta = {
+                ...update._meta,
+                claudeCode: {
+                    ...(update._meta?.claudeCode || {}),
+                    parentToolUseId: options.parentToolUseId,
+                },
+            };
+        }
+        return [{ sessionId, update }];
+    }
+    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": {
+                const alreadyCached = chunk.id in toolUseCache;
+                toolUseCache[chunk.id] = chunk;
+                if (chunk.name === "TodoWrite") {
+                    // @ts-expect-error - sometimes input is empty object or undefined
+                    if (Array.isArray(chunk.input?.todos)) {
+                        update = {
+                            sessionUpdate: "plan",
+                            entries: planEntries(chunk.input),
+                        };
+                    }
+                }
+                else if (chunk.name === "TaskCreate" ||
+                    chunk.name === "TaskUpdate" ||
+                    chunk.name === "TaskList" ||
+                    chunk.name === "TaskGet") {
+                    // Task* tool_use is suppressed; the plan update is emitted at
+                    // tool_result time once we have the task ID (for TaskCreate) and
+                    // confirmation that the change took effect.
+                }
+                else {
+                    // Only register hooks on first encounter to avoid double-firing
+                    if (registerHooks && !alreadyCached) {
+                        registerHookCallback(chunk.id, {
+                            onPostToolUseHook: async (toolUseId, toolInput, toolResponse) => {
+                                const toolUse = toolUseCache[toolUseId];
+                                if (toolUse) {
+                                    // Both `Edit` and `Write` produce a structuredPatch in their
+                                    // PostToolUse tool_response. For Edit the diff replaces the
+                                    // optimistic content built at tool_use time. For Write the
+                                    // optimistic content (built from `input.content` alone with
+                                    // `oldText: null`) shows "creation" semantics regardless of
+                                    // whether the file existed; the structuredPatch from the
+                                    // hook lets us emit the real diff for `type: "update"`. The
+                                    // helper returns `{}` if the response shape isn't usable.
+                                    const editDiff = toolUse.name === "Edit" || toolUse.name === "Write"
+                                        ? toolUpdateFromDiffToolResponse(toolResponse)
+                                        : {};
+                                    const update = {
+                                        _meta: {
+                                            claudeCode: {
+                                                toolResponse,
+                                                toolName: toolUse.name,
+                                            },
+                                        },
+                                        toolCallId: toolUseId,
+                                        sessionUpdate: "tool_call_update",
+                                        ...editDiff,
+                                    };
+                                    await client.sessionUpdate({
+                                        sessionId,
+                                        update,
+                                    });
+                                }
+                                else {
+                                    logger.error(`[claude-agent-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
+                    }
+                    if (alreadyCached) {
+                        // Second encounter (full assistant message after streaming) —
+                        // send as tool_call_update to refine the existing tool_call
+                        // rather than emitting a duplicate tool_call.
+                        update = {
+                            _meta: {
+                                claudeCode: {
+                                    toolName: chunk.name,
+                                },
+                            },
+                            toolCallId: chunk.id,
+                            sessionUpdate: "tool_call_update",
+                            rawInput,
+                            ...toolInfoFromToolUse(chunk, supportsTerminalOutput, options?.cwd),
+                        };
+                    }
+                    else {
+                        // First encounter (streaming content_block_start or replay) —
+                        // send as tool_call with terminal_info for Bash tools.
+                        update = {
+                            _meta: {
+                                claudeCode: {
+                                    toolName: chunk.name,
+                                },
+                                ...(chunk.name === "Bash" && supportsTerminalOutput
+                                    ? { terminal_info: { terminal_id: chunk.id } }
+                                    : {}),
+                            },
+                            toolCallId: chunk.id,
+                            sessionUpdate: "tool_call",
+                            rawInput,
+                            status: "pending",
+                            ...toolInfoFromToolUse(chunk, supportsTerminalOutput, options?.cwd),
+                        };
+                    }
+                }
+                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-agent-acp] Got a tool result for tool use that wasn't tracked: ${chunk.tool_use_id}`);
+                    break;
+                }
+                if (toolUse.name === "TaskCreate" ||
+                    toolUse.name === "TaskUpdate" ||
+                    toolUse.name === "TaskList" ||
+                    toolUse.name === "TaskGet") {
+                    // Headless/SDK sessions emit Task* tools instead of TodoWrite.
+                    // TaskCreate / TaskUpdate mutate the accumulated task list; TaskList
+                    // and TaskGet are read-only so we just suppress their tool_call /
+                    // tool_result events. The plan update is emitted as a snapshot of
+                    // the accumulated state, mirroring the legacy TodoWrite behavior.
+                    const isError = "is_error" in chunk && chunk.is_error;
+                    if (!isError) {
+                        if (toolUse.name === "TaskCreate") {
+                            applyTaskCreate(taskState, toolUse.input, parseTaskCreateOutput(chunk.content));
+                        }
+                        else if (toolUse.name === "TaskUpdate") {
+                            applyTaskUpdate(taskState, toolUse.input);
+                        }
+                    }
+                    if (!isError && (toolUse.name === "TaskCreate" || toolUse.name === "TaskUpdate")) {
+                        update = {
+                            sessionUpdate: "plan",
+                            entries: taskStateToPlanEntries(taskState),
+                        };
+                    }
+                }
+                else if (toolUse.name !== "TodoWrite") {
+                    const { _meta: toolMeta, ...toolUpdate } = toolUpdateFromToolResult(chunk, toolUseCache[chunk.tool_use_id], supportsTerminalOutput);
+                    // When terminal output is supported, send terminal_output as a
+                    // separate notification to match codex-acp's streaming lifecycle:
+                    //   1. tool_call       → _meta.terminal_info  (already sent above)
+                    //   2. tool_call_update → _meta.terminal_output (sent here)
+                    //   3. tool_call_update → _meta.terminal_exit  (sent below with status)
+                    if (toolMeta?.terminal_output) {
+                        output.push({
+                            sessionId,
+                            update: {
+                                _meta: {
+                                    terminal_output: toolMeta.terminal_output,
+                                    ...(options?.parentToolUseId
+                                        ? { claudeCode: { parentToolUseId: options.parentToolUseId } }
+                                        : {}),
+                                },
+                                toolCallId: chunk.tool_use_id,
+                                sessionUpdate: "tool_call_update",
+                            },
+                        });
+                    }
+                    update = {
+                        _meta: {
+                            claudeCode: {
+                                toolName: toolUse.name,
+                            },
+                            ...(toolMeta?.terminal_exit ? { terminal_exit: toolMeta.terminal_exit } : {}),
+                        },
+                        toolCallId: chunk.tool_use_id,
+                        sessionUpdate: "tool_call_update",
+                        status: "is_error" in chunk && chunk.is_error ? "failed" : "completed",
+                        rawOutput: chunk.content,
+                        ...toolUpdate,
+                    };
+                }
+                break;
+            }
+            case "document":
+            case "search_result":
+            case "redacted_thinking":
+            case "input_json_delta":
+            case "citations_delta":
+            case "signature_delta":
+            case "container_upload":
+            case "compaction":
+            case "compaction_delta":
+            case "advisor_tool_result":
+            case "mid_conv_system":
+                break;
+            default:
+                unreachable(chunk, logger);
+                break;
+        }
+        if (update) {
+            if (options?.parentToolUseId) {
+                update._meta = {
+                    ...update._meta,
+                    claudeCode: {
+                        ...(update._meta?.claudeCode || {}),
+                        parentToolUseId: options.parentToolUseId,
+                    },
+                };
+            }
+            output.push({ sessionId, update });
+        }
+    }
+    return output;
+}
+export function streamEventToAcpNotifications(message, sessionId, toolUseCache, client, logger, options) {
+    const event = message.event;
+    switch (event.type) {
+        case "content_block_start":
+            return toAcpNotifications([event.content_block], "assistant", sessionId, toolUseCache, client, logger, {
+                clientCapabilities: options?.clientCapabilities,
+                parentToolUseId: message.parent_tool_use_id,
+                cwd: options?.cwd,
+                taskState: options?.taskState,
+            });
+        case "content_block_delta":
+            return toAcpNotifications([event.delta], "assistant", sessionId, toolUseCache, client, logger, {
+                clientCapabilities: options?.clientCapabilities,
+                parentToolUseId: message.parent_tool_use_id,
+                cwd: options?.cwd,
+                taskState: options?.taskState,
+            });
+        // No content. `ping` is a Messages-API keep-alive event that the SDK's
+        // `BetaRawMessageStreamEvent` union doesn't include even though the
+        // wire format emits it; the `as never` cast lets us no-op it here
+        // instead of letting it fall through to `unreachable`.
+        case "ping":
+        case "message_start":
+        case "message_delta":
+        case "message_stop":
+        case "content_block_stop":
+            return [];
+        default:
+            unreachable(event, logger);
+            return [];
+    }
+}
+export function runAcp() {
+    const input = nodeToWebWritable(process.stdout);
+    const output = nodeToWebReadable(process.stdin);
+    const stream = ndJsonStream(input, output);
+    let agent;
+    const connection = new AgentSideConnection((client) => {
+        agent = new ClaudeAcpAgent(client);
+        return agent;
+    }, stream);
+    return { connection, agent };
+}
+function commonPrefixLength(a, b) {
+    let i = 0;
+    while (i < a.length && i < b.length && a[i] === b[i]) {
+        i++;
+    }
+    return i;
+}
+/** Best-effort first guess of a model's context window from its ID, used only
+ *  until a `result` message arrives with the authoritative `modelUsage` value.
+ *  Anthropic 1M-context variants encode "1m" as a distinct token in the SDK
+ *  model ID (e.g., "claude-opus-4-6-1m"), which `\b1m\b` catches without also
+ *  matching things like "10m" or embedded substrings. */
+function inferContextWindowFromModel(model) {
+    if (/\b1m\b/i.test(model))
+        return 1_000_000;
+    return null;
+}
+function parseModelConfig(raw) {
+    if (!raw)
+        return undefined;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("CLAUDE_MODEL_CONFIG must be a JSON object");
+    }
+    const result = {};
+    if (parsed.modelOverrides !== undefined)
+        result.modelOverrides = parsed.modelOverrides;
+    if (parsed.availableModels !== undefined)
+        result.availableModels = parsed.availableModels;
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function getMatchingModelUsage(modelUsage, currentModel) {
+    let bestKey = null;
+    let bestLen = 0;
+    for (const key of Object.keys(modelUsage)) {
+        const len = commonPrefixLength(key, currentModel);
+        if (len > bestLen) {
+            bestLen = len;
+            bestKey = key;
+        }
+    }
+    if (bestKey) {
+        return modelUsage[bestKey];
+    }
+}