@tencent-ai/agent-sdk 0.3.11 → 0.3.12

package/lib/acp/tool-converter.js

@@ -1,806 +0,0 @@
-"use strict";
-/**
- * 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.AcpTransformer = void 0;
-// ============= ACP Message Transformer (Stateless Utility) =============
-/**
- * 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.
- *
- * 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
- */
-class AcpTransformer {
-    // ============= Public API: SDK Tool Use ↔ ACP Tool Call =============
-    /**
-     * Convert SDK ToolUseContentBlock to complete session/update params
-     * Returns an object that can be spread directly into AcpMessage params
-     *
-     * This is the preferred method for creating tool call messages that comply with ACP spec.
-     *
-     * @param toolUse - SDK tool use block
-     * @param sessionId - Session ID for the message
-     * @param messageId - Optional message ID (defaults to toolUse.id)
-     * @returns Complete params object ready to be used in session/update message
-     */
-    static convertSdkToolUseToSessionUpdate(toolUse, sessionId, messageId) {
-        const toolName = toolUse.name;
-        const toolInput = toolUse.input;
-        return {
-            sessionId,
-            update: {
-                sessionUpdate: 'tool_call',
-                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),
-            },
-            _meta: {
-                'codebuddy.ai': {
-                    toolName,
-                    messageId: messageId || toolUse.id,
-                },
-            }
-        };
-    }
-    // ============= 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') {
-                content.push({
-                    type: 'content',
-                    content: { type: 'text', text: toolResult.content },
-                });
-            }
-            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 {
-            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,
-            };
-        }
-        if (acpMessage.method === 'session/cancel') {
-            return {
-                type: 'control_request',
-                request: { subtype: 'interrupt' },
-            };
-        }
-        // 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);
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Convert SDK internal message to ACP format
-     *
-     * @param message - SDK message to convert
-     * @param mode - Conversion mode:
-     *   - 'stream': Real-time streaming mode (session/prompt) - converts to incremental chunks
-     *   - 'history': History replay mode (session/load) - converts to complete messages
-     *
-     * Converts all SDK message types to corresponding ACP messages:
-     * - Stream mode: PartialAssistantMessage (stream_event) → streaming text/tool deltas
-     * - History mode: AssistantMessage/UserMessage → complete message objects
-     */
-    static sdkToAcp(message, mode = 'stream') {
-        const messages = [];
-        // ============= Stream Mode: Handle Real-time Streaming Events =============
-        if (mode === 'stream') {
-            // Process stream_event for incremental updates
-            if ('type' in message && message.type === 'stream_event') {
-                const partialMsg = message;
-                const streamEvent = partialMsg.event;
-                // Handle content_block_start: process the initial content_block (aligned with Zed)
-                if (streamEvent.type === 'content_block_start' && 'content_block' in streamEvent) {
-                    const block = streamEvent.content_block;
-                    // Handle tool_use blocks at start
-                    if (block.type === 'tool_use') {
-                        const toolMsg = {
-                            jsonrpc: '2.0',
-                            method: 'session/update',
-                            params: AcpTransformer.convertSdkToolUseToSessionUpdate(block, partialMsg.session_id || 'unknown', partialMsg.uuid),
-                        };
-                        messages.push(toolMsg);
-                    }
-                    // Handle text blocks at start (initial empty text block)
-                    else if (block.type === 'text') {
-                        messages.push({
-                            jsonrpc: '2.0',
-                            method: 'session/update',
-                            params: {
-                                sessionId: partialMsg.session_id || 'unknown',
-                                update: {
-                                    sessionUpdate: 'agent_message_chunk',
-                                    content: {
-                                        type: 'text',
-                                        text: block.text || '',
-                                    },
-                                },
-                                _meta: {
-                                    'codebuddy.ai': {
-                                        messageId: partialMsg.uuid,
-                                    },
-                                }
-                            },
-                        });
-                    }
-                }
-                // Handle content_block_delta: process incremental updates (aligned with Zed)
-                else if (streamEvent.type === 'content_block_delta') {
-                    if ('delta' in streamEvent && streamEvent.delta.type === 'text_delta') {
-                        // Convert text deltas to agent_message_chunk format (Zed naming convention)
-                        messages.push({
-                            jsonrpc: '2.0',
-                            method: 'session/update',
-                            params: {
-                                sessionId: partialMsg.session_id || 'unknown',
-                                update: {
-                                    sessionUpdate: 'agent_message_chunk',
-                                    content: {
-                                        type: 'text',
-                                        text: streamEvent.delta.text,
-                                    },
-                                },
-                                _meta: {
-                                    'codebuddy.ai': {
-                                        messageId: partialMsg.uuid,
-                                    },
-                                },
-                            },
-                        });
-                    }
-                }
-            }
-            // Handle user messages with tool results in stream mode
-            // Tool results don't stream - they arrive as complete messages
-            if ('type' in message && message.type === 'user') {
-                const userMsg = message;
-                const messageId = userMsg.uuid;
-                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
-                    for (const toolResultBlock of toolResultBlocks) {
-                        const acpResult = AcpTransformer.convertSdkToolResultToAcpToolResult(toolResultBlock);
-                        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,
-                                },
-                                _meta: {
-                                    'codebuddy.ai': {
-                                        messageId: messageId,
-                                    },
-                                }
-                            },
-                        };
-                        messages.push(updateMsg);
-                    }
-                }
-            }
-            // Skip system, tool_progress, assistant (handled by stream_event), and other internal messages in stream mode
-            return messages;
-        }
-        else {
-            // ============= History Mode: Handle Complete Messages =============
-            // Convert complete messages for history replay (for session/load)
-            // Handle assistant messages (contain tool calls and text from the model)
-            if ('type' in message && message.type === 'assistant') {
-                const assistantMsg = message;
-                const messageId = assistantMsg.message.id;
-                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 toolCallMsg = {
-                            jsonrpc: '2.0',
-                            method: 'session/update',
-                            params: AcpTransformer.convertSdkToolUseToSessionUpdate(toolUse, assistantMsg.session_id || 'unknown', messageId),
-                        };
-                        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/update',
-                            params: {
-                                sessionId: assistantMsg.session_id || 'unknown',
-                                update: {
-                                    sessionUpdate: 'agent_message_chunk',
-                                    content: {
-                                        type: 'text',
-                                        text: textContent,
-                                    },
-                                },
-                                _meta: {
-                                    'codebuddy.ai': {
-                                        messageId: messageId,
-                                    },
-                                }
-                            },
-                        });
-                    }
-                }
-            }
-            // Handle user messages with tool results or text content
-            if ('type' in message && message.type === 'user') {
-                const userMsg = message;
-                const messageId = userMsg.uuid;
-                if (userMsg.message.content) {
-                    // Handle array content (tool results and text blocks)
-                    if (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,
-                                    },
-                                    _meta: {
-                                        'codebuddy.ai': {
-                                            messageId: messageId,
-                                        },
-                                    }
-                                },
-                            };
-                            messages.push(updateMsg);
-                        }
-                        // Extract and send text content if present (for resume history)
-                        const textContent = AcpTransformer.privateExtractTextContent(userMsg.message.content);
-                        if (textContent) {
-                            messages.push({
-                                jsonrpc: '2.0',
-                                method: 'session/prompt',
-                                params: {
-                                    sessionId: userMsg.session_id || 'unknown',
-                                    prompt: [{ type: 'text', text: textContent }],
-                                    _meta: {
-                                        'codebuddy.ai': {
-                                            messageId: messageId,
-                                        },
-                                    }
-                                },
-                            });
-                        }
-                    }
-                    else if (typeof userMsg.message.content === 'string' && userMsg.message.content) {
-                        // Handle string content (for resume history)
-                        messages.push({
-                            jsonrpc: '2.0',
-                            method: 'session/prompt',
-                            params: {
-                                sessionId: userMsg.session_id || 'unknown',
-                                prompt: [{ type: 'text', text: userMsg.message.content }],
-                                _meta: {
-                                    'codebuddy.ai': {
-                                        messageId: messageId,
-                                    },
-                                }
-                            },
-                        });
-                    }
-                }
-            }
-            // 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,
-                    },
-                });
-            }
-            // 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,
-                    },
-                });
-            }
-        }
-        // 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) {
-                    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}`;
-            }
-            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';
-        }
-    }
-    // ============= 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';
-        }
-    }
-    // ============= 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;
-            }
-        }
-        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) {
-            // For file operations, only include path, not line number
-            // Line numbers should be added by specific operations that target specific lines
-            locations.push({
-                path: filePath,
-            });
-        }
-        else if (notebookPath) {
-            locations.push({ path: notebookPath });
-        }
-        else if (path && (toolName === 'Glob' || toolName === 'glob')) {
-            locations.push({ path });
-        }
-        return locations.length > 0 ? locations : undefined;
-    }
-    // ============= Private: Content Format Conversion =============
-    static formatAcpContentForSdk(toolCallContent) {
-        var _a;
-        if (toolCallContent.length === 0) {
-            return '';
-        }
-        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,
-                });
-            }
-            else if (item.type === 'content') {
-                const contentItem = item;
-                if (contentItem.content && contentItem.content.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');
-    }
-    // ============= 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;
-    }
-    // ============= 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');
-    }
-    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');
-    }
-    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,
-        };
-    }
-}
-exports.AcpTransformer = AcpTransformer;
-//# sourceMappingURL=tool-converter.js.map