@tencent-ai/agent-sdk 0.3.41 → 0.3.43

package/lib/acp/converter.js

@@ -1,1094 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AcpConverter = void 0;
-// ============= Lookup Tables =============
-const TOOL_KIND_MAP = {
-    read: 'read',
-    notebookread: 'read',
-    notebook_read: 'read',
-    glob: 'read',
-    write: 'edit',
-    edit: 'edit',
-    multiedit: 'edit',
-    notebookedit: 'edit',
-    notebook_edit: 'edit',
-    bash: 'execute',
-    bashoutput: 'execute',
-    bash_output: 'execute',
-    killshell: 'execute',
-    kill_shell: 'execute',
-    taskoutput: 'execute',
-    task_output: 'execute',
-    grep: 'search',
-    websearch: 'search',
-    web_search: 'search',
-    webfetch: 'fetch',
-    web_fetch: 'fetch',
-    task: 'think',
-    todowrite: 'think',
-    todo_write: 'think',
-    enterplanmode: 'think',
-    enter_plan_mode: 'think',
-    exitplanmode: 'think',
-    exit_plan_mode: 'think',
-};
-const TOOL_TITLE_GENERATORS = {
-    read: input => {
-        const filePath = input.file_path;
-        const offset = input.offset;
-        const limit = input.limit;
-        if (!filePath) {
-            return 'Read';
-        }
-        if (limit) {
-            const startLine = (offset !== null && offset !== void 0 ? offset : 0) + 1;
-            const endLine = startLine + limit - 1;
-            return `Read ${filePath} (${startLine}-${endLine})`;
-        }
-        else if (offset) {
-            return `Read ${filePath} (from line ${(offset !== null && offset !== void 0 ? offset : 0) + 1})`;
-        }
-        return `Read ${filePath}`;
-    },
-    write: input => {
-        const filePath = input.file_path;
-        return filePath ? `Write ${filePath}` : 'Write';
-    },
-    edit: input => {
-        const filePath = input.file_path;
-        return filePath ? `Edit \`${filePath}\`` : 'Edit';
-    },
-    multiedit: input => {
-        const filePath = input.file_path;
-        return filePath ? `Edit \`${filePath}\`` : 'Edit';
-    },
-    bash: input => {
-        const command = input.command;
-        if (!command) {
-            return 'Terminal';
-        }
-        const escaped = command.split('`').join('\\`');
-        return `\`${escaped}\``;
-    },
-    bashoutput: () => 'Tail Logs',
-    bash_output: () => 'Tail Logs',
-    killshell: () => 'Kill Process',
-    kill_shell: () => 'Kill Process',
-    glob: input => {
-        let label = 'Find';
-        const path = input.path;
-        const pattern = input.pattern;
-        if (path) {
-            label += ` \`${path}\``;
-        }
-        if (pattern) {
-            label += ` \`${pattern}\``;
-        }
-        return label;
-    },
-    grep: input => {
-        let label = 'grep';
-        if (input['-i']) {
-            label += ' -i';
-        }
-        if (input['-n']) {
-            label += ' -n';
-        }
-        if (input['-C'] !== undefined) {
-            label += ` -C ${input['-C']}`;
-        }
-        if (input['-A'] !== undefined) {
-            label += ` -A ${input['-A']}`;
-        }
-        if (input['-B'] !== undefined) {
-            label += ` -B ${input['-B']}`;
-        }
-        if (input.multiline) {
-            label += ' -P';
-        }
-        if (input.glob) {
-            label += ` --include="${input.glob}"`;
-        }
-        if (input.type) {
-            label += ` --type=${input.type}`;
-        }
-        const pattern = input.pattern;
-        const path = input.path;
-        if (pattern) {
-            label += ` "${pattern}"`;
-        }
-        if (path) {
-            label += ` ${path}`;
-        }
-        return label;
-    },
-    webfetch: input => {
-        const url = input.url;
-        return url ? `Fetch ${url}` : 'Fetch';
-    },
-    web_fetch: input => {
-        const url = input.url;
-        return url ? `Fetch ${url}` : 'Fetch';
-    },
-    websearch: input => {
-        const query = input.query;
-        if (!query) {
-            return 'Search';
-        }
-        let label = `"${query}"`;
-        const allowedDomains = input.allowed_domains;
-        const blockedDomains = input.blocked_domains;
-        if (allowedDomains === null || allowedDomains === void 0 ? void 0 : allowedDomains.length) {
-            label += ` (allowed: ${allowedDomains.join(', ')})`;
-        }
-        if (blockedDomains === null || blockedDomains === void 0 ? void 0 : blockedDomains.length) {
-            label += ` (blocked: ${blockedDomains.join(', ')})`;
-        }
-        return label;
-    },
-    web_search: input => {
-        const query = input.query;
-        if (!query) {
-            return 'Search';
-        }
-        let label = `"${query}"`;
-        const allowedDomains = input.allowed_domains;
-        const blockedDomains = input.blocked_domains;
-        if (allowedDomains === null || allowedDomains === void 0 ? void 0 : allowedDomains.length) {
-            label += ` (allowed: ${allowedDomains.join(', ')})`;
-        }
-        if (blockedDomains === null || blockedDomains === void 0 ? void 0 : blockedDomains.length) {
-            label += ` (blocked: ${blockedDomains.join(', ')})`;
-        }
-        return label;
-    },
-    notebookread: input => {
-        const path = input.notebook_path;
-        return path ? `Read Notebook ${path}` : 'Read Notebook';
-    },
-    notebook_read: input => {
-        const path = input.notebook_path;
-        return path ? `Read Notebook ${path}` : 'Read Notebook';
-    },
-    notebookedit: input => {
-        const path = input.notebook_path;
-        return path ? `Edit Notebook ${path}` : 'Edit Notebook';
-    },
-    notebook_edit: input => {
-        const path = input.notebook_path;
-        return path ? `Edit Notebook ${path}` : 'Edit Notebook';
-    },
-    task: input => {
-        const description = input.description;
-        return description || 'Task';
-    },
-    todowrite: () => 'Update TODOs',
-    todo_write: () => 'Update TODOs',
-    askuserquestion: () => 'Ask User',
-    ask_user_question: () => 'Ask User',
-    slashcommand: input => {
-        const command = input.command;
-        return command ? `Run: ${command}` : 'Slash Command';
-    },
-    slash_command: input => {
-        const command = input.command;
-        return command ? `Run: ${command}` : 'Slash Command';
-    },
-    skill: input => {
-        const command = input.command;
-        return command ? `Skill: ${command}` : 'Skill';
-    },
-    lsp: input => {
-        const operation = input.operation;
-        return operation ? `LSP: ${operation}` : 'LSP';
-    },
-    enterplanmode: () => 'Enter Plan Mode',
-    enter_plan_mode: () => 'Enter Plan Mode',
-    exitplanmode: () => 'Exit Plan Mode',
-    exit_plan_mode: () => 'Exit Plan Mode',
-    taskoutput: () => 'Get Task Output',
-    task_output: () => 'Get Task Output',
-};
-// ============= AcpConverter =============
-class AcpConverter {
-    constructor() {
-        this.todoWriteToolUseIds = new Set();
-        this.taskToolUseIds = new Set();
-        // Map from content block index to actual tool call ID
-        this.contentBlockIndexToToolCallId = new Map();
-        // Map from content block index to tool name (for skipping TodoWrite streaming updates)
-        this.contentBlockIndexToToolName = new Map();
-    }
-    reset() {
-        this.todoWriteToolUseIds.clear();
-        this.taskToolUseIds.clear();
-        this.contentBlockIndexToToolCallId.clear();
-        this.contentBlockIndexToToolName.clear();
-    }
-    isTodoWriteToolUse(toolName) {
-        return toolName === 'TodoWrite' || toolName === 'todo_write';
-    }
-    isTaskToolWithPlan(toolName) {
-        return AcpConverter.TASK_TOOLS_WITH_PLAN.has(toolName);
-    }
-    /**
-     * Check if a tool should only generate plan updates (no tool_call/tool_call_update).
-     */
-    isPlanOnlyTool(toolName) {
-        return this.isTodoWriteToolUse(toolName) || this.isTaskToolWithPlan(toolName);
-    }
-    shouldSkipToolResult(toolUseId) {
-        if (this.todoWriteToolUseIds.has(toolUseId)) {
-            // Remove after checking to free memory
-            this.todoWriteToolUseIds.delete(toolUseId);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Add requestId to SessionUpdateWithMeta if provided.
-     * Merges with existing _meta if present.
-     */
-    withRequestId(update, requestId) {
-        var _a, _b;
-        if (!requestId) {
-            return update;
-        }
-        const existingMeta = (_b = (_a = update._meta) === null || _a === void 0 ? void 0 : _a['codebuddy.ai']) !== null && _b !== void 0 ? _b : {};
-        return {
-            ...update,
-            _meta: {
-                'codebuddy.ai': {
-                    ...existingMeta,
-                    requestId,
-                },
-            },
-        };
-    }
-    // ============= Public API =============
-    /**
-     * Convert SDK message to SessionUpdate objects.
-     *
-     * This is the unified conversion method for both streaming and history modes.
-     * The only difference between modes is whether to include user input text.
-     *
-     * @param message - SDK message to convert
-     * @param options - Conversion options
-     * @param options.includeUserInput - Whether to include user text content (default: false)
-     *                                   Set to true for history replay, false for live streaming
-     *
-     * Returns updates for:
-     * - stream_event → agent_message_chunk, tool_call, tool_call_update (streaming deltas)
-     *   - content_block_start with tool_use → tool_call (status: pending)
-     *   - content_block_delta with text_delta → agent_message_chunk
-     *   - content_block_delta with input_json_delta → tool_call_update (status: pending, streaming params)
-     * - user messages → user_message_chunk (if includeUserInput), tool_call_update
-     * - assistant messages → agent_message_chunk, tool_call
-     * - result/error → ignored (handled by prompt() return value)
-     */
-    convertToUpdates(message, options = { mode: 'stream' }) {
-        const updates = [];
-        if (!('type' in message)) {
-            return updates;
-        }
-        // Extract _requestId from message (experimental)
-        const requestId = message._requestId;
-        switch (message.type) {
-            case 'stream_event':
-                updates.push(...this.convertStreamEventToUpdates(message, requestId));
-                break;
-            case 'user':
-                updates.push(...this.convertUserMessageToUpdates(message, options.mode, requestId));
-                break;
-            case 'assistant':
-                updates.push(...this.convertAssistantMessageToUpdates(message, options.mode, requestId));
-                break;
-            case 'topic':
-                updates.push(...this.convertTopicMessageToUpdates(message, requestId));
-                break;
-            case 'system':
-                updates.push(...this.convertSystemMessageToUpdates(message, requestId));
-                break;
-            // result/error are not sent as session updates (handled by prompt() return value)
-        }
-        return updates;
-    }
-    // ============= Private: Message Converters =============
-    /**
-     * Convert stream_event (partial assistant message) to updates.
-     * Handles content_block_start, content_block_delta, and input_json_delta events.
-     */
-    convertStreamEventToUpdates(partialMsg, requestId) {
-        const updates = [];
-        const streamEvent = partialMsg.event;
-        if (streamEvent.type === 'content_block_start' && 'content_block' in streamEvent) {
-            const block = streamEvent.content_block;
-            const index = streamEvent.index;
-            if (block.type === 'tool_use') {
-                const toolUse = block;
-                // Store mapping from index to tool call ID and tool name
-                if (typeof index === 'number') {
-                    this.contentBlockIndexToToolCallId.set(index, toolUse.id);
-                    this.contentBlockIndexToToolName.set(index, toolUse.name);
-                }
-                updates.push(...this.convertToolUseToUpdates(toolUse, requestId));
-            }
-            else if (block.type === 'text') {
-                updates.push(this.withRequestId({
-                    update: {
-                        sessionUpdate: 'agent_message_chunk',
-                        content: { type: 'text', text: block.text || '' },
-                    },
-                }, requestId));
-            }
-            else if (block.type === 'thinking') {
-                // Thinking block start - send initial agent_thought_chunk
-                updates.push(this.withRequestId({
-                    update: {
-                        sessionUpdate: 'agent_thought_chunk',
-                        content: { type: 'text', text: block.thinking || '' },
-                    },
-                }, requestId));
-            }
-            // redacted_thinking - skip (ACP doesn't have equivalent)
-        }
-        else if (streamEvent.type === 'content_block_delta') {
-            if ('delta' in streamEvent) {
-                const delta = streamEvent.delta;
-                // Handle text delta
-                if (delta.type === 'text_delta') {
-                    updates.push(this.withRequestId({
-                        update: {
-                            sessionUpdate: 'agent_message_chunk',
-                            content: { type: 'text', text: delta.text },
-                        },
-                    }, requestId));
-                }
-                // Handle input_json_delta for tool calls
-                else if (delta.type === 'input_json_delta') {
-                    const toolCallUpdate = this.convertInputJsonDeltaToUpdate(streamEvent, requestId);
-                    if (toolCallUpdate) {
-                        updates.push(toolCallUpdate);
-                    }
-                }
-                // Handle thinking delta
-                else if (delta.type === 'thinking_delta') {
-                    updates.push(this.withRequestId({
-                        update: {
-                            sessionUpdate: 'agent_thought_chunk',
-                            content: { type: 'text', text: delta.thinking },
-                        },
-                    }, requestId));
-                }
-                // Handle signature delta - skip (ACP doesn't support signatures)
-                // else if (delta.type === 'signature_delta') { }
-            }
-        }
-        return updates;
-    }
-    /**
-     * Convert user message to updates.
-     * Includes user text and image content.
-     * Always includes tool results.
-     */
-    convertUserMessageToUpdates(userMsg, _mode, requestId) {
-        const updates = [];
-        // Extract all user content (text and images)
-        const contentUpdates = this.extractUserContentUpdates(userMsg, requestId);
-        updates.push(...contentUpdates);
-        // Always extract tool results
-        updates.push(...this.extractToolResultUpdates(userMsg, requestId));
-        return updates;
-    }
-    /**
-     * Convert assistant message to updates.
-     * Extracts text content and tool calls.
-     */
-    convertAssistantMessageToUpdates(assistantMsg, mode, requestId) {
-        var _a;
-        const updates = [];
-        const content = (_a = assistantMsg.message) === null || _a === void 0 ? void 0 : _a.content;
-        if (!content || !Array.isArray(content)) {
-            return updates;
-        }
-        // Extract tool calls and thinking blocks
-        for (const block of content) {
-            if (block.type === 'tool_use') {
-                updates.push(...this.convertToolUseToUpdates(block, requestId));
-            }
-            else if (block.type === 'thinking') {
-                // Non-streaming thinking content
-                const thinkingBlock = block;
-                if (thinkingBlock.thinking) {
-                    updates.push(this.withRequestId({
-                        update: {
-                            sessionUpdate: 'agent_thought_chunk',
-                            content: { type: 'text', text: thinkingBlock.thinking },
-                        },
-                    }, requestId));
-                }
-            }
-            // redacted_thinking - skip (ACP doesn't have equivalent)
-        }
-        if (mode === 'history') {
-            // Extract text content
-            const textContent = AcpConverter.extractTextContent(content);
-            if (textContent) {
-                updates.push(this.withRequestId({
-                    update: {
-                        sessionUpdate: 'agent_message_chunk',
-                        content: { type: 'text', text: textContent },
-                    },
-                }, requestId));
-            }
-        }
-        return updates;
-    }
-    /**
-     * Convert topic message to session_info_update.
-     * Updates the session's human-readable title.
-     */
-    convertTopicMessageToUpdates(topicMsg, requestId) {
-        return [this.withRequestId({
-                update: {
-                    sessionUpdate: 'session_info_update',
-                    title: topicMsg.topic
-                },
-            }, requestId)];
-    }
-    /**
-     * Convert system init message.
-     * Note: System messages are NOT converted to SessionUpdate.
-     * The model/permissionMode should be sent via custom notification instead.
-     * See AcpAgent.handleSystemInitNotification() for sending custom notifications.
-     */
-    convertSystemMessageToUpdates(_sysMsg, _requestId) {
-        // System messages are handled separately - not via session updates
-        // The AcpAgent will send custom notifications for model/permissionMode
-        return [];
-    }
-    /**
-     * Convert tool_use block to updates.
-     * Handles TodoWrite specially (converts to plan update from input.newTodos).
-     * Handles Task tools specially (skips tool_call, plan generated from tool_result).
-     */
-    convertToolUseToUpdates(toolUse, requestId) {
-        // TodoWrite: generate plan from input.newTodos
-        if (this.isTodoWriteToolUse(toolUse.name)) {
-            const planUpdate = this.createPlanUpdate(toolUse);
-            if (planUpdate) {
-                return [this.withRequestId({
-                        update: planUpdate,
-                        _meta: { 'codebuddy.ai': { toolName: toolUse.name } },
-                    }, requestId)];
-            }
-            return [];
-        }
-        // Task tools: skip tool_call, plan will be generated from tool_result
-        if (this.isTaskToolWithPlan(toolUse.name)) {
-            // Mark for skipping tool_result as well (plan will be generated there)
-            this.taskToolUseIds.add(toolUse.id);
-            return [];
-        }
-        // Regular tools: generate tool_call as usual
-        // When rawInput exists (input is complete), status should be 'in_progress' (tool is running)
-        // 'pending' is only for streaming input or awaiting approval
-        const hasCompleteInput = toolUse.input && Object.keys(toolUse.input).length > 0;
-        return [this.withRequestId({
-                update: {
-                    sessionUpdate: 'tool_call',
-                    toolCallId: toolUse.id,
-                    status: (hasCompleteInput ? 'in_progress' : 'pending'),
-                    title: AcpConverter.generateToolTitle(toolUse.name, toolUse.input),
-                    kind: AcpConverter.getToolKind(toolUse.name),
-                    rawInput: toolUse.input,
-                    content: AcpConverter.generateToolContent(toolUse.name, toolUse.input),
-                    locations: AcpConverter.extractToolLocations(toolUse.name, toolUse.input),
-                },
-                _meta: { 'codebuddy.ai': { toolName: toolUse.name } },
-            }, requestId)];
-    }
-    /**
-     * Extract user content updates (text and images) from user message.
-     * Converts SDK content blocks to ACP user_message_chunk updates.
-     */
-    extractUserContentUpdates(userMsg, requestId) {
-        var _a;
-        const updates = [];
-        const content = (_a = userMsg.message) === null || _a === void 0 ? void 0 : _a.content;
-        if (!content) {
-            return updates;
-        }
-        // Handle string content (simple text)
-        if (typeof content === 'string') {
-            if (content) {
-                updates.push(this.withRequestId({
-                    update: {
-                        sessionUpdate: 'user_message_chunk',
-                        content: { type: 'text', text: content },
-                    },
-                }, requestId));
-            }
-            return updates;
-        }
-        // Handle array of content blocks
-        if (Array.isArray(content)) {
-            for (const block of content) {
-                if (!block || typeof block !== 'object' || !('type' in block)) {
-                    continue;
-                }
-                if (block.type === 'text') {
-                    const textBlock = block;
-                    if (textBlock.text) {
-                        updates.push(this.withRequestId({
-                            update: {
-                                sessionUpdate: 'user_message_chunk',
-                                content: { type: 'text', text: textBlock.text },
-                            },
-                        }, requestId));
-                    }
-                }
-                else if (block.type === 'image') {
-                    // Convert SDK ImageContentBlock to ACP ImageContent
-                    const imageBlock = block;
-                    const acpImage = AcpConverter.convertSdkImageToAcp(imageBlock);
-                    if (acpImage) {
-                        updates.push(this.withRequestId({
-                            update: {
-                                sessionUpdate: 'user_message_chunk',
-                                content: acpImage,
-                            },
-                        }, requestId));
-                    }
-                }
-                // Skip tool_result blocks - handled separately by extractToolResultUpdates
-            }
-        }
-        return updates;
-    }
-    /**
-     * Extract tool result updates from user message.
-     */
-    extractToolResultUpdates(userMsg, requestId) {
-        var _a;
-        const updates = [];
-        const content = (_a = userMsg.message) === null || _a === void 0 ? void 0 : _a.content;
-        if (!content || !Array.isArray(content)) {
-            return updates;
-        }
-        for (const block of content) {
-            if (block.type === 'tool_result') {
-                const toolResult = block;
-                // Skip TodoWrite results
-                if (this.shouldSkipToolResult(toolResult.tool_use_id)) {
-                    continue;
-                }
-                // Task tools: generate plan from rawResponse.todos
-                if (this.taskToolUseIds.has(toolResult.tool_use_id)) {
-                    this.taskToolUseIds.delete(toolResult.tool_use_id);
-                    const planUpdate = this.tryCreatePlanUpdateFromTaskResult(toolResult);
-                    if (planUpdate) {
-                        updates.push(this.withRequestId({ update: planUpdate }, requestId));
-                    }
-                    continue; // Skip tool_call_update
-                }
-                // Regular tools: generate tool_call_update as usual
-                const toolCallContent = AcpConverter.extractToolCallContent(toolResult.content);
-                updates.push(this.withRequestId({
-                    update: {
-                        sessionUpdate: 'tool_call_update',
-                        toolCallId: toolResult.tool_use_id,
-                        status: toolResult.is_error ? 'failed' : 'completed',
-                        content: toolCallContent.length > 0 ? toolCallContent : undefined,
-                        rawOutput: toolResult.content,
-                    },
-                }, requestId));
-            }
-        }
-        return updates;
-    }
-    /**
-     * Convert input_json_delta to tool_call_update.
-     * Sends streaming updates of tool call parameters as they arrive.
-     * Skips TodoWrite and Task tool streaming updates (plan updates are sent separately).
-     */
-    convertInputJsonDeltaToUpdate(deltaEvent, requestId) {
-        var _a;
-        try {
-            const index = deltaEvent.index;
-            // Skip TodoWrite and Task tools streaming updates (plan updates are handled separately)
-            const toolName = this.contentBlockIndexToToolName.get(index);
-            if (toolName && this.isPlanOnlyTool(toolName)) {
-                return null;
-            }
-            const partialJson = (_a = deltaEvent.delta) === null || _a === void 0 ? void 0 : _a.partial_json;
-            if (typeof partialJson !== 'string' || !partialJson) {
-                return null;
-            }
-            // Try to get the actual tool call ID from the mapping
-            // If not yet available (delta arrives before content_block_start), use temporary ID
-            const toolCallId = this.contentBlockIndexToToolCallId.get(index) || `temp_${index}`;
-            return this.withRequestId({
-                update: {
-                    sessionUpdate: 'tool_call_update',
-                    toolCallId,
-                    status: 'pending',
-                    content: [{
-                            type: 'content',
-                            content: { type: 'text', text: partialJson },
-                        }],
-                },
-            }, requestId);
-        }
-        catch (_b) {
-            return null;
-        }
-    }
-    /**
-     * Create plan update from TodoWrite tool use.
-     *
-     * agent-cli format: { oldTodos: [...], newTodos: [...] }
-     * - newTodos: The current/updated todo list
-     * - oldTodos: The previous todo list (for reference)
-     *
-     * Behavior (consistent with claude-code-acp):
-     * - Always use newTodos for the plan entries
-     * - When newTodos is empty, send empty entries to clear the plan
-     */
-    createPlanUpdate(toolUse) {
-        try {
-            const input = toolUse.input;
-            // Only use newTodos (consistent with claude-code-acp behavior)
-            if (!(input === null || input === void 0 ? void 0 : input.newTodos) || !Array.isArray(input.newTodos)) {
-                return null;
-            }
-            const entries = input.newTodos.map((todo, index) => ({
-                content: todo.content,
-                status: todo.status,
-                priority: 'medium',
-                _meta: { 'codebuddy.ai': { id: `todo-${index}`, activeForm: todo.activeForm } },
-            }));
-            this.todoWriteToolUseIds.add(toolUse.id);
-            return { sessionUpdate: 'plan', entries };
-        }
-        catch (_a) {
-            return null;
-        }
-    }
-    /**
-     * Create plan update from Task tool result.
-     * Extracts todos from _meta.rawResponse.todos or content text (full task list).
-     */
-    tryCreatePlanUpdateFromTaskResult(toolResult) {
-        var _a, _b, _c;
-        try {
-            // First, check _meta.rawResponse.todos (preferred, set by stream-json-view)
-            const meta = toolResult._meta;
-            let todos = (_a = meta === null || meta === void 0 ? void 0 : meta.rawResponse) === null || _a === void 0 ? void 0 : _a.todos;
-            // Fallback: try to parse from content text
-            if (!todos || !Array.isArray(todos)) {
-                let resultData;
-                if (typeof toolResult.content === 'string') {
-                    resultData = JSON.parse(toolResult.content);
-                }
-                else if (Array.isArray(toolResult.content)) {
-                    for (const block of toolResult.content) {
-                        if ('text' in block && block.text) {
-                            try {
-                                const parsed = JSON.parse(block.text);
-                                if ((_b = parsed.rawResponse) === null || _b === void 0 ? void 0 : _b.todos) {
-                                    resultData = parsed;
-                                    break;
-                                }
-                            }
-                            catch (_d) {
-                                continue;
-                            }
-                        }
-                    }
-                }
-                todos = (_c = resultData === null || resultData === void 0 ? void 0 : resultData.rawResponse) === null || _c === void 0 ? void 0 : _c.todos;
-            }
-            if (!todos || !Array.isArray(todos)) {
-                return null;
-            }
-            const entries = todos.map((todo, index) => ({
-                content: todo.content,
-                status: todo.status,
-                priority: 'medium',
-                _meta: { 'codebuddy.ai': { id: `task-${index}`, activeForm: todo.activeForm } },
-            }));
-            return { sessionUpdate: 'plan', entries };
-        }
-        catch (_e) {
-            return null;
-        }
-    }
-    // ============= Static: Tool Conversion =============
-    static extractToolCallContent(content) {
-        const result = [];
-        if (!content) {
-            return result;
-        }
-        if (typeof content === 'string') {
-            result.push({
-                type: 'content',
-                content: { type: 'text', text: content },
-            });
-        }
-        else if (Array.isArray(content)) {
-            for (const block of content) {
-                if ('type' in block && block.type === 'text') {
-                    const textBlock = block;
-                    result.push({
-                        type: 'content',
-                        content: { type: 'text', text: textBlock.text },
-                    });
-                }
-            }
-        }
-        return result;
-    }
-    static convertToolResultToUpdate(toolResult) {
-        const content = AcpConverter.extractToolCallContent(toolResult.content);
-        return {
-            toolCallId: toolResult.tool_use_id,
-            status: toolResult.is_error ? 'failed' : 'completed',
-            content: content.length > 0 ? content : undefined,
-        };
-    }
-    static convertAcpToolResultToSdk(toolCallId, acpResult) {
-        const isError = acpResult.status === 'failed';
-        const content = acpResult.content ? AcpConverter.formatAcpContentForSdk(acpResult.content) : '';
-        return {
-            type: 'tool_result',
-            tool_use_id: toolCallId,
-            content: content,
-            is_error: isError,
-        };
-    }
-    static convertSdkToolResultToToolResult(toolResult) {
-        const content = AcpConverter.extractToolCallContent(toolResult.content);
-        return {
-            toolCallId: toolResult.tool_use_id,
-            status: toolResult.is_error ? 'failed' : 'completed',
-            content: content.length > 0 ? content : undefined,
-            rawOutput: toolResult.content,
-        };
-    }
-    // ============= Private: Lookup-based Utilities =============
-    static generateToolTitle(toolName, input) {
-        const generator = TOOL_TITLE_GENERATORS[toolName.toLowerCase()];
-        return generator ? generator(input) : (toolName || 'Unknown Tool');
-    }
-    static getToolKind(toolName) {
-        var _a;
-        return (_a = TOOL_KIND_MAP[toolName.toLowerCase()]) !== null && _a !== void 0 ? _a : 'other';
-    }
-    static generateToolContent(toolName, input) {
-        const content = [];
-        const lowerName = toolName.toLowerCase();
-        if (lowerName === 'edit' || lowerName === 'multiedit') {
-            const filePath = input.file_path;
-            const oldString = input.old_string;
-            const newString = input.new_string;
-            if (filePath && oldString !== undefined && newString !== undefined) {
-                content.push({
-                    type: 'diff',
-                    path: filePath,
-                    oldText: oldString || null,
-                    newText: newString,
-                });
-            }
-        }
-        else if (lowerName === 'bash') {
-            const description = input.description;
-            if (description) {
-                content.push({
-                    type: 'content',
-                    content: { type: 'text', text: description },
-                });
-            }
-        }
-        else if (lowerName === 'task') {
-            const prompt = input.prompt;
-            if (prompt) {
-                content.push({
-                    type: 'content',
-                    content: { type: 'text', text: prompt },
-                });
-            }
-        }
-        else if (lowerName === 'webfetch' || lowerName === 'web_fetch') {
-            const prompt = input.prompt;
-            if (prompt) {
-                content.push({
-                    type: 'content',
-                    content: { type: 'text', text: prompt },
-                });
-            }
-        }
-        return content.length > 0 ? content : undefined;
-    }
-    static extractToolLocations(toolName, input) {
-        const locations = [];
-        const lowerName = toolName.toLowerCase();
-        const filePath = input.file_path;
-        const notebookPath = input.notebook_path;
-        const path = input.path;
-        if (filePath) {
-            locations.push({ path: filePath });
-        }
-        else if (notebookPath) {
-            locations.push({ path: notebookPath });
-        }
-        else if (path && lowerName === 'glob') {
-            locations.push({ path });
-        }
-        return locations.length > 0 ? locations : undefined;
-    }
-    static formatAcpContentForSdk(toolCallContent) {
-        var _a, _b;
-        if (toolCallContent.length === 0) {
-            return '';
-        }
-        const blocks = [];
-        for (const item of toolCallContent) {
-            if (item.type === 'diff') {
-                const diff = item;
-                const diffText = `--- ${diff.path}\n+++ ${diff.path}\n${AcpConverter.formatDiffHunk((_a = diff.oldText) !== null && _a !== void 0 ? _a : null, diff.newText)}`;
-                blocks.push({ type: 'text', text: diffText });
-            }
-            else if (item.type === 'content') {
-                const contentItem = item;
-                if (((_b = contentItem.content) === null || _b === void 0 ? void 0 : _b.type) === 'text' && contentItem.content.text) {
-                    blocks.push({ type: 'text', text: contentItem.content.text });
-                }
-            }
-            else if (item.type === 'terminal') {
-                const terminalItem = item;
-                if (terminalItem.terminalId) {
-                    blocks.push({ type: 'text', text: `[Terminal: ${terminalItem.terminalId}]` });
-                }
-            }
-        }
-        if (blocks.length === 1 && blocks[0].type === 'text') {
-            return blocks[0].text;
-        }
-        return blocks.length > 0 ? blocks : '';
-    }
-    static formatDiffHunk(oldText, newText) {
-        const oldLines = oldText ? oldText.split('\n') : [];
-        const newLines = newText.split('\n');
-        const hunks = [];
-        hunks.push(`@@ -1,${oldLines.length} +1,${newLines.length} @@`);
-        for (const line of oldLines) {
-            hunks.push(`-${line}`);
-        }
-        for (const line of newLines) {
-            hunks.push(`+${line}`);
-        }
-        return hunks.join('\n');
-    }
-    static extractTextContent(contentBlocks) {
-        if (!Array.isArray(contentBlocks)) {
-            return '';
-        }
-        return contentBlocks
-            .filter((block) => typeof block === 'object' &&
-            block !== null &&
-            'type' in block &&
-            block.type === 'text')
-            .map(block => block.text)
-            .join('\n');
-    }
-    // ============= ACP Prompt to SDK Conversion =============
-    /**
-     * Convert ACP ContentBlock[] to SDK ContentBlock[].
-     *
-     * Type mapping (following Zed claude-code-acp pattern):
-     * - ACP text -> SDK TextContentBlock (with MCP command format conversion)
-     * - ACP image -> SDK ImageContentBlock (base64 or URL)
-     * - ACP resource (text) -> SDK TextContentBlock ([@name](uri) link + content)
-     * - ACP resource (blob/image) -> SDK ImageContentBlock
-     * - ACP resource_link -> SDK TextContentBlock ([@name](uri) Markdown link)
-     * - ACP audio -> ignored (not supported by SDK)
-     */
-    static convertAcpPromptToSdk(blocks) {
-        const content = [];
-        const context = [];
-        for (const block of blocks) {
-            AcpConverter.convertAcpContentBlock(block, content, context);
-        }
-        // Append context blocks at the end (following Zed pattern)
-        return [...content, ...context];
-    }
-    /**
-     * Convert a single ACP ContentBlock and push to content/context arrays.
-     * Following Zed claude-code-acp pattern for content/context separation.
-     */
-    static convertAcpContentBlock(block, content, context) {
-        switch (block.type) {
-            case 'text': {
-                const textBlock = block;
-                let text = textBlock.text;
-                // MCP command format conversion: /mcp:server:command -> /server:command (MCP)
-                const mcpMatch = text.match(/^\/mcp:([^:\s]+):(\S+)(\s+.*)?$/);
-                if (mcpMatch) {
-                    const [, server, command, args] = mcpMatch;
-                    text = `/${server}:${command} (MCP)${args || ''}`;
-                }
-                content.push({ type: 'text', text });
-                break;
-            }
-            case 'image': {
-                const imageBlock = block;
-                if (imageBlock.data) {
-                    // Base64 image
-                    content.push({
-                        type: 'image',
-                        source: {
-                            type: 'base64',
-                            media_type: AcpConverter.normalizeImageMimeType(imageBlock.mimeType),
-                            data: imageBlock.data,
-                        },
-                    });
-                }
-                else if (imageBlock.uri && imageBlock.uri.startsWith('http')) {
-                    // URL image (only HTTP/HTTPS)
-                    content.push({
-                        type: 'image',
-                        source: {
-                            type: 'url',
-                            url: imageBlock.uri,
-                        },
-                    });
-                }
-                break;
-            }
-            case 'resource': {
-                // EmbeddedResource - following Zed pattern: link in content, text in context
-                const resourceBlock = block;
-                const resource = resourceBlock.resource;
-                if ('text' in resource && resource.text !== undefined) {
-                    const textResource = resource;
-                    // Text resource: add formatted link to content, text to context
-                    const formattedUri = AcpConverter.formatUriAsLink(textResource.uri);
-                    content.push({ type: 'text', text: formattedUri });
-                    context.push({ type: 'text', text: `\n\n${textResource.text}\n` });
-                }
-                else if ('blob' in resource && resource.blob) {
-                    const blobResource = resource;
-                    // Blob resource - check if it's an image
-                    const mimeType = blobResource.mimeType || '';
-                    if (mimeType.startsWith('image/')) {
-                        content.push({
-                            type: 'image',
-                            source: {
-                                type: 'base64',
-                                media_type: AcpConverter.normalizeImageMimeType(mimeType),
-                                data: blobResource.blob,
-                            },
-                        });
-                    }
-                    // Non-image blobs are ignored (no good way to represent in text)
-                }
-                break;
-            }
-            case 'resource_link': {
-                // ResourceLink - format as Markdown link [@name](uri)
-                const linkBlock = block;
-                const formattedUri = AcpConverter.formatUriAsLink(linkBlock.uri, linkBlock.name);
-                content.push({ type: 'text', text: formattedUri });
-                break;
-            }
-            case 'audio': {
-                // Audio is not supported by SDK - silently ignore (following Zed pattern)
-                break;
-            }
-            default: {
-                // Unknown block type - silently ignore
-                break;
-            }
-        }
-    }
-    /**
-     * Format URI as Markdown link [@name](uri).
-     * Following Zed claude-code-acp formatUriAsLink pattern.
-     */
-    static formatUriAsLink(uri, name) {
-        try {
-            if (uri.startsWith('file://')) {
-                // Extract filename from file:// URI
-                const path = uri.slice(7);
-                const fileName = name || path.split('/').pop() || path;
-                return `[@${fileName}](${uri})`;
-            }
-            // For other URIs, use provided name or the URI itself
-            const displayName = name || uri;
-            return `[@${displayName}](${uri})`;
-        }
-        catch (_a) {
-            return uri;
-        }
-    }
-    /**
-     * Normalize MIME type to SDK-supported image types.
-     */
-    static normalizeImageMimeType(mimeType) {
-        const normalized = mimeType.toLowerCase();
-        if (normalized === 'image/jpeg' || normalized === 'image/jpg') {
-            return 'image/jpeg';
-        }
-        if (normalized === 'image/png') {
-            return 'image/png';
-        }
-        if (normalized === 'image/gif') {
-            return 'image/gif';
-        }
-        if (normalized === 'image/webp') {
-            return 'image/webp';
-        }
-        // Default to jpeg for unsupported types
-        return 'image/jpeg';
-    }
-    /**
-     * Convert SDK ImageContentBlock to ACP ImageContent format.
-     * Returns null if conversion is not possible.
-     *
-     * SDK format: { type: 'image', source: { type: 'base64', media_type, data } | { type: 'url', url } }
-     * ACP format: { type: 'image', data, mimeType, uri? }
-     */
-    static convertSdkImageToAcp(imageBlock) {
-        if (!imageBlock.source) {
-            return null;
-        }
-        if (imageBlock.source.type === 'base64') {
-            return {
-                type: 'image',
-                data: imageBlock.source.data,
-                mimeType: imageBlock.source.media_type,
-            };
-        }
-        else if (imageBlock.source.type === 'url') {
-            // For URL-based images, we cannot convert to ACP format directly
-            // as ACP ImageContent requires base64 data
-            // Return with empty data and uri for reference
-            return {
-                type: 'image',
-                data: '', // ACP requires data field, but we don't have base64 for URL images
-                mimeType: 'image/jpeg', // Default MIME type
-                uri: imageBlock.source.url,
-            };
-        }
-        return null;
-    }
-}
-exports.AcpConverter = AcpConverter;
-// Task tools that should generate plan updates instead of tool_call/tool_call_update
-AcpConverter.TASK_TOOLS_WITH_PLAN = new Set([
-    'TaskCreate', 'task_create',
-    'TaskUpdate', 'task_update',
-    'TaskList', 'task_list',
-]);
-//# sourceMappingURL=converter.js.map