@tencent-ai/agent-sdk 0.2.2 → 0.3.0

package/lib/acp/tool-converter.js

@@ -1,436 +1,623 @@
 "use strict";
 /**
- * Tool Converter Utility
+ * ACP Message Transformer
  *
  * Converts SDK internal tool formats to ACP (Agent Client Protocol) format and vice versa.
  *
+ * Uses official @agentclientprotocol/sdk types for compatibility with the ACP specification.
+ *
  * Critical Design Principle: NO DATA LOSS
  * - SDK tool inputs are preserved completely in rawInput
  * - Tool IDs are maintained throughout the conversion
  * - Tool results are preserved with error state tracking
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertSdkToolUseToAcpToolCall = convertSdkToolUseToAcpToolCall;
-exports.convertAcpToolResultToSdk = convertAcpToolResultToSdk;
-exports.extractToolUseBlocks = extractToolUseBlocks;
-exports.extractTextContent = extractTextContent;
-// ============= Conversion: SDK Tool Use → ACP Tool Call =============
+exports.AcpTransformer = void 0;
+// ============= ACP Message Transformer (Stateless Utility) =============
 /**
- * Convert SDK ToolUseContentBlock to ACP Tool Call
- * Preserves all input data in rawInput field
+ * Bidirectional converter between SDK internal format (JSON Lines) and ACP (Agent Client Protocol) format.
+ *
+ * This is an abstract utility class with only static methods - do not instantiate.
  *
- * @param toolUse - SDK tool use block
- * @returns ACP tool call with complete data preservation
+ * Key features:
+ * - Converts SDK tool use/result to ACP format
+ * - Converts ACP messages to SDK format
+ * - Extracts and manipulates tool/text blocks
+ * - Complete data preservation in roundtrip conversions
+ * - Type-safe message routing
  */
-function convertSdkToolUseToAcpToolCall(toolUse) {
-    const toolName = toolUse.name;
-    const toolInput = toolUse.input;
-    return {
-        toolCallId: toolUse.id,
-        status: 'pending',
-        title: generateToolTitle(toolName, toolInput),
-        kind: getToolKind(toolName),
-        rawInput: toolInput,
-        content: generateToolContent(toolName, toolInput),
-        locations: extractToolLocations(toolName, toolInput),
-    };
-}
-// ============= Title Generation by Tool Type =============
-function generateToolTitle(toolName, input) {
-    switch (toolName) {
-        case 'Read':
-        case 'read': {
-            const filePath = input.file_path;
-            const offset = input.offset;
-            const limit = input.limit;
-            if (!filePath)
-                return 'Read';
-            if (limit) {
-                return `Read ${filePath} (${(offset !== null && offset !== void 0 ? offset : 0) + 1} - ${(offset !== null && offset !== void 0 ? offset : 0) + limit})`;
+class AcpTransformer {
+    // ============= Public API: SDK Tool Use ↔ ACP Tool Call =============
+    /**
+     * Convert SDK ToolUseContentBlock to ACP Tool Call
+     * Preserves all input data in rawInput field
+     */
+    static convertSdkToolUseToAcpToolCall(toolUse) {
+        const toolName = toolUse.name;
+        const toolInput = toolUse.input;
+        return {
+            toolCallId: toolUse.id,
+            status: 'pending',
+            title: AcpTransformer.generateToolTitle(toolName, toolInput),
+            kind: AcpTransformer.getToolKind(toolName),
+            rawInput: toolInput,
+            content: AcpTransformer.generateToolContent(toolName, toolInput),
+            locations: AcpTransformer.extractToolLocations(toolName, toolInput),
+        };
+    }
+    // ============= Public API: Bidirectional Tool Conversion =============
+    /**
+     * Convert ACP Tool Result to SDK ToolResultContentBlock
+     * Preserves tool_use_id and ensures error state is tracked
+     */
+    static convertAcpToolResultToSdk(toolCallId, acpResult) {
+        const isError = acpResult.status === 'failed';
+        const content = acpResult.content ? AcpTransformer.formatAcpContentForSdk(acpResult.content) : '';
+        return {
+            type: 'tool_result',
+            tool_use_id: toolCallId,
+            content: content,
+            is_error: isError,
+        };
+    }
+    /**
+     * Convert SDK ToolResultContentBlock to ACP ToolResult
+     * Enables bidirectional conversion for tool results
+     */
+    static convertSdkToolResultToAcpToolResult(toolResult) {
+        const content = [];
+        if (toolResult.content) {
+            if (typeof toolResult.content === 'string') {
+                if (toolResult.content) {
+                    content.push({
+                        type: 'content',
+                        content: { type: 'text', text: toolResult.content },
+                    });
+                }
             }
-            else if (offset) {
-                return `Read ${filePath} (from line ${(offset !== null && offset !== void 0 ? offset : 0) + 1})`;
+            else if (Array.isArray(toolResult.content)) {
+                for (const block of toolResult.content) {
+                    if ('type' in block && block.type === 'text') {
+                        const textBlock = block;
+                        content.push({
+                            type: 'content',
+                            content: { type: 'text', text: textBlock.text },
+                        });
+                    }
+                }
             }
-            return `Read ${filePath}`;
-        }
-        case 'Write':
-        case 'write': {
-            const filePath = input.file_path;
-            return filePath ? `Write ${filePath}` : 'Write';
         }
-        case 'Edit':
-        case 'edit':
-        case 'MultiEdit': {
-            const filePath = input.file_path;
-            return filePath ? `Edit \`${filePath}\`` : 'Edit';
+        return {
+            toolCallId: toolResult.tool_use_id,
+            status: toolResult.is_error ? 'failed' : 'completed',
+            content: content.length > 0 ? content : undefined,
+            rawOutput: toolResult.content,
+        };
+    }
+    // ============= Public API: Message Transformation =============
+    /**
+     * Convert ACP message to SDK internal format (JSON Lines)
+     *
+     * Converts all ACP message types to corresponding SDK messages:
+     * - session/prompt: User input → UserMessage
+     * - session/cancel: Cancellation request → ControlRequest
+     * - session/update (tool_call_update): Tool result → UserMessage with tool_result block
+     */
+    static acpToSdk(acpMessage) {
+        if (acpMessage.method === 'session/prompt') {
+            const params = acpMessage.params;
+            const sessionId = params === null || params === void 0 ? void 0 : params.sessionId;
+            const prompt = params === null || params === void 0 ? void 0 : params.prompt;
+            const content = AcpTransformer.privateExtractPromptText(prompt);
+            return {
+                type: 'user',
+                session_id: sessionId || 'unknown',
+                message: {
+                    role: 'user',
+                    content: content,
+                },
+                parent_tool_use_id: null,
+            };
         }
-        case 'Bash':
-        case 'bash': {
-            const command = input.command;
-            if (!command)
-                return 'Terminal';
-            // Escape backticks in command (replace all occurrences)
-            const escaped = command.split('`').join('\\`');
-            return `\`${escaped}\``;
+        if (acpMessage.method === 'session/cancel') {
+            return {
+                type: 'control_request',
+                request: { subtype: 'interrupt' },
+            };
         }
-        case 'BashOutput':
-        case 'bash_output':
-            return 'Tail Logs';
-        case 'KillShell':
-        case 'kill_shell':
-            return 'Kill Process';
-        case 'Glob':
-        case 'glob': {
-            let label = 'Find';
-            const path = input.path;
-            const pattern = input.pattern;
-            if (path)
-                label += ` \`${path}\``;
-            if (pattern)
-                label += ` \`${pattern}\``;
-            return label;
+        // Handle session/update with tool_call_update
+        if (acpMessage.method === 'session/update') {
+            const params = acpMessage.params;
+            const sessionId = params === null || params === void 0 ? void 0 : params.sessionId;
+            const update = params === null || params === void 0 ? void 0 : params.update;
+            if ((update === null || update === void 0 ? void 0 : update.sessionUpdate) === 'tool_call_update') {
+                // Convert tool_call_update back to SDK tool result format
+                const toolCallId = update.toolCallId;
+                const status = update.status;
+                const content = update.content;
+                if (toolCallId) {
+                    // Create an AcpToolResult from the update
+                    const acpResult = {
+                        toolCallId,
+                        status: status || 'completed',
+                        content: content,
+                    };
+                    return AcpTransformer.privateCreateToolResultMessage({ params: { sessionId } }, acpResult);
+                }
+            }
         }
-        case 'Grep':
-        case 'grep': {
-            let label = 'grep';
-            // Add flags
-            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}`;
-            // Add pattern and path
-            const pattern = input.pattern;
-            const path = input.path;
-            if (pattern)
-                label += ` "${pattern}"`;
-            if (path)
-                label += ` ${path}`;
-            return label;
+        return null;
+    }
+    /**
+     * Convert SDK internal message to ACP format
+     *
+     * Converts all SDK message types to corresponding ACP messages:
+     * - AssistantMessage with tool_use blocks → tool_call messages
+     * - AssistantMessage with text → session/text messages
+     * - Other message types are skipped
+     */
+    static sdkToAcp(message) {
+        const messages = [];
+        // Handle assistant messages (contain tool calls and text from the model)
+        if ('type' in message && message.type === 'assistant') {
+            const assistantMsg = message;
+            if (assistantMsg.message.content && Array.isArray(assistantMsg.message.content)) {
+                // Extract and convert tool use blocks
+                const toolUseBlocks = AcpTransformer.privateExtractToolUseBlocks(assistantMsg.message.content);
+                for (const toolUse of toolUseBlocks) {
+                    const acpToolCall = AcpTransformer.convertSdkToolUseToAcpToolCall(toolUse);
+                    const toolCallMsg = {
+                        jsonrpc: '2.0',
+                        method: 'tool_call',
+                        params: acpToolCall,
+                    };
+                    messages.push(toolCallMsg);
+                }
+                // Extract and send text content if present
+                const textContent = AcpTransformer.privateExtractTextContent(assistantMsg.message.content);
+                if (textContent) {
+                    messages.push({
+                        jsonrpc: '2.0',
+                        method: 'session/text',
+                        params: {
+                            content: textContent,
+                        },
+                    });
+                }
+                return messages;
+            }
         }
-        case 'WebFetch':
-        case 'web_fetch': {
-            const url = input.url;
-            return url ? `Fetch ${url}` : 'Fetch';
+        // Handle user messages with tool results
+        if ('type' in message && message.type === 'user') {
+            const userMsg = message;
+            if (userMsg.message.content && Array.isArray(userMsg.message.content)) {
+                // Look for tool result blocks
+                const toolResultBlocks = userMsg.message.content.filter((block) => typeof block === 'object' &&
+                    block !== null &&
+                    'type' in block &&
+                    block.type === 'tool_result');
+                // Convert tool results to ACP tool_call_update format (via session/update)
+                for (const toolResultBlock of toolResultBlocks) {
+                    const acpResult = AcpTransformer.convertSdkToolResultToAcpToolResult(toolResultBlock);
+                    // Wrap tool result as session/update with tool_call_update
+                    const updateMsg = {
+                        jsonrpc: '2.0',
+                        method: 'session/update',
+                        params: {
+                            sessionId: userMsg.session_id || 'unknown',
+                            update: {
+                                sessionUpdate: 'tool_call_update',
+                                toolCallId: acpResult.toolCallId,
+                                status: acpResult.status,
+                                content: acpResult.content,
+                            },
+                        },
+                    };
+                    messages.push(updateMsg);
+                }
+            }
         }
-        case 'WebSearch':
-        case 'web_search': {
-            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;
+        // Handle result messages (marks the end of a turn)
+        if ('type' in message && message.type === 'result') {
+            messages.push({
+                jsonrpc: '2.0',
+                method: 'session/result',
+                params: {
+                    sessionId: message.session_id || 'unknown',
+                    result: message,
+                },
+            });
+            return messages;
         }
-        case 'NotebookRead':
-        case 'notebook_read': {
-            const path = input.notebook_path;
-            return path ? `Read Notebook ${path}` : 'Read Notebook';
+        // Handle error messages
+        if ('type' in message && message.type === 'error') {
+            messages.push({
+                jsonrpc: '2.0',
+                method: 'session/error',
+                params: {
+                    sessionId: message.session_id || 'unknown',
+                    error: message.error,
+                },
+            });
+            return messages;
         }
-        case 'NotebookEdit':
-        case 'notebook_edit': {
-            const path = input.notebook_path;
-            return path ? `Edit Notebook ${path}` : 'Edit Notebook';
+        // Skip system, tool_progress, stream_event (partial), compact_boundary and other internal messages
+        return messages;
+    }
+    // ============= Private: Title Generation by Tool Type =============
+    static generateToolTitle(toolName, input) {
+        switch (toolName) {
+            case 'Read':
+            case 'read': {
+                const filePath = input.file_path;
+                const offset = input.offset;
+                const limit = input.limit;
+                if (!filePath)
+                    return 'Read';
+                if (limit) {
+                    return `Read ${filePath} (${(offset !== null && offset !== void 0 ? offset : 0) + 1} - ${(offset !== null && offset !== void 0 ? offset : 0) + limit})`;
+                }
+                else if (offset) {
+                    return `Read ${filePath} (from line ${(offset !== null && offset !== void 0 ? offset : 0) + 1})`;
+                }
+                return `Read ${filePath}`;
+            }
+            case 'Write':
+            case 'write': {
+                const filePath = input.file_path;
+                return filePath ? `Write ${filePath}` : 'Write';
+            }
+            case 'Edit':
+            case 'edit':
+            case 'MultiEdit': {
+                const filePath = input.file_path;
+                return filePath ? `Edit \`${filePath}\`` : 'Edit';
+            }
+            case 'Bash':
+            case 'bash': {
+                const command = input.command;
+                if (!command)
+                    return 'Terminal';
+                const escaped = command.split('`').join('\\`');
+                return `\`${escaped}\``;
+            }
+            case 'BashOutput':
+            case 'bash_output':
+                return 'Tail Logs';
+            case 'KillShell':
+            case 'kill_shell':
+                return 'Kill Process';
+            case 'Glob':
+            case 'glob': {
+                let label = 'Find';
+                const path = input.path;
+                const pattern = input.pattern;
+                if (path)
+                    label += ` \`${path}\``;
+                if (pattern)
+                    label += ` \`${pattern}\``;
+                return label;
+            }
+            case 'Grep':
+            case 'grep': {
+                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;
+            }
+            case 'WebFetch':
+            case 'web_fetch': {
+                const url = input.url;
+                return url ? `Fetch ${url}` : 'Fetch';
+            }
+            case 'WebSearch':
+            case 'web_search': {
+                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;
+            }
+            case 'NotebookRead':
+            case 'notebook_read': {
+                const path = input.notebook_path;
+                return path ? `Read Notebook ${path}` : 'Read Notebook';
+            }
+            case 'NotebookEdit':
+            case 'notebook_edit': {
+                const path = input.notebook_path;
+                return path ? `Edit Notebook ${path}` : 'Edit Notebook';
+            }
+            case 'Task':
+            case 'task': {
+                const description = input.description;
+                return description || 'Task';
+            }
+            case 'TodoWrite':
+            case 'todo_write': {
+                return 'Update TODOs';
+            }
+            case 'AskUserQuestion':
+            case 'ask_user_question':
+                return 'Ask User';
+            case 'SlashCommand':
+            case 'slash_command': {
+                const command = input.command;
+                return command ? `Run: ${command}` : 'Slash Command';
+            }
+            case 'Skill':
+            case 'skill': {
+                const command = input.command;
+                return command ? `Skill: ${command}` : 'Skill';
+            }
+            case 'LSP':
+            case 'lsp': {
+                const operation = input.operation;
+                return operation ? `LSP: ${operation}` : 'LSP';
+            }
+            case 'EnterPlanMode':
+            case 'enter_plan_mode':
+                return 'Enter Plan Mode';
+            case 'ExitPlanMode':
+            case 'exit_plan_mode':
+                return 'Exit Plan Mode';
+            case 'TaskOutput':
+            case 'task_output':
+                return 'Get Task Output';
+            default:
+                return toolName || 'Unknown Tool';
         }
-        case 'Task':
-        case 'task': {
-            const description = input.description;
-            return description || 'Task';
+    }
+    // ============= Private: Tool Kind Classification =============
+    static getToolKind(toolName) {
+        switch (toolName) {
+            case 'Read':
+            case 'read':
+            case 'NotebookRead':
+            case 'notebook_read':
+            case 'Glob':
+            case 'glob':
+                return 'read';
+            case 'Write':
+            case 'write':
+            case 'Edit':
+            case 'edit':
+            case 'MultiEdit':
+            case 'NotebookEdit':
+            case 'notebook_edit':
+                return 'edit';
+            case 'Bash':
+            case 'bash':
+            case 'BashOutput':
+            case 'bash_output':
+            case 'KillShell':
+            case 'kill_shell':
+            case 'TaskOutput':
+            case 'task_output':
+                return 'execute';
+            case 'Grep':
+            case 'grep':
+            case 'WebSearch':
+            case 'web_search':
+                return 'search';
+            case 'WebFetch':
+            case 'web_fetch':
+                return 'fetch';
+            case 'Task':
+            case 'task':
+            case 'TodoWrite':
+            case 'todo_write':
+            case 'EnterPlanMode':
+            case 'enter_plan_mode':
+            case 'ExitPlanMode':
+            case 'exit_plan_mode':
+                return 'think';
+            default:
+                return 'other';
         }
-        case 'TodoWrite':
-        case 'todo_write': {
-            return 'Update TODOs';
+    }
+    // ============= Private: Content Generation by Tool Type =============
+    static generateToolContent(toolName, input) {
+        const content = [];
+        switch (toolName) {
+            case 'Edit':
+            case 'edit':
+            case '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,
+                    });
+                }
+                break;
+            }
+            case 'Bash':
+            case 'bash': {
+                const description = input.description;
+                if (description) {
+                    content.push({
+                        type: 'content',
+                        content: { type: 'text', text: description },
+                    });
+                }
+                break;
+            }
+            case 'Task':
+            case 'task': {
+                const prompt = input.prompt;
+                if (prompt) {
+                    content.push({
+                        type: 'content',
+                        content: { type: 'text', text: prompt },
+                    });
+                }
+                break;
+            }
+            case 'WebFetch':
+            case 'web_fetch': {
+                const prompt = input.prompt;
+                if (prompt) {
+                    content.push({
+                        type: 'content',
+                        content: { type: 'text', text: prompt },
+                    });
+                }
+                break;
+            }
         }
-        case 'AskUserQuestion':
-        case 'ask_user_question':
-            return 'Ask User';
-        case 'SlashCommand':
-        case 'slash_command': {
-            const command = input.command;
-            return command ? `Run: ${command}` : 'Slash Command';
+        return content.length > 0 ? content : undefined;
+    }
+    // ============= Private: Location Extraction by Tool Type =============
+    static extractToolLocations(toolName, input) {
+        const locations = [];
+        const filePath = input.file_path;
+        const notebookPath = input.notebook_path;
+        const path = input.path;
+        if (filePath) {
+            locations.push({
+                path: filePath,
+                line: input.offset,
+            });
         }
-        case 'Skill':
-        case 'skill': {
-            const command = input.command;
-            return command ? `Skill: ${command}` : 'Skill';
+        else if (notebookPath) {
+            locations.push({ path: notebookPath });
         }
-        case 'LSP':
-        case 'lsp': {
-            const operation = input.operation;
-            return operation ? `LSP: ${operation}` : 'LSP';
+        else if (path && (toolName === 'Glob' || toolName === 'glob')) {
+            locations.push({ path });
         }
-        case 'EnterPlanMode':
-        case 'enter_plan_mode':
-            return 'Enter Plan Mode';
-        case 'ExitPlanMode':
-        case 'exit_plan_mode':
-            return 'Exit Plan Mode';
-        case 'TaskOutput':
-        case 'task_output':
-            return 'Get Task Output';
-        default:
-            return toolName || 'Unknown Tool';
+        return locations.length > 0 ? locations : undefined;
     }
-}
-// ============= Tool Kind Classification =============
-function getToolKind(toolName) {
-    switch (toolName) {
-        case 'Read':
-        case 'read':
-        case 'NotebookRead':
-        case 'notebook_read':
-        case 'Glob':
-        case 'glob':
-            return 'read';
-        case 'Write':
-        case 'write':
-        case 'Edit':
-        case 'edit':
-        case 'MultiEdit':
-        case 'NotebookEdit':
-        case 'notebook_edit':
-            return 'edit';
-        case 'Bash':
-        case 'bash':
-        case 'BashOutput':
-        case 'bash_output':
-        case 'KillShell':
-        case 'kill_shell':
-        case 'TaskOutput':
-        case 'task_output':
-            return 'execute';
-        case 'Grep':
-        case 'grep':
-        case 'WebSearch':
-        case 'web_search':
-            return 'search';
-        case 'WebFetch':
-        case 'web_fetch':
-            return 'fetch';
-        case 'Task':
-        case 'task':
-        case 'TodoWrite':
-        case 'todo_write':
-        case 'EnterPlanMode':
-        case 'enter_plan_mode':
-        case 'ExitPlanMode':
-        case 'exit_plan_mode':
-            return 'think';
-        default:
-            return 'other';
-    }
-}
-// ============= Content Generation by Tool Type =============
-function generateToolContent(toolName, input) {
-    switch (toolName) {
-        case 'Edit':
-        case 'edit':
-        case 'MultiEdit': {
-            const filePath = input.file_path;
-            const oldString = input.old_string;
-            const newString = input.new_string;
-            if (filePath && oldString !== undefined && newString !== undefined) {
-                return [{
-                        type: 'diff',
-                        content: {
-                            path: filePath,
-                            oldText: oldString || null,
-                            newText: newString,
-                        },
-                    }];
-            }
-            return undefined;
+    // ============= Private: Content Format Conversion =============
+    static formatAcpContentForSdk(toolCallContent) {
+        var _a;
+        if (toolCallContent.length === 0) {
+            return '';
         }
-        case 'Bash':
-        case 'bash': {
-            const description = input.description;
-            if (description) {
-                return [{
-                        type: 'text',
-                        content: { type: 'text', text: description },
-                    }];
+        const blocks = [];
+        for (const item of toolCallContent) {
+            if (item.type === 'diff') {
+                const diff = item;
+                const diffText = `--- ${diff.path}
++++ ${diff.path}
+${AcpTransformer.formatDiffHunk((_a = diff.oldText) !== null && _a !== void 0 ? _a : null, diff.newText)}`;
+                blocks.push({
+                    type: 'text',
+                    text: diffText,
+                });
             }
-            return undefined;
-        }
-        case 'Task':
-        case 'task': {
-            const prompt = input.prompt;
-            if (prompt) {
-                return [{
+            else if (item.type === 'content') {
+                const contentItem = item;
+                if (contentItem.content && contentItem.content.type === 'text' && contentItem.content.text) {
+                    blocks.push({
                         type: 'text',
-                        content: { type: 'text', text: prompt },
-                    }];
+                        text: contentItem.content.text,
+                    });
+                }
             }
-            return undefined;
-        }
-        case 'WebFetch':
-        case 'web_fetch': {
-            const prompt = input.prompt;
-            if (prompt) {
-                return [{
+            else if (item.type === 'terminal') {
+                const terminalItem = item;
+                if (terminalItem.terminalId) {
+                    blocks.push({
                         type: 'text',
-                        content: { type: 'text', text: prompt },
-                    }];
+                        text: `[Terminal: ${terminalItem.terminalId}]`,
+                    });
+                }
             }
-            return undefined;
         }
-        default:
-            return undefined;
+        if (blocks.length === 1 && blocks[0].type === 'text') {
+            return blocks[0].text;
+        }
+        return blocks.length > 0 ? blocks : '';
     }
-}
-// ============= Location Extraction by Tool Type =============
-function extractToolLocations(toolName, input) {
-    const locations = [];
-    // File path based tools
-    const filePath = input.file_path;
-    const notebookPath = input.notebook_path;
-    const path = input.path;
-    // Add file location if present
-    if (filePath) {
-        locations.push({
-            path: filePath,
-            line: input.offset,
-        });
+    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');
     }
-    else if (notebookPath) {
-        locations.push({ path: notebookPath });
+    // ============= Private: Prompt and Result Helpers =============
+    static privateExtractPromptText(prompt) {
+        let content = '';
+        if (prompt && Array.isArray(prompt)) {
+            for (const block of prompt) {
+                if (block.type === 'text' && block.text) {
+                    content += block.text;
+                }
+            }
+        }
+        return content;
     }
-    else if (path && (toolName === 'Glob' || toolName === 'glob')) {
-        locations.push({ path });
+    // ============= Private: Content Block Extraction =============
+    static privateExtractToolUseBlocks(contentBlocks) {
+        if (!Array.isArray(contentBlocks))
+            return [];
+        return contentBlocks.filter((block) => typeof block === 'object' &&
+            block !== null &&
+            'type' in block &&
+            block.type === 'tool_use');
     }
-    return locations.length > 0 ? locations : undefined;
-}
-// ============= Conversion: ACP Tool Result → SDK Tool Result =============
-/**
- * Convert ACP Tool Result to SDK ToolResultContentBlock
- * Preserves tool_use_id and ensures error state is tracked
- *
- * @param toolCallId - Original tool call ID
- * @param acpResult - ACP tool result
- * @returns SDK ToolResultContentBlock
- */
-function convertAcpToolResultToSdk(toolCallId, acpResult) {
-    const isError = acpResult.status === 'failed';
-    const content = acpResult.content ? formatAcpContentForSdk(acpResult.content) : '';
-    return {
-        type: 'tool_result',
-        tool_use_id: toolCallId,
-        content: content,
-        is_error: isError,
-    };
-}
-// ============= Content Format Conversion =============
-/**
- * Convert ACP content format to SDK content format
- */
-function formatAcpContentForSdk(acpContent) {
-    if (acpContent.length === 0) {
-        return '';
-    }
-    // If all content is text type, combine into single string
-    if (acpContent.every(c => c.type === 'text')) {
-        return acpContent
-            .map(c => {
-            if (c.content && 'text' in c.content) {
-                return c.content.text;
-            }
+    static privateExtractTextContent(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');
     }
-    // Otherwise, convert to ContentBlock array
-    const blocks = [];
-    for (const item of acpContent) {
-        const block = convertAcpContentToContentBlock(item);
-        if (block) {
-            blocks.push(block);
-        }
-    }
-    return blocks.length > 0 ? blocks : '';
-}
-/**
- * Convert single ACP content item to ContentBlock
- */
-function convertAcpContentToContentBlock(acpContent) {
-    if (acpContent.type === 'text' && acpContent.content && 'text' in acpContent.content) {
-        const textBlock = {
-            type: 'text',
-            text: acpContent.content.text,
-        };
-        return textBlock;
-    }
-    if (acpContent.type === 'diff' && acpContent.content && 'path' in acpContent.content) {
-        // For now, convert diff back to text representation
-        const diff = acpContent.content;
-        const diffText = `--- ${diff.path}
-+++ ${diff.path}
-${formatDiffHunk(diff.oldText, diff.newText)}`;
-        const textBlock = {
-            type: 'text',
-            text: diffText,
+    static privateCreateToolResultMessage(acpMessage, acpResult) {
+        var _a;
+        const toolResultBlock = AcpTransformer.convertAcpToolResultToSdk(acpResult.toolCallId, acpResult);
+        return {
+            type: 'user',
+            session_id: ((_a = acpMessage.params) === null || _a === void 0 ? void 0 : _a.sessionId) || 'unknown',
+            message: {
+                role: 'user',
+                content: [toolResultBlock],
+            },
+            parent_tool_use_id: acpResult.toolCallId,
         };
-        return textBlock;
     }
-    return null;
-}
-/**
- * Format diff hunks for display
- */
-function formatDiffHunk(oldText, newText) {
-    const oldLines = oldText ? oldText.split('\n') : [];
-    const newLines = newText.split('\n');
-    const hunks = [];
-    hunks.push(`@@ -1,${oldLines.length} +1,${newLines.length} @@`);
-    // Add old lines
-    for (const line of oldLines) {
-        hunks.push(`-${line}`);
-    }
-    // Add new lines
-    for (const line of newLines) {
-        hunks.push(`+${line}`);
-    }
-    return hunks.join('\n');
-}
-// ============= Helper: Extract Tool Use Blocks =============
-/**
- * Extract tool use blocks from content blocks array
- */
-function extractToolUseBlocks(contentBlocks) {
-    if (!Array.isArray(contentBlocks))
-        return [];
-    return contentBlocks.filter((block) => typeof block === 'object' &&
-        block !== null &&
-        'type' in block &&
-        block.type === 'tool_use');
-}
-/**
- * Extract text content from content blocks array
- */
-function 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');
 }
+exports.AcpTransformer = AcpTransformer;
 //# sourceMappingURL=tool-converter.js.map