@blackbox_ai/blackbox-cli-core 0.0.9 → 0.8.1

package/dist/src/encrypt/tool-parser.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { FunctionDeclaration } from '@google/genai';
+export interface ToolCall {
+    name: string;
+    arguments: Record<string, unknown>;
+    id?: string;
+}
+export interface ParseResult {
+    success: boolean;
+    normalText: string;
+    toolCalls: ToolCall[];
+    error?: string;
+}
+export interface StreamingParseResult {
+    normalText: string;
+    toolCalls: ToolCall[];
+    isComplete: boolean;
+}
+/**
+ * Enhanced tool parser for MiniMax-M2.1, DeepSeek, and Qwen
+ */
+export declare class EncryptedToolParser {
+    private streamingBuffer;
+    private readonly callsBeginToken;
+    private readonly callsEndToken;
+    private readonly callBeginToken;
+    private readonly callEndToken;
+    private readonly callSepToken;
+    private readonly mmToolCallStart;
+    private readonly mmToolCallEnd;
+    constructor();
+    /**
+     * Check if text contains tool calls
+     */
+    hasToolCall(text: string): boolean;
+    /**
+     * Check if text contains bare tool calls (tool tags without wrapper)
+     */
+    private hasBareToolCalls;
+    /**
+     * Parse complete text for tool calls
+     */
+    parseComplete(text: string, tools: FunctionDeclaration[], modelType?: string): ParseResult;
+    /**
+     * Parse MiniMax format tool calls with robust XML parsing
+     * Format: <minimax:tool_call><invoke name="func"><parameter name="arg">val</parameter></invoke></minimax:tool_call>
+     */
+    private parseMiniMaxFormat;
+    /**
+     * Parse DeepSeek format tool calls
+     */
+    private parseDeepSeekFormat;
+    /**
+     * Parse Qwen format tool calls
+     */
+    private parseQwenFormat;
+    /**
+     * Parse bare tool calls (tool tags without wrapper)
+     * Format: <tool_name>param_name="value"</tool_name> or <tool_name param_name="value" />
+     */
+    private parseBareToolCalls;
+    /**
+     * Parse pipe-delimited tool calls
+     * Format: <|tool_name|>content<|tool_name|> or <|tool_name|><|parameter_name="value">
+     */
+    private parsePipeDelimitedToolCalls;
+    /**
+     * Find the index of the first bare tool call in text
+     */
+    private findFirstBareToolCall;
+    /**
+     * Parse JSON arguments with recovery
+     */
+    private parseJsonArguments;
+    /**
+     * Parse streaming increment
+     */
+    parseStreamingIncrement(newText: string, tools: FunctionDeclaration[], modelType?: string): StreamingParseResult;
+    private hasCompleteToolCalls;
+    private extractPartialNormalText;
+    private endsWithPartialToken;
+    /**
+     * Add default values for required parameters that are missing
+     */
+    private addDefaultParameters;
+    private escapeRegex;
+    resetStreamingState(): void;
+}
+export declare function createEncryptedToolParser(): EncryptedToolParser;

package/dist/src/encrypt/tool-parser.js

@@ -0,0 +1,567 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Enhanced tool parser for MiniMax-M2.1, DeepSeek, and Qwen
+ */
+export class EncryptedToolParser {
+    streamingBuffer = '';
+    // DeepSeek format tokens
+    callsBeginToken = '<｜tool▁calls▁begin｜>';
+    callsEndToken = '<｜tool▁calls▁end｜>';
+    callBeginToken = '<｜tool▁call▁begin｜>';
+    callEndToken = '<｜tool▁call▁end｜>';
+    callSepToken = '<｜tool▁sep｜>';
+    // MiniMax format tokens (Based on M2.1 Jinja)
+    mmToolCallStart = '<minimax:tool_call>';
+    mmToolCallEnd = '</minimax:tool_call>';
+    constructor() { }
+    /**
+     * Check if text contains tool calls
+     */
+    hasToolCall(text) {
+        return text.includes(this.callsBeginToken) ||
+            text.includes('<tool_call>') || // Qwen format
+            text.includes(this.mmToolCallStart) || // MiniMax format
+            text.includes('<invoke name=') || // MiniMax invoke format
+            this.hasBareToolCalls(text); // Bare tool calls (new format)
+    }
+    /**
+     * Check if text contains bare tool calls (tool tags without wrapper)
+     */
+    hasBareToolCalls(text) {
+        // Look for patterns like <tool_name> with parameters
+        const bareToolPatterns = [
+            /<read_file[\s>]/,
+            /<glob[\s>]/,
+            /<search_files[\s>]/,
+            /<list_files[\s>]/,
+            /<create_file[\s>]/,
+            /<edit_file[\s>]/,
+            /<execute_command[\s>]/,
+            /<browser_action[\s>]/,
+            /<ask_followup_question[\s>]/,
+            /<attempt_completion[\s>]/,
+            /<new_task[\s>]/,
+            /<retrieve_knowledge[\s>]/
+        ];
+        // Also check for pipe-delimited format: <|tool_name|>
+        const pipeDelimitedPatterns = [
+            /<\|read_file\|>/,
+            /<\|glob\|>/,
+            /<\|search_files\|>/,
+            /<\|list_files\|>/,
+            /<\|create_file\|>/,
+            /<\|edit_file\|>/,
+            /<\|execute_command\|>/,
+            /<\|browser_action\|>/,
+            /<\|ask_followup_question\|>/,
+            /<\|attempt_completion\|>/,
+            /<\|new_task\|>/,
+            /<\|retrieve_knowledge\|>/
+        ];
+        return bareToolPatterns.some(pattern => pattern.test(text)) ||
+            pipeDelimitedPatterns.some(pattern => pattern.test(text));
+    }
+    /**
+     * Parse complete text for tool calls
+     */
+    parseComplete(text, tools, modelType = 'minimax') {
+        try {
+            // 1. Clean <think> tags first (MiniMax puts reasoning in <think> before tools)
+            const cleanText = text.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+            const hasToolCalls = this.hasToolCall(cleanText);
+            if (!hasToolCalls) {
+                return {
+                    success: true,
+                    normalText: cleanText,
+                    toolCalls: []
+                };
+            }
+            let toolCalls = [];
+            let normalText = '';
+            if (modelType.toLowerCase() === 'minimax') {
+                // First try standard MiniMax format
+                toolCalls = this.parseMiniMaxFormat(cleanText, tools);
+                // If no tool calls found, try bare tool call format
+                if (toolCalls.length === 0 && this.hasBareToolCalls(cleanText)) {
+                    toolCalls = this.parseBareToolCalls(cleanText, tools);
+                }
+                // If still no tool calls found, try pipe-delimited format
+                if (toolCalls.length === 0) {
+                    toolCalls = this.parsePipeDelimitedToolCalls(cleanText, tools);
+                }
+                // For MiniMax, text usually comes before the tool call block (if any)
+                // or the tool call block is standalone.
+                const toolCallIdx = cleanText.indexOf(this.mmToolCallStart);
+                const bareToolIdx = this.findFirstBareToolCall(cleanText);
+                const firstToolIdx = toolCallIdx !== -1 ? toolCallIdx : bareToolIdx;
+                normalText = firstToolIdx !== -1 ? cleanText.substring(0, firstToolIdx).trim() : cleanText.trim();
+            }
+            else if (modelType.toLowerCase() === 'deepseek') {
+                toolCalls = this.parseDeepSeekFormat(cleanText, tools);
+                const toolCallIdx = cleanText.indexOf(this.callsBeginToken);
+                normalText = toolCallIdx !== -1 ? cleanText.substring(0, toolCallIdx).trim() : cleanText.trim();
+            }
+            else {
+                toolCalls = this.parseQwenFormat(cleanText, tools);
+                const toolCallIdx = cleanText.indexOf('<tool_call>');
+                normalText = toolCallIdx !== -1 ? cleanText.substring(0, toolCallIdx).trim() : cleanText.trim();
+            }
+            return {
+                success: true,
+                normalText,
+                toolCalls
+            };
+        }
+        catch (error) {
+            console.error(`❌ [DEBUG] EncryptedToolParser.parseComplete failed:`, error);
+            return {
+                success: false,
+                normalText: text,
+                toolCalls: [],
+                error: error instanceof Error ? error.message : 'Unknown parsing error'
+            };
+        }
+    }
+    /**
+     * Parse MiniMax format tool calls with robust XML parsing
+     * Format: <minimax:tool_call><invoke name="func"><parameter name="arg">val</parameter></invoke></minimax:tool_call>
+     */
+    parseMiniMaxFormat(text, tools) {
+        const toolCalls = [];
+        // Regex to capture content inside <minimax:tool_call> tags
+        const outerRegex = /<minimax:tool_call>([\s\S]*?)<\/minimax:tool_call>/g;
+        let outerMatch;
+        while ((outerMatch = outerRegex.exec(text)) !== null) {
+            const toolBlockContent = outerMatch[1];
+            // Regex to capture individual <invoke> blocks
+            // Use [\s\S]*? for non-greedy match across lines
+            const invokeRegex = /<invoke name="([^"]+)">([\s\S]*?)<\/invoke>/g;
+            let invokeMatch;
+            while ((invokeMatch = invokeRegex.exec(toolBlockContent)) !== null) {
+                const toolName = invokeMatch[1];
+                const paramsContent = invokeMatch[2];
+                // Validate tool exists
+                if (!tools.some(t => t.name === toolName)) {
+                    continue;
+                }
+                const toolArguments = {};
+                // Regex to capture <parameter> blocks
+                const paramRegex = /<parameter name="([^"]+)">([\s\S]*?)<\/parameter>/g;
+                let paramMatch;
+                while ((paramMatch = paramRegex.exec(paramsContent)) !== null) {
+                    const paramName = paramMatch[1];
+                    const rawValue = paramMatch[2].trim();
+                    // Intelligent Type Inference based on Jinja behavior
+                    // Jinja says: {{ v | tojson ... else v }}
+                    try {
+                        // 1. Try JSON parsing first (for objects, arrays, quoted strings, true/false, numbers)
+                        toolArguments[paramName] = JSON.parse(rawValue);
+                    }
+                    catch {
+                        // 2. If JSON fails, it's likely a raw string that didn't need JSON encoding
+                        // However, we should check for simple types that might be unquoted in XML
+                        if (rawValue === 'true') {
+                            toolArguments[paramName] = true;
+                        }
+                        else if (rawValue === 'false') {
+                            toolArguments[paramName] = false;
+                        }
+                        else if (!isNaN(Number(rawValue)) && rawValue !== '') {
+                            toolArguments[paramName] = Number(rawValue);
+                        }
+                        else {
+                            toolArguments[paramName] = rawValue; // Fallback to string
+                        }
+                    }
+                }
+                // Add default values for required parameters if missing
+                this.addDefaultParameters(toolName, toolArguments);
+                toolCalls.push({
+                    name: toolName,
+                    arguments: toolArguments,
+                    id: `call_${Date.now()}_${toolCalls.length}`
+                });
+            }
+        }
+        return toolCalls;
+    }
+    /**
+     * Parse DeepSeek format tool calls
+     */
+    parseDeepSeekFormat(text, tools) {
+        const toolCalls = [];
+        // Find all tool call blocks
+        const callsBlockRegex = new RegExp(`${this.escapeRegex(this.callsBeginToken)}(.*?)${this.escapeRegex(this.callsEndToken)}`, 'gs');
+        const callsMatches = Array.from(text.matchAll(callsBlockRegex));
+        for (const callsMatch of callsMatches) {
+            const callsContent = callsMatch[1];
+            const individualCallRegex = new RegExp(`${this.escapeRegex(this.callBeginToken)}(.*?)${this.escapeRegex(this.callSepToken)}(.*?)${this.escapeRegex(this.callEndToken)}`, 'gs');
+            const individualMatches = Array.from(callsContent.matchAll(individualCallRegex));
+            for (const [, toolName, argsStr] of individualMatches) {
+                const trimmedName = toolName.trim();
+                const trimmedArgs = argsStr.trim();
+                if (!tools.some(t => t.name === trimmedName))
+                    continue;
+                try {
+                    const parsedArgs = this.parseJsonArguments(trimmedArgs);
+                    // Add default values for required parameters if missing
+                    this.addDefaultParameters(trimmedName, parsedArgs);
+                    toolCalls.push({
+                        name: trimmedName,
+                        arguments: parsedArgs,
+                        id: `call_${Date.now()}_${toolCalls.length}`
+                    });
+                }
+                catch (error) {
+                    console.warn(`Failed to parse args for ${trimmedName}`, error);
+                }
+            }
+        }
+        return toolCalls;
+    }
+    /**
+     * Parse Qwen format tool calls
+     */
+    parseQwenFormat(text, tools) {
+        const toolCalls = [];
+        const qwenRegex = /<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/g;
+        let match;
+        while ((match = qwenRegex.exec(text)) !== null) {
+            try {
+                const toolCallData = this.parseJsonArguments(match[1].trim());
+                if (toolCallData['name'] && toolCallData['arguments']) {
+                    const toolName = toolCallData['name'];
+                    if (!tools.some(t => t.name === toolName))
+                        continue;
+                    const args = toolCallData['arguments'];
+                    // Add default values for required parameters if missing
+                    this.addDefaultParameters(toolName, args);
+                    toolCalls.push({
+                        name: toolName,
+                        arguments: args,
+                        id: `call_${Date.now()}_${toolCalls.length}`
+                    });
+                }
+            }
+            catch (_e) { /* ignore */ }
+        }
+        return toolCalls;
+    }
+    /**
+     * Parse bare tool calls (tool tags without wrapper)
+     * Format: <tool_name>param_name="value"</tool_name> or <tool_name param_name="value" />
+     */
+    parseBareToolCalls(text, tools) {
+        const toolCalls = [];
+        const toolNames = tools.map(t => t.name).filter((name) => name !== undefined);
+        // Create regex pattern for each tool
+        for (const toolName of toolNames) {
+            // Pattern 1: Self-closing tags with attributes: <tool_name param="value" />
+            const selfClosingRegex = new RegExp(`<${toolName}\\s+([^>]*?)\\s*/>`, 'g');
+            let selfClosingMatch;
+            while ((selfClosingMatch = selfClosingRegex.exec(text)) !== null) {
+                const attributesString = selfClosingMatch[1];
+                const toolArguments = {};
+                // Parse attributes from self-closing tag
+                const paramRegex = /(\w+)="([^"]*)"/g;
+                let paramMatch;
+                while ((paramMatch = paramRegex.exec(attributesString)) !== null) {
+                    const paramName = paramMatch[1];
+                    const paramValue = paramMatch[2];
+                    // Type inference for parameter values
+                    if (paramValue === 'true') {
+                        toolArguments[paramName] = true;
+                    }
+                    else if (paramValue === 'false') {
+                        toolArguments[paramName] = false;
+                    }
+                    else if (!isNaN(Number(paramValue)) && paramValue !== '') {
+                        toolArguments[paramName] = Number(paramValue);
+                    }
+                    else {
+                        toolArguments[paramName] = paramValue;
+                    }
+                }
+                // Add default values for required parameters if missing
+                this.addDefaultParameters(toolName, toolArguments);
+                toolCalls.push({
+                    name: toolName,
+                    arguments: toolArguments,
+                    id: `call_${Date.now()}_${toolCalls.length}`
+                });
+            }
+            // Pattern 2: Opening/closing tags: <tool_name>content</tool_name> or <tool_name param="value">content</tool_name>
+            const openCloseRegex = new RegExp(`<${toolName}([^>]*?)>([\\s\\S]*?)<\\/${toolName}>`, 'g');
+            let openCloseMatch;
+            while ((openCloseMatch = openCloseRegex.exec(text)) !== null) {
+                const attributesString = openCloseMatch[1];
+                const toolContent = openCloseMatch[2];
+                const toolArguments = {};
+                // Parse attributes from opening tag
+                if (attributesString.trim()) {
+                    const paramRegex = /(\w+)="([^"]*)"/g;
+                    let paramMatch;
+                    while ((paramMatch = paramRegex.exec(attributesString)) !== null) {
+                        const paramName = paramMatch[1];
+                        const paramValue = paramMatch[2];
+                        // Type inference for parameter values
+                        if (paramValue === 'true') {
+                            toolArguments[paramName] = true;
+                        }
+                        else if (paramValue === 'false') {
+                            toolArguments[paramName] = false;
+                        }
+                        else if (!isNaN(Number(paramValue)) && paramValue !== '') {
+                            toolArguments[paramName] = Number(paramValue);
+                        }
+                        else {
+                            toolArguments[paramName] = paramValue;
+                        }
+                    }
+                }
+                // Parse parameters from the tool content
+                // Look for patterns like: param_name="value"
+                const contentParamRegex = /(\w+)="([^"]*)"/g;
+                let contentParamMatch;
+                while ((contentParamMatch = contentParamRegex.exec(toolContent)) !== null) {
+                    const paramName = contentParamMatch[1];
+                    const paramValue = contentParamMatch[2];
+                    // Type inference for parameter values
+                    if (paramValue === 'true') {
+                        toolArguments[paramName] = true;
+                    }
+                    else if (paramValue === 'false') {
+                        toolArguments[paramName] = false;
+                    }
+                    else if (!isNaN(Number(paramValue)) && paramValue !== '') {
+                        toolArguments[paramName] = Number(paramValue);
+                    }
+                    else {
+                        toolArguments[paramName] = paramValue;
+                    }
+                }
+                // Also look for content between tags (for tools that take content)
+                const contentMatch = toolContent.match(/^\s*([^=\s][^=]*?)\s*$/);
+                if (contentMatch && !toolContent.includes('=')) {
+                    // This is content-based tool call
+                    const content = contentMatch[1].trim();
+                    if (content) {
+                        // For content-based tools, use common parameter names
+                        if (toolName === 'execute_command') {
+                            toolArguments['command'] = content;
+                        }
+                        else if (toolName === 'ask_followup_question') {
+                            toolArguments['question'] = content;
+                        }
+                        else {
+                            toolArguments['content'] = content;
+                        }
+                    }
+                }
+                // Add default values for required parameters if missing
+                this.addDefaultParameters(toolName, toolArguments);
+                toolCalls.push({
+                    name: toolName,
+                    arguments: toolArguments,
+                    id: `call_${Date.now()}_${toolCalls.length}`
+                });
+            }
+        }
+        return toolCalls;
+    }
+    /**
+     * Parse pipe-delimited tool calls
+     * Format: <|tool_name|>content<|tool_name|> or <|tool_name|><|parameter_name="value">
+     */
+    parsePipeDelimitedToolCalls(text, tools) {
+        const toolCalls = [];
+        const toolNames = tools.map(t => t.name).filter((name) => name !== undefined);
+        for (const toolName of toolNames) {
+            // Pattern: <|tool_name|>...content...<|tool_name|> or <|tool_name|>content (without closing)
+            const pipeRegex = new RegExp(`<\\|${toolName}\\|>([\\s\\S]*?)(?:<\\|${toolName}\\||$)`, 'g');
+            let pipeMatch;
+            while ((pipeMatch = pipeRegex.exec(text)) !== null) {
+                const toolContent = pipeMatch[1];
+                const toolArguments = {};
+                // Parse parameters from pipe-delimited format: <|parameter_name="value">
+                const paramRegex = /<\|(\w+)="([^"]*)"/g;
+                let paramMatch;
+                let paramCount = 0;
+                while ((paramMatch = paramRegex.exec(toolContent)) !== null) {
+                    paramCount++;
+                    const paramName = paramMatch[1];
+                    const paramValue = paramMatch[2];
+                    // Type inference for parameter values
+                    if (paramValue === 'true') {
+                        toolArguments[paramName] = true;
+                    }
+                    else if (paramValue === 'false') {
+                        toolArguments[paramName] = false;
+                    }
+                    else if (!isNaN(Number(paramValue)) && paramValue !== '') {
+                        toolArguments[paramName] = Number(paramValue);
+                    }
+                    else {
+                        toolArguments[paramName] = paramValue;
+                    }
+                }
+                // If no parameters found in pipe format, treat the content as a direct parameter
+                if (paramCount === 0 && toolContent.trim()) {
+                    const cleanContent = toolContent.trim();
+                    // For content-based tools, use common parameter names
+                    if (toolName === 'execute_command') {
+                        toolArguments['command'] = cleanContent;
+                    }
+                    else if (toolName === 'ask_followup_question') {
+                        toolArguments['question'] = cleanContent;
+                    }
+                    else if (toolName === 'read_file') {
+                        toolArguments['path'] = cleanContent;
+                    }
+                    else if (toolName === 'glob') {
+                        toolArguments['pattern'] = cleanContent;
+                    }
+                    else {
+                        toolArguments['content'] = cleanContent;
+                    }
+                }
+                // Add default values for required parameters if missing
+                this.addDefaultParameters(toolName, toolArguments);
+                toolCalls.push({
+                    name: toolName,
+                    arguments: toolArguments,
+                    id: `call_${Date.now()}_${toolCalls.length}`
+                });
+            }
+        }
+        return toolCalls;
+    }
+    /**
+     * Find the index of the first bare tool call in text
+     */
+    findFirstBareToolCall(text) {
+        const bareToolPatterns = [
+            /<read_file[\s>]/,
+            /<glob[\s>]/,
+            /<search_files[\s>]/,
+            /<list_files[\s>]/,
+            /<create_file[\s>]/,
+            /<edit_file[\s>]/,
+            /<execute_command[\s>]/,
+            /<browser_action[\s>]/,
+            /<ask_followup_question[\s>]/,
+            /<attempt_completion[\s>]/,
+            /<new_task[\s>]/,
+            /<retrieve_knowledge[\s>]/
+        ];
+        let earliestIndex = -1;
+        for (const pattern of bareToolPatterns) {
+            const match = text.match(pattern);
+            if (match && typeof match.index === 'number') {
+                if (earliestIndex === -1 || match.index < earliestIndex) {
+                    earliestIndex = match.index;
+                }
+            }
+        }
+        return earliestIndex;
+    }
+    /**
+     * Parse JSON arguments with recovery
+     */
+    parseJsonArguments(jsonStr) {
+        try {
+            return JSON.parse(jsonStr);
+        }
+        catch {
+            try {
+                // Fix unescaped quotes and trailing commas
+                const fixed = jsonStr.replace(/([^\\])"/g, '$1\\"').replace(/,(\s*[}\]])/g, '$1');
+                return JSON.parse(fixed);
+            }
+            catch {
+                return {}; // Parsing failed
+            }
+        }
+    }
+    /**
+     * Parse streaming increment
+     */
+    parseStreamingIncrement(newText, tools, modelType = 'minimax') {
+        this.streamingBuffer += newText;
+        const hasComplete = this.hasCompleteToolCalls(this.streamingBuffer, modelType);
+        if (hasComplete) {
+            const parseResult = this.parseComplete(this.streamingBuffer, tools, modelType);
+            this.streamingBuffer = '';
+            return {
+                normalText: parseResult.normalText,
+                toolCalls: parseResult.toolCalls,
+                isComplete: true
+            };
+        }
+        return {
+            normalText: this.extractPartialNormalText(newText),
+            toolCalls: [],
+            isComplete: false
+        };
+    }
+    hasCompleteToolCalls(text, modelType) {
+        if (modelType.toLowerCase() === 'minimax') {
+            return text.includes(this.mmToolCallStart) && text.includes(this.mmToolCallEnd);
+        }
+        else if (modelType.toLowerCase() === 'deepseek') {
+            return text.includes(this.callsBeginToken) && text.includes(this.callsEndToken);
+        }
+        else {
+            return text.includes('<tool_call>') && text.includes('</tool_call>');
+        }
+    }
+    extractPartialNormalText(newText) {
+        // If buffer contains start of tool call or start of thought, block output
+        if (this.streamingBuffer.includes('<minimax') ||
+            this.streamingBuffer.includes('<invoke') ||
+            this.streamingBuffer.includes('<think') ||
+            this.streamingBuffer.includes(this.callsBeginToken) ||
+            this.streamingBuffer.includes('<tool_call>')) {
+            return '';
+        }
+        // Check partial endings to be safe
+        const tokens = ['<minimax', '<invoke', '<think', '<tool_call', '<｜tool'];
+        for (const t of tokens) {
+            if (this.endsWithPartialToken(this.streamingBuffer, t))
+                return '';
+        }
+        return newText;
+    }
+    endsWithPartialToken(text, target) {
+        for (let i = 1; i < target.length; i++) {
+            if (text.endsWith(target.substring(0, i)))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Add default values for required parameters that are missing
+     */
+    addDefaultParameters(toolName, toolArguments) {
+        // Shell/execute_command tool requires is_background parameter
+        // Check if the parameter is undefined or not present at all
+        if (toolName === 'execute_command' && !('is_background' in toolArguments)) {
+            // Default to foreground execution (false) for safety
+            toolArguments['is_background'] = false;
+        }
+    }
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    resetStreamingState() {
+        this.streamingBuffer = '';
+    }
+}
+export function createEncryptedToolParser() {
+    return new EncryptedToolParser();
+}
+//# sourceMappingURL=tool-parser.js.map