wave-code 0.19.2 → 0.19.3

package/dist/acp/agent.js

@@ -1,1163 +0,0 @@
-import { Agent as WaveAgent, listSessions as listWaveSessions, listAllSessions as listAllWaveSessions, deleteSession as deleteWaveSession, truncateContent, BASH_TOOL_NAME, EDIT_TOOL_NAME, WRITE_TOOL_NAME, EXIT_PLAN_MODE_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "wave-agent-sdk";
-import { logger } from "../utils/logger.js";
-import { AGENT_METHODS, } from "@agentclientprotocol/sdk";
-export class WaveAcpAgent {
-    constructor(connection) {
-        this.agents = new Map();
-        this.taskCache = new Map();
-        this.connection = connection;
-    }
-    getSessionModeState(agent) {
-        return {
-            currentModeId: agent.getPermissionMode(),
-            availableModes: [
-                {
-                    id: "default",
-                    name: "Default",
-                    description: "Ask for permission for restricted tools",
-                },
-                {
-                    id: "acceptEdits",
-                    name: "Accept Edits",
-                    description: "Automatically accept file edits",
-                },
-                {
-                    id: "plan",
-                    name: "Plan",
-                    description: "Plan mode for complex tasks",
-                },
-                {
-                    id: "bypassPermissions",
-                    name: "Bypass Permissions",
-                    description: "Automatically accept all tool calls",
-                },
-                {
-                    id: "dontAsk",
-                    name: "Don't Ask",
-                    description: "Automatically deny restricted tools unless pre-approved",
-                },
-            ],
-        };
-    }
-    getSessionConfigOptions(agent) {
-        const configuredModels = agent.getConfiguredModels();
-        const currentModel = agent.getModelConfig().model || "";
-        return [
-            {
-                id: "permission_mode",
-                name: "Permission Mode",
-                description: "Controls how the agent requests permission",
-                type: "select",
-                category: "mode",
-                currentValue: agent.getPermissionMode(),
-                options: [
-                    { value: "default", name: "Default" },
-                    { value: "acceptEdits", name: "Accept Edits" },
-                    { value: "plan", name: "Plan" },
-                    { value: "bypassPermissions", name: "Bypass Permissions" },
-                    { value: "dontAsk", name: "Don't Ask" },
-                ],
-            },
-            {
-                id: "model",
-                name: "Model",
-                description: "The AI model to use for this session",
-                type: "select",
-                category: "model",
-                currentValue: currentModel,
-                options: configuredModels.map((m) => ({
-                    value: m,
-                    name: m,
-                })),
-            },
-        ];
-    }
-    async cleanupAllAgents() {
-        logger.info("Cleaning up all active agents due to connection closure");
-        const destroyPromises = Array.from(this.agents.values()).map((agent) => agent.destroy());
-        await Promise.all(destroyPromises);
-        this.agents.clear();
-    }
-    async initialize() {
-        logger.info("Initializing WaveAcpAgent");
-        // Setup cleanup on connection closure
-        this.connection.closed.then(() => this.cleanupAllAgents());
-        return {
-            protocolVersion: 1,
-            agentInfo: {
-                name: "wave-agent",
-                version: "0.1.0",
-            },
-            agentCapabilities: {
-                loadSession: true,
-                mcpCapabilities: { http: true, sse: true },
-                sessionCapabilities: {
-                    list: {},
-                    close: {},
-                },
-                promptCapabilities: {
-                    image: true,
-                    embeddedContext: true,
-                },
-            },
-        };
-    }
-    async authenticate() {
-        // No authentication required for now
-    }
-    async createAgent(sessionId, cwd, mcpServers) {
-        const callbacks = {};
-        const agentRef = {};
-        const sdkMcpServers = mcpServers
-            ? convertAcpMcpServers(mcpServers)
-            : undefined;
-        const agent = await WaveAgent.create({
-            workdir: cwd,
-            restoreSessionId: sessionId,
-            stream: true,
-            mcpServers: sdkMcpServers,
-            canUseTool: (context) => {
-                if (!agentRef.instance) {
-                    throw new Error("Agent instance not yet initialized");
-                }
-                return this.handlePermissionRequest(agentRef.instance.sessionId, context);
-            },
-            callbacks: {
-                onAssistantContentUpdated: (params) => callbacks.onAssistantContentUpdated?.(params),
-                onAssistantReasoningUpdated: (params) => callbacks.onAssistantReasoningUpdated?.(params),
-                onToolBlockUpdated: (params) => {
-                    const cb = callbacks.onToolBlockUpdated;
-                    cb?.(params);
-                },
-                onTasksChange: (tasks) => callbacks.onTasksChange?.(tasks),
-                onPermissionModeChange: (mode) => callbacks.onPermissionModeChange?.(mode),
-                onModelChange: (model) => callbacks.onModelChange?.(model),
-                onUserMessageAdded: (params) => callbacks.onUserMessageAdded?.(params),
-                onMcpServersChange: (servers) => callbacks.onMcpServersChange?.(servers),
-                onSessionIdChange: (newSessionId) => callbacks.onSessionIdChange?.(newSessionId),
-                onLatestTotalTokensChange: (tokens) => callbacks.onLatestTotalTokensChange?.(tokens),
-                onLoadingChange: (loading) => callbacks.onLoadingChange?.(loading),
-            },
-        });
-        agentRef.instance = agent;
-        const actualSessionId = agent.sessionId;
-        this.agents.set(actualSessionId, agent);
-        // Update the callbacks object with the correct sessionId
-        const { callbacks: cb } = this.createCallbacks(actualSessionId);
-        Object.assign(callbacks, cb);
-        // Send initial available commands after agent creation
-        // Use setImmediate to ensure the client receives the session response before the update
-        setImmediate(() => {
-            this.connection.sessionUpdate({
-                sessionId: actualSessionId,
-                update: {
-                    sessionUpdate: "available_commands_update",
-                    availableCommands: agent.getSlashCommands().map((cmd) => ({
-                        name: cmd.name,
-                        description: cmd.description,
-                        input: {
-                            hint: "Enter arguments...",
-                        },
-                    })),
-                },
-            });
-        });
-        return agent;
-    }
-    async newSession(params) {
-        const { cwd, mcpServers } = params;
-        logger.info(`Creating new session in ${cwd}`);
-        const agent = await this.createAgent(undefined, cwd, mcpServers);
-        logger.info(`New session created with ID: ${agent.sessionId}`);
-        return {
-            sessionId: agent.sessionId,
-            modes: this.getSessionModeState(agent),
-            configOptions: this.getSessionConfigOptions(agent),
-        };
-    }
-    async loadSession(params) {
-        const { sessionId, cwd, mcpServers } = params;
-        logger.info(`Loading session: ${sessionId} in ${cwd}`);
-        const agent = await this.createAgent(sessionId, cwd, mcpServers);
-        // Replay conversation history via session/update notifications per ACP spec
-        await this.replayConversationHistory(agent);
-        return {
-            modes: this.getSessionModeState(agent),
-            configOptions: this.getSessionConfigOptions(agent),
-        };
-    }
-    async listSessions(params) {
-        const { cwd } = params;
-        logger.info(`listSessions called with params: ${JSON.stringify(params)}`);
-        let waveSessions;
-        if (!cwd) {
-            logger.info("listSessions called without cwd, listing all sessions");
-            waveSessions = await listAllWaveSessions();
-        }
-        else {
-            logger.info(`Listing sessions for ${cwd}`);
-            waveSessions = await listWaveSessions(cwd);
-        }
-        logger.info(`Found ${waveSessions.length} sessions`);
-        const sessions = waveSessions.map((meta) => ({
-            sessionId: meta.id,
-            cwd: meta.workdir,
-            title: meta.firstMessage ? truncateContent(meta.firstMessage) : undefined,
-            updatedAt: meta.lastActiveAt.toISOString(),
-        }));
-        return { sessions };
-    }
-    async unstable_closeSession(params) {
-        const sessionId = params.sessionId;
-        logger.info(`Stopping session ${sessionId}`);
-        const agent = this.agents.get(sessionId);
-        if (agent) {
-            const workdir = agent.workingDirectory;
-            await agent.destroy();
-            this.agents.delete(sessionId);
-            // Delete the session file so it doesn't show up in listSessions
-            await deleteWaveSession(sessionId, workdir);
-        }
-        return {};
-    }
-    async extMethod(method, params) {
-        if (method === AGENT_METHODS.session_close) {
-            return this.unstable_closeSession(params);
-        }
-        throw new Error(`Method ${method} not implemented`);
-    }
-    async setSessionMode(params) {
-        const { sessionId, modeId } = params;
-        const agent = this.agents.get(sessionId);
-        if (!agent)
-            throw new Error(`Session ${sessionId} not found`);
-        agent.setPermissionMode(modeId);
-    }
-    async setSessionConfigOption(params) {
-        const { sessionId, configId, value } = params;
-        const agent = this.agents.get(sessionId);
-        if (!agent)
-            throw new Error(`Session ${sessionId} not found`);
-        if (configId === "permission_mode") {
-            agent.setPermissionMode(value);
-        }
-        else if (configId === "model" && typeof value === "string") {
-            agent.setModel(value);
-        }
-        return {
-            configOptions: this.getSessionConfigOptions(agent),
-        };
-    }
-    async prompt(params) {
-        const { sessionId, prompt, messageId } = params;
-        logger.info(`Received prompt for session ${sessionId}`);
-        logger.debug(`Prompt content for session ${sessionId}:`, prompt);
-        const agent = this.agents.get(sessionId);
-        if (!agent) {
-            logger.error(`Session ${sessionId} not found`);
-            throw new Error(`Session ${sessionId} not found`);
-        }
-        // Map ACP prompt to Wave Agent sendMessage
-        const textBlocks = [];
-        const images = [];
-        for (const block of prompt) {
-            if (block.type === "text") {
-                textBlocks.push(block.text);
-            }
-            else if (block.type === "resource_link") {
-                const link = block;
-                textBlocks.push(`[${link.name}](${link.uri})`);
-            }
-            else if (block.type === "resource") {
-                const embedded = block;
-                textBlocks.push(`[Resource](${embedded.resource.uri})`);
-            }
-            else if (block.type === "image") {
-                const img = block;
-                images.push({
-                    path: img.data.startsWith("data:")
-                        ? img.data
-                        : `data:${img.mimeType};base64,${img.data}`,
-                    mimeType: img.mimeType,
-                });
-            }
-        }
-        const textContent = textBlocks.join("\n");
-        const usagesBefore = agent.usages.length;
-        try {
-            await agent.sendMessage(textContent, images.length > 0 ? images : undefined);
-            logger.info(`Message sent successfully for session ${sessionId}`);
-            return {
-                stopReason: "end_turn",
-                ...mapTurnUsage(agent.usages.slice(usagesBefore)),
-                ...(messageId ? { userMessageId: messageId } : {}),
-            };
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes("abort")) {
-                logger.info(`Message aborted for session ${sessionId}`);
-                return {
-                    stopReason: "cancelled",
-                    ...mapTurnUsage(agent.usages.slice(usagesBefore)),
-                    ...(messageId ? { userMessageId: messageId } : {}),
-                };
-            }
-            logger.error(`Error sending message for session ${sessionId}:`, error);
-            throw error;
-        }
-    }
-    async cancel(params) {
-        const { sessionId } = params;
-        logger.info(`Cancelling message for session ${sessionId}`);
-        const agent = this.agents.get(sessionId);
-        if (agent) {
-            agent.abortMessage();
-        }
-    }
-    getAllowAlwaysName(context) {
-        if (context.toolName === BASH_TOOL_NAME) {
-            const command = context.toolInput?.command || "";
-            if (command.startsWith("mkdir")) {
-                return "Yes, and auto-accept edits";
-            }
-            if (context.suggestedPrefix) {
-                const prefix = context.suggestedPrefix.length > 12
-                    ? context.suggestedPrefix.substring(0, 9) + "..."
-                    : context.suggestedPrefix;
-                return `Yes, always allow ${prefix}`;
-            }
-            return "Yes, always allow this command";
-        }
-        if (context.toolName === EDIT_TOOL_NAME ||
-            context.toolName === WRITE_TOOL_NAME) {
-            return "Yes, and auto-accept edits";
-        }
-        if (context.toolName === EXIT_PLAN_MODE_TOOL_NAME) {
-            return "Yes, auto-accept edits";
-        }
-        return "Allow Always";
-    }
-    async handleAskQuestion(sessionId, toolCallId, context) {
-        try {
-            const questions = context.toolInput?.questions || [];
-            const request = {
-                toolCallId,
-                title: questions.length === 1 ? questions[0].header : undefined,
-                questions: questions.map((q, qi) => ({
-                    id: `q${qi}`,
-                    prompt: q.question,
-                    options: q.options.map((opt, oi) => ({
-                        id: String(oi),
-                        label: opt.label,
-                        description: opt.description,
-                    })),
-                    allowMultiple: q.multiSelect,
-                })),
-            };
-            const response = await this.connection.extMethod("wave/ask_question", request);
-            const outcome = response.outcome;
-            if (outcome === "cancelled") {
-                return { behavior: "deny", message: "Cancelled by user" };
-            }
-            // outcome === "answered"
-            const answers = response.answers || [];
-            const answerMap = {};
-            for (const answer of answers) {
-                const qIndex = parseInt(answer.questionId.replace("q", ""), 10);
-                const question = questions[qIndex];
-                if (!question)
-                    continue;
-                const selectedLabels = answer.selectedOptionIds
-                    .map((id) => question.options[parseInt(id, 10)]?.label)
-                    .filter(Boolean);
-                answerMap[question.question] = selectedLabels.join(", ");
-            }
-            return { behavior: "allow", message: JSON.stringify(answerMap) };
-        }
-        catch (error) {
-            logger.warn("wave/ask_question extMethod failed, falling back to requestPermission", { error });
-            return null;
-        }
-    }
-    async handleCreatePlan(sessionId, toolCallId, context) {
-        try {
-            const cachedTasks = this.taskCache.get(sessionId) || [];
-            const request = {
-                toolCallId,
-                plan: context.planContent || "",
-                todos: cachedTasks
-                    .filter((t) => t.status !== "deleted")
-                    .map((t) => ({
-                    id: t.id,
-                    content: t.subject,
-                    status: t.status === "completed"
-                        ? "completed"
-                        : t.status === "in_progress"
-                            ? "in_progress"
-                            : "pending",
-                })),
-            };
-            const response = await this.connection.extMethod("wave/create_plan", request);
-            const outcome = response.outcome;
-            if (outcome === "accepted") {
-                const mode = response.mode;
-                return {
-                    behavior: "allow",
-                    newPermissionMode: (mode || "default"),
-                };
-            }
-            if (outcome === "rejected") {
-                const reason = response.reason;
-                return { behavior: "deny", message: reason || "Plan rejected" };
-            }
-            // cancelled or unknown outcome
-            return { behavior: "deny", message: "Cancelled by user" };
-        }
-        catch (error) {
-            logger.warn("wave/create_plan extMethod failed, falling back to requestPermission", { error });
-            return null;
-        }
-    }
-    async handlePermissionRequest(sessionId, context) {
-        logger.info(`Handling permission request for ${context.toolName} in session ${sessionId}`);
-        const agent = this.agents.get(sessionId);
-        const toolCallId = context.toolCallId ||
-            "perm-" + Math.random().toString(36).substring(2, 9);
-        let effectiveName = context.toolName;
-        let effectiveCompactParams = undefined;
-        if (agent?.messages && context.toolCallId) {
-            const toolBlock = agent.messages
-                .flatMap((m) => m.blocks)
-                .find((b) => b.type === "tool" && b.id === context.toolCallId);
-            if (toolBlock) {
-                effectiveName = toolBlock.name || effectiveName;
-                effectiveCompactParams =
-                    toolBlock.compactParams || effectiveCompactParams;
-            }
-        }
-        const displayTitle = effectiveName && effectiveCompactParams
-            ? `${effectiveName}: ${effectiveCompactParams}`
-            : effectiveName || "Tool Call";
-        let options = [
-            {
-                optionId: "allow_once",
-                name: "Allow Once",
-                kind: "allow_once",
-            },
-            {
-                optionId: "allow_always",
-                name: "Allow Always",
-                kind: "allow_always",
-            },
-            {
-                optionId: "reject_once",
-                name: "Reject Once",
-                kind: "reject_once",
-            },
-        ];
-        if (context.toolName === BASH_TOOL_NAME ||
-            context.toolName === EDIT_TOOL_NAME ||
-            context.toolName === WRITE_TOOL_NAME) {
-            options = [
-                {
-                    optionId: "allow_once",
-                    name: "Yes, proceed",
-                    kind: "allow_once",
-                },
-                {
-                    optionId: "allow_always",
-                    name: this.getAllowAlwaysName(context),
-                    kind: "allow_always",
-                },
-            ];
-        }
-        else if (context.toolName === EXIT_PLAN_MODE_TOOL_NAME) {
-            options = [
-                {
-                    optionId: "allow_once",
-                    name: "Yes, manually approve edits",
-                    kind: "allow_once",
-                },
-                {
-                    optionId: "allow_always",
-                    name: "Yes, auto-accept edits",
-                    kind: "allow_always",
-                },
-            ];
-        }
-        else if (context.toolName === ENTER_PLAN_MODE_TOOL_NAME) {
-            options = [
-                {
-                    optionId: "allow_once",
-                    name: "Yes, enter plan mode",
-                    kind: "allow_once",
-                },
-                {
-                    optionId: "reject_once",
-                    name: "No, start implementing now",
-                    kind: "reject_once",
-                },
-            ];
-        }
-        else if (context.toolName === ASK_USER_QUESTION_TOOL_NAME) {
-            options = [];
-        }
-        const content = context.toolName
-            ? this.getToolContent(context.toolName, context.toolInput, undefined, context.planContent)
-            : undefined;
-        const locations = context.toolName
-            ? this.getToolLocations(context.toolName, context.toolInput)
-            : undefined;
-        const kind = context.toolName
-            ? this.getToolKind(context.toolName)
-            : undefined;
-        // Try extension methods first, fall back to requestPermission
-        if (context.toolName === ASK_USER_QUESTION_TOOL_NAME) {
-            const extResult = await this.handleAskQuestion(sessionId, toolCallId, context);
-            if (extResult !== null)
-                return extResult;
-            // Fall through to existing requestPermission logic
-        }
-        if (context.toolName === EXIT_PLAN_MODE_TOOL_NAME) {
-            const extResult = await this.handleCreatePlan(sessionId, toolCallId, context);
-            if (extResult !== null)
-                return extResult;
-            // Fall through to existing requestPermission logic
-        }
-        try {
-            const response = await this.connection.requestPermission({
-                sessionId: sessionId,
-                toolCall: {
-                    toolCallId,
-                    title: displayTitle,
-                    status: "pending",
-                    rawInput: context.toolInput,
-                    content,
-                    locations,
-                    kind,
-                },
-                options,
-            });
-            if (response.outcome.outcome === "cancelled") {
-                return { behavior: "deny", message: "Cancelled by user" };
-            }
-            if (context.toolName === ASK_USER_QUESTION_TOOL_NAME) {
-                return {
-                    behavior: "allow",
-                    message: response.message,
-                };
-            }
-            const selectedOptionId = response.outcome.optionId;
-            logger.info(`User selected permission option: ${selectedOptionId}`);
-            switch (selectedOptionId) {
-                case "allow_always":
-                    if (context.toolName === BASH_TOOL_NAME) {
-                        const command = context.toolInput?.command || "";
-                        const rule = context.suggestedPrefix || command;
-                        return {
-                            behavior: "allow",
-                            newPermissionRule: `${BASH_TOOL_NAME}(${rule})`,
-                        };
-                    }
-                    if (context.toolName === EDIT_TOOL_NAME ||
-                        context.toolName === WRITE_TOOL_NAME ||
-                        context.toolName === EXIT_PLAN_MODE_TOOL_NAME) {
-                        return {
-                            behavior: "allow",
-                            newPermissionMode: "acceptEdits",
-                        };
-                    }
-                    return {
-                        behavior: "allow",
-                        newPermissionRule: context.toolName,
-                    };
-                case "allow_once":
-                    if (context.toolName === EXIT_PLAN_MODE_TOOL_NAME) {
-                        return { behavior: "allow", newPermissionMode: "default" };
-                    }
-                    if (context.toolName === ENTER_PLAN_MODE_TOOL_NAME) {
-                        return { behavior: "allow", newPermissionMode: "plan" };
-                    }
-                    return { behavior: "allow" };
-                case "reject_once":
-                    return { behavior: "deny", message: "Rejected by user" };
-                default:
-                    return { behavior: "deny", message: "Unknown option selected" };
-            }
-        }
-        catch (error) {
-            logger.error("Error requesting permission via ACP:", error);
-            return {
-                behavior: "deny",
-                message: `Error requesting permission: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    getToolContent(name, parameters, shortResult, planContent) {
-        const contents = [];
-        if (parameters) {
-            if (name === WRITE_TOOL_NAME &&
-                typeof parameters.file_path === "string" &&
-                typeof parameters.content === "string") {
-                contents.push({
-                    type: "diff",
-                    path: parameters.file_path,
-                    oldText: null,
-                    newText: parameters.content,
-                });
-            }
-            else if (name === EDIT_TOOL_NAME &&
-                typeof parameters.file_path === "string" &&
-                typeof parameters.old_string === "string" &&
-                typeof parameters.new_string === "string") {
-                contents.push({
-                    type: "diff",
-                    path: parameters.file_path,
-                    oldText: parameters.old_string,
-                    newText: parameters.new_string,
-                });
-            }
-            else if (name === EXIT_PLAN_MODE_TOOL_NAME && planContent) {
-                contents.push({
-                    type: "content",
-                    content: {
-                        type: "text",
-                        text: planContent,
-                    },
-                });
-            }
-            else if (name === ASK_USER_QUESTION_TOOL_NAME &&
-                Array.isArray(parameters.questions)) {
-                const markdown = parameters.questions
-                    .map((q, i) => {
-                    let text = `### Question ${i + 1}\n${q.question}\n`;
-                    if (Array.isArray(q.options)) {
-                        text += q.options
-                            .map((opt) => `- ${opt.label}${opt.description ? `: ${opt.description}` : ""}`)
-                            .join("\n");
-                    }
-                    return text;
-                })
-                    .join("\n\n");
-                contents.push({
-                    type: "content",
-                    content: {
-                        type: "text",
-                        text: markdown,
-                    },
-                });
-            }
-            if (name.startsWith("mcp__")) {
-                contents.push({
-                    type: "content",
-                    content: {
-                        type: "text",
-                        text: "```json\n" + JSON.stringify(parameters, null, 2) + "\n```",
-                    },
-                });
-            }
-        }
-        if (shortResult) {
-            contents.push({
-                type: "content",
-                content: {
-                    type: "text",
-                    text: name === BASH_TOOL_NAME
-                        ? "```\n" + shortResult + "\n```"
-                        : shortResult,
-                },
-            });
-        }
-        return contents.length > 0 ? contents : undefined;
-    }
-    getToolLocations(name, parameters, extraStartLineNumber) {
-        if (!parameters)
-            return undefined;
-        if (name === "Write" ||
-            name === "Edit" ||
-            name === "Read" ||
-            name === "LSP") {
-            const filePath = (parameters.file_path || parameters.filePath);
-            let line = extraStartLineNumber ??
-                parameters.startLineNumber ??
-                parameters.line ??
-                parameters.offset;
-            if (name === "Write" && line === undefined) {
-                line = 1;
-            }
-            if (filePath) {
-                return [
-                    {
-                        path: filePath,
-                        line: line,
-                    },
-                ];
-            }
-        }
-        return undefined;
-    }
-    getToolKind(name) {
-        switch (name) {
-            case "Read":
-            case "Glob":
-            case "Grep":
-            case "LSP":
-                return "read";
-            case "Write":
-            case "Edit":
-                return "edit";
-            case "Bash":
-                return "execute";
-            case "Agent":
-                return "other";
-            default:
-                return "other";
-        }
-    }
-    async replayConversationHistory(agent) {
-        const sessionId = agent.sessionId;
-        const history = agent.messages;
-        for (const message of history) {
-            if (message.isMeta)
-                continue;
-            const messageId = message.id;
-            for (const block of message.blocks) {
-                if (block.type === "text") {
-                    const textBlock = block;
-                    const update = message.role === "user"
-                        ? {
-                            sessionUpdate: "user_message_chunk",
-                            content: { type: "text", text: textBlock.content },
-                            messageId,
-                        }
-                        : {
-                            sessionUpdate: "agent_message_chunk",
-                            content: { type: "text", text: textBlock.content },
-                            messageId,
-                        };
-                    this.connection.sessionUpdate({ sessionId, update });
-                }
-                else if (block.type === "reasoning") {
-                    const reasoningBlock = block;
-                    this.connection.sessionUpdate({
-                        sessionId,
-                        update: {
-                            sessionUpdate: "agent_thought_chunk",
-                            content: { type: "text", text: reasoningBlock.content },
-                            messageId,
-                        },
-                    });
-                }
-                else if (block.type === "tool") {
-                    const toolBlock = block;
-                    const toolCallId = toolBlock.id ||
-                        "replay-" + Math.random().toString(36).substring(2, 9);
-                    const effectiveName = toolBlock.name || "Tool";
-                    const effectiveCompactParams = toolBlock.compactParams;
-                    const displayTitle = effectiveName && effectiveCompactParams
-                        ? `${effectiveName}: ${effectiveCompactParams}`
-                        : effectiveName;
-                    let parsedParameters;
-                    if (toolBlock.parameters) {
-                        try {
-                            const parsed = JSON.parse(toolBlock.parameters);
-                            parsedParameters = Array.isArray(parsed)
-                                ? { args: parsed }
-                                : parsed;
-                        }
-                        catch {
-                            // Ignore parse errors
-                        }
-                    }
-                    const content = effectiveName && (parsedParameters || toolBlock.shortResult)
-                        ? this.getToolContent(effectiveName, parsedParameters, toolBlock.shortResult)
-                        : undefined;
-                    const locations = effectiveName && parsedParameters
-                        ? this.getToolLocations(effectiveName, parsedParameters)
-                        : undefined;
-                    const kind = effectiveName
-                        ? this.getToolKind(effectiveName)
-                        : undefined;
-                    // Emit tool_call (creation)
-                    this.connection.sessionUpdate({
-                        sessionId,
-                        update: {
-                            sessionUpdate: "tool_call",
-                            toolCallId,
-                            title: displayTitle,
-                            status: "pending",
-                            content,
-                            locations,
-                            kind,
-                            rawInput: parsedParameters,
-                        },
-                    });
-                    // Emit tool_call_update with final status
-                    const status = toolBlock.stage === "end"
-                        ? toolBlock.success
-                            ? "completed"
-                            : "failed"
-                        : toolBlock.stage === "running"
-                            ? "in_progress"
-                            : "pending";
-                    this.connection.sessionUpdate({
-                        sessionId,
-                        update: {
-                            sessionUpdate: "tool_call_update",
-                            toolCallId,
-                            status,
-                            title: displayTitle,
-                            rawOutput: toolBlock.result || toolBlock.error,
-                            content,
-                            locations,
-                            kind,
-                            rawInput: parsedParameters,
-                        },
-                    });
-                }
-                else if (block.type === "compact") {
-                    const compactBlock = block;
-                    this.connection.sessionUpdate({
-                        sessionId,
-                        update: {
-                            sessionUpdate: "agent_message_chunk",
-                            content: { type: "text", text: compactBlock.content },
-                            messageId,
-                        },
-                    });
-                }
-                // Skip: image, bang, error, file_history, task_notification blocks
-            }
-        }
-    }
-    createCallbacks(sessionId) {
-        const sessionRef = { id: sessionId };
-        const getAgent = () => this.agents.get(sessionRef.id);
-        const toolStates = new Map();
-        return {
-            callbacks: {
-                onAssistantContentUpdated: (params) => {
-                    this.connection.sessionUpdate({
-                        sessionId: sessionRef.id,
-                        update: {
-                            sessionUpdate: "agent_message_chunk",
-                            content: {
-                                type: "text",
-                                text: params.chunk,
-                            },
-                        },
-                    });
-                },
-                onAssistantReasoningUpdated: (params) => {
-                    this.connection.sessionUpdate({
-                        sessionId: sessionRef.id,
-                        update: {
-                            sessionUpdate: "agent_thought_chunk",
-                            content: {
-                                type: "text",
-                                text: params.chunk,
-                            },
-                        },
-                    });
-                },
-                onToolBlockUpdated: (params) => {
-                    const { id, name, stage, success, error, result, parameters, compactParams, shortResult, startLineNumber, } = params;
-                    let state = toolStates.get(id);
-                    if (!state) {
-                        state = {};
-                        toolStates.set(id, state);
-                    }
-                    if (name)
-                        state.name = name;
-                    if (compactParams)
-                        state.compactParams = compactParams;
-                    if (shortResult)
-                        state.shortResult = shortResult;
-                    if (startLineNumber !== undefined)
-                        state.startLineNumber = startLineNumber;
-                    const effectiveName = state.name || name;
-                    const effectiveCompactParams = state.compactParams || compactParams;
-                    const effectiveShortResult = state.shortResult || shortResult;
-                    const effectiveStartLineNumber = state.startLineNumber !== undefined
-                        ? state.startLineNumber
-                        : startLineNumber;
-                    const displayTitle = effectiveName && effectiveCompactParams
-                        ? `${effectiveName}: ${effectiveCompactParams}`
-                        : effectiveName || "Tool Call";
-                    let parsedParameters = undefined;
-                    if (parameters) {
-                        try {
-                            const parsed = JSON.parse(parameters);
-                            parsedParameters = Array.isArray(parsed)
-                                ? { args: parsed }
-                                : parsed;
-                        }
-                        catch {
-                            // Ignore parse errors during streaming
-                        }
-                    }
-                    const content = effectiveName && (parsedParameters || effectiveShortResult)
-                        ? this.getToolContent(effectiveName, parsedParameters, effectiveShortResult)
-                        : undefined;
-                    const locations = effectiveName && parsedParameters
-                        ? this.getToolLocations(effectiveName, parsedParameters, effectiveStartLineNumber)
-                        : undefined;
-                    const kind = effectiveName
-                        ? this.getToolKind(effectiveName)
-                        : undefined;
-                    if (stage === "start") {
-                        this.connection.sessionUpdate({
-                            sessionId: sessionRef.id,
-                            update: {
-                                sessionUpdate: "tool_call",
-                                toolCallId: id,
-                                title: displayTitle,
-                                status: "pending",
-                                content,
-                                locations,
-                                kind,
-                                rawInput: parsedParameters,
-                            },
-                        });
-                        return;
-                    }
-                    if (stage === "streaming") {
-                        // We don't support streaming tool arguments in ACP yet
-                        return;
-                    }
-                    const status = stage === "end"
-                        ? success
-                            ? "completed"
-                            : "failed"
-                        : stage === "running"
-                            ? "in_progress"
-                            : "pending";
-                    this.connection.sessionUpdate({
-                        sessionId: sessionRef.id,
-                        update: {
-                            sessionUpdate: "tool_call_update",
-                            toolCallId: id,
-                            status,
-                            title: displayTitle,
-                            rawOutput: result || error,
-                            content,
-                            locations,
-                            kind,
-                            rawInput: parsedParameters,
-                        },
-                    });
-                    if (stage === "end") {
-                        toolStates.delete(id);
-                    }
-                },
-                onTasksChange: (tasks) => {
-                    this.taskCache.set(sessionRef.id, tasks);
-                    this.connection.sessionUpdate({
-                        sessionId: sessionRef.id,
-                        update: {
-                            sessionUpdate: "plan",
-                            entries: tasks
-                                .filter((t) => t.status !== "deleted")
-                                .map((task) => ({
-                                content: task.subject,
-                                status: task.status === "completed"
-                                    ? "completed"
-                                    : task.status === "in_progress"
-                                        ? "in_progress"
-                                        : "pending",
-                                priority: "medium",
-                            })),
-                        },
-                    });
-                },
-                onPermissionModeChange: (mode) => {
-                    this.connection.sessionUpdate({
-                        sessionId: sessionRef.id,
-                        update: {
-                            sessionUpdate: "current_mode_update",
-                            currentModeId: mode,
-                        },
-                    });
-                    const agent = getAgent();
-                    if (agent) {
-                        this.connection.sessionUpdate({
-                            sessionId: sessionRef.id,
-                            update: {
-                                sessionUpdate: "config_option_update",
-                                configOptions: this.getSessionConfigOptions(agent),
-                            },
-                        });
-                    }
-                },
-                onModelChange: () => {
-                    const agent = getAgent();
-                    if (agent) {
-                        this.connection.sessionUpdate({
-                            sessionId: sessionRef.id,
-                            update: {
-                                sessionUpdate: "config_option_update",
-                                configOptions: this.getSessionConfigOptions(agent),
-                            },
-                        });
-                    }
-                },
-                onUserMessageAdded: (params) => {
-                    this.connection.sessionUpdate({
-                        sessionId: sessionRef.id,
-                        update: {
-                            sessionUpdate: "user_message_chunk",
-                            content: { type: "text", text: params.content },
-                        },
-                    });
-                },
-                onMcpServersChange: (servers) => {
-                    for (const server of servers) {
-                        this.connection.sessionUpdate({
-                            sessionId: sessionRef.id,
-                            update: {
-                                sessionUpdate: "ext_notification",
-                                method: "mcp_server_status",
-                                params: {
-                                    name: server.name,
-                                    status: server.status,
-                                    toolCount: server.toolCount,
-                                    error: server.error,
-                                },
-                            },
-                        });
-                    }
-                },
-                onSessionIdChange: (newSessionId) => {
-                    const oldSessionId = sessionRef.id;
-                    if (oldSessionId === newSessionId)
-                        return;
-                    // Update agents Map key
-                    const agent = this.agents.get(oldSessionId);
-                    if (agent) {
-                        this.agents.delete(oldSessionId);
-                        this.agents.set(newSessionId, agent);
-                    }
-                    // Update taskCache key
-                    const tasks = this.taskCache.get(oldSessionId);
-                    if (tasks) {
-                        this.taskCache.delete(oldSessionId);
-                        this.taskCache.set(newSessionId, tasks);
-                    }
-                    // Update ref so all subsequent callbacks use new ID
-                    sessionRef.id = newSessionId;
-                    // Notify ACP client
-                    this.connection.sessionUpdate({
-                        sessionId: oldSessionId,
-                        update: {
-                            sessionUpdate: "ext_notification",
-                            method: "session_id_change",
-                            params: { oldSessionId, newSessionId },
-                        },
-                    });
-                },
-                onLatestTotalTokensChange: (tokens) => {
-                    const agent = getAgent();
-                    const contextWindowSize = agent?.getMaxInputTokens() ?? 0;
-                    this.connection.sessionUpdate({
-                        sessionId: sessionRef.id,
-                        update: {
-                            sessionUpdate: "usage_update",
-                            size: contextWindowSize,
-                            used: tokens,
-                        },
-                    });
-                },
-                onLoadingChange: (loading) => {
-                    if (!loading) {
-                        this.connection.sessionUpdate({
-                            sessionId: sessionRef.id,
-                            update: {
-                                sessionUpdate: "agent_message_chunk",
-                                content: { type: "text", text: "" },
-                                _meta: { endOfTurn: true },
-                            },
-                        });
-                    }
-                },
-            },
-            sessionRef,
-        };
-    }
-}
-/**
- * Convert ACP McpServer[] to SDK Record<string, McpServerConfig>.
- */
-function convertAcpMcpServers(servers) {
-    const result = {};
-    for (const server of servers) {
-        const config = {};
-        if ("type" in server && server.type === "http") {
-            config.type = "http";
-            config.url = server.url;
-            config.headers = convertHttpHeaders(server.headers);
-        }
-        else if ("type" in server && server.type === "sse") {
-            config.type = "sse";
-            config.url = server.url;
-            config.headers = convertHttpHeaders(server.headers);
-        }
-        else {
-            // stdio (no type discriminator)
-            config.command = server.command;
-            config.args = server.args;
-            config.env = convertEnvVariables(server.env);
-        }
-        result[server.name] = config;
-    }
-    return result;
-}
-/**
- * Convert ACP EnvVariable[] to SDK Record<string, string>.
- */
-function convertEnvVariables(env) {
-    const result = {};
-    for (const entry of env) {
-        result[entry.name] = entry.value;
-    }
-    return result;
-}
-/**
- * Convert ACP HttpHeader[] to SDK Record<string, string>.
- */
-function convertHttpHeaders(headers) {
-    const result = {};
-    for (const entry of headers) {
-        result[entry.name] = entry.value;
-    }
-    return result;
-}
-/**
- * Map per-turn SDK usages to a single ACP Usage object.
- * Returns undefined when there are no usage entries.
- */
-function mapTurnUsage(newUsages) {
-    if (newUsages.length === 0)
-        return {};
-    let inputTokens = 0;
-    let outputTokens = 0;
-    let totalTokens = 0;
-    let cachedReadTokens = 0;
-    let cachedWriteTokens = 0;
-    for (const u of newUsages) {
-        inputTokens += u.prompt_tokens;
-        outputTokens += u.completion_tokens;
-        totalTokens += u.total_tokens;
-        cachedReadTokens += u.cache_read_input_tokens ?? 0;
-        cachedWriteTokens += u.cache_creation_input_tokens ?? 0;
-    }
-    const usage = {
-        inputTokens,
-        outputTokens,
-        totalTokens,
-    };
-    if (cachedReadTokens > 0)
-        usage.cachedReadTokens = cachedReadTokens;
-    if (cachedWriteTokens > 0)
-        usage.cachedWriteTokens = cachedWriteTokens;
-    return { usage };
-}