@blackbox_ai/blackbox-cli-core 0.0.9 → 0.8.1

package/dist/src/core/encryptedGeminiClientBridge.js

@@ -0,0 +1,808 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { EncryptedTurn } from './encryptedTurn.js';
+import { getCoreSystemPrompt } from './prompts.js';
+import { ApprovalMode } from '../config/config.js';
+import { getEnvironmentContext } from '../utils/environmentContext.js';
+import { formatThinkContent as formatThinkContentUtil } from '../utils/textCleaning.js';
+import { MessageTruncator } from '../utils/messageTruncator.js';
+/**
+ * EncryptedGeminiClientBridge provides a bridge between the encrypted provider
+ * and the existing GeminiClient interface, enabling tool execution through
+ * the event-based system that the UI layer expects.
+ */
+export class EncryptedGeminiClientBridge {
+    encryptedService;
+    config;
+    tools = [];
+    history = [];
+    pendingToolResults = new Map();
+    messageTruncator;
+    constructor(encryptedService, config) {
+        this.encryptedService = encryptedService;
+        this.config = config;
+        this.messageTruncator = new MessageTruncator(config?.getDebugMode() ?? false);
+    }
+    /**
+     * Set the available tools for this client
+     */
+    setTools(tools) {
+        this.tools = tools || [];
+    }
+    /**
+     * Add content to history
+     */
+    addHistory(content) {
+        this.history.push(content);
+    }
+    /**
+     * Get current history
+     */
+    getHistory() {
+        return [...this.history];
+    }
+    /**
+     * Send a message and get streaming events that match the regular GeminiClient interface
+     * This is the key method that bridges the encrypted provider with the event system
+     */
+    async *sendMessageStream(request, signal, prompt_id) {
+        try {
+            // Convert request to text
+            const messageText = this.convertRequestToText(request);
+            // Get tools from config directly instead of relying on stored tools
+            let currentTools = [];
+            if (this.config) {
+                try {
+                    const toolRegistry = this.config.getToolRegistry();
+                    if (toolRegistry) {
+                        currentTools = toolRegistry.getFunctionDeclarations();
+                        // Update our stored tools to match
+                        this.tools = currentTools;
+                    }
+                }
+                catch (error) {
+                    // Silently handle tool registry access errors
+                    console.error(error);
+                }
+            }
+            // Create tools system prompt if we have tools
+            const toolsSystemPrompt = EncryptedTurn.createToolsSystemPrompt(currentTools || [], 'minimax');
+            // CRITICAL FIX: Add the current user message to history before converting
+            // This ensures the user message is included in the message history
+            const currentUserMessage = {
+                role: 'user',
+                parts: [{ text: messageText }]
+            };
+            // Create a temporary history that includes the current message
+            const historyWithCurrentMessage = [...this.history, currentUserMessage];
+            // Convert history to message format (including current user message)
+            const messageHistory = await this.convertHistoryToMessageFormat(historyWithCurrentMessage, toolsSystemPrompt);
+            // Initialize the encrypted service if needed
+            if (!this.encryptedService.isReady()) {
+                await this.encryptedService.initialize(toolsSystemPrompt);
+            }
+            // Send message through encrypted service
+            const encryptedStream = await this.encryptedService.sendMessage(messageText, messageHistory);
+            // Read the entire response first to detect tool calls
+            const reader = encryptedStream.getReader();
+            const decoder = new TextDecoder();
+            let fullResponse = '';
+            // BUFFERING LOGIC START
+            let streamBuffer = '';
+            let inToolCall = false;
+            // Safety margin: larger than the longest possible token + potential function name length
+            const SAFETY_MARGIN = 60;
+            try {
+                while (true) {
+                    if (signal.aborted) {
+                        yield { type: 'user_cancelled' };
+                        return;
+                    }
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    const chunk = decoder.decode(value, { stream: true });
+                    fullResponse += chunk;
+                    streamBuffer += chunk;
+                    // Loop to process the buffer as much as possible
+                    let processing = true;
+                    while (processing) {
+                        processing = false; // Default to stopping unless we find a token
+                        if (inToolCall) {
+                            // WE ARE INSIDE A TOOL CALL: Hunt for END tokens only
+                            const endTokens = [
+                                '</minimax:tool_call>', // MiniMax format - this is the REAL end
+                                '<｜tool▁calls▁end｜>', // DeepSeek format
+                                '</tool_call>', // Qwen format
+                                '</think>', // Think end (can appear in tool calls)
+                                // Bare tool call end tokens
+                                '</read_file>',
+                                '</read_data_file>',
+                                '</glob>',
+                                '</search_files>',
+                                '</list_files>',
+                                '</create_file>',
+                                '</edit_file>',
+                                '</execute_command>',
+                                '</browser_action>',
+                                '</ask_followup_question>',
+                                '</attempt_completion>',
+                                '</new_task>',
+                                '</retrieve_knowledge>',
+                                '</read_many_files>'
+                            ];
+                            let endIdx = -1;
+                            let tokenLen = 0;
+                            // Find earliest end token
+                            for (const token of endTokens) {
+                                const idx = streamBuffer.indexOf(token);
+                                if (idx !== -1 && (endIdx === -1 || idx < endIdx)) {
+                                    endIdx = idx;
+                                    tokenLen = token.length;
+                                }
+                            }
+                            if (endIdx !== -1) {
+                                // Found end token!
+                                // Discard everything up to the end of this token (hiding the tool call)
+                                streamBuffer = streamBuffer.substring(endIdx + tokenLen);
+                                inToolCall = false;
+                                processing = true; // Loop again to see if there is text after
+                            }
+                        }
+                        else {
+                            // WE ARE IN TEXT MODE: Hunt for START tokens (or rogue END tokens)
+                            const startTokens = [
+                                '<minimax:tool_call>', // MiniMax format
+                                '<invoke name=', // MiniMax invoke start
+                                '<｜tool▁calls▁begin｜>', // DeepSeek format
+                                '<｜tool▁call▁begin｜>', // DeepSeek format
+                                '<tool_call>', // Qwen format
+                                '<think>', // Think tags
+                            ];
+                            const sepToken = '<｜tool▁sep｜>'; // Special case: hides preceding word
+                            // Also look for standalone end tokens to clean up artifacts
+                            // CRITICAL FIX: Don't treat </invoke> as orphaned - it's part of valid tool calls
+                            const endTokens = [
+                                '</minimax:tool_call>', // MiniMax format
+                                '<｜tool▁call▁end｜>', // DeepSeek format
+                                '<｜tool▁calls▁end｜>', // DeepSeek format
+                                '</tool_call>', // Qwen format
+                                '</think>', // Think end
+                            ];
+                            let matchIdx = -1;
+                            let matchLen = 0;
+                            let matchType = null;
+                            // Helper to find earliest token
+                            const check = (idx, len, type) => {
+                                if (idx !== -1 && (matchIdx === -1 || idx < matchIdx)) {
+                                    matchIdx = idx;
+                                    matchLen = len;
+                                    matchType = type;
+                                }
+                            };
+                            // Check start tokens
+                            for (const token of startTokens) {
+                                const idx = streamBuffer.indexOf(token);
+                                if (token === '<think>') {
+                                    check(idx, token.length, 'think');
+                                }
+                                else {
+                                    check(idx, token.length, 'start');
+                                }
+                            }
+                            // CRITICAL FIX: Also check for bare tool call start tokens (both opening and self-closing)
+                            const bareToolNames = [
+                                'read_file',
+                                'read_data_file',
+                                'glob',
+                                'search_files',
+                                'list_files',
+                                'create_file',
+                                'edit_file',
+                                'execute_command',
+                                'browser_action',
+                                'ask_followup_question',
+                                'attempt_completion',
+                                'new_task',
+                                'retrieve_knowledge',
+                                'read_many_files'
+                            ];
+                            for (const toolName of bareToolNames) {
+                                // Check for opening tag format: <tool_name>
+                                const openingTag = `<${toolName}>`;
+                                const openingIdx = streamBuffer.indexOf(openingTag);
+                                if (openingIdx !== -1) {
+                                    check(openingIdx, openingTag.length, 'start');
+                                }
+                                // Check for self-closing tag format: <tool_name ... />
+                                const selfClosingPattern = new RegExp(`<${toolName}\\s[^>]*\\s*/>`, 'g');
+                                const selfClosingMatch = selfClosingPattern.exec(streamBuffer);
+                                if (selfClosingMatch && typeof selfClosingMatch.index === 'number') {
+                                    check(selfClosingMatch.index, selfClosingMatch[0].length, 'start');
+                                }
+                                // Check for opening tag with attributes: <tool_name ...>
+                                const attributePattern = new RegExp(`<${toolName}\\s[^>]*>`, 'g');
+                                const attributeMatch = attributePattern.exec(streamBuffer);
+                                if (attributeMatch && typeof attributeMatch.index === 'number') {
+                                    check(attributeMatch.index, attributeMatch[0].length, 'start');
+                                }
+                                // Check for pipe-delimited format: <|tool_name|>
+                                const pipeDelimitedTag = `<|${toolName}|>`;
+                                const pipeIdx = streamBuffer.indexOf(pipeDelimitedTag);
+                                if (pipeIdx !== -1) {
+                                    check(pipeIdx, pipeDelimitedTag.length, 'start');
+                                }
+                            }
+                            // Check separator token
+                            const idxSep = streamBuffer.indexOf(sepToken);
+                            check(idxSep, sepToken.length, 'sep');
+                            // Check end tokens
+                            for (const token of endTokens) {
+                                const idx = streamBuffer.indexOf(token);
+                                check(idx, token.length, 'end');
+                            }
+                            if (matchIdx !== -1 && matchType !== null) {
+                                if (matchType === 'think') {
+                                    // Handle think blocks - find the end
+                                    const thinkEnd = streamBuffer.indexOf('</think>', matchIdx);
+                                    if (thinkEnd !== -1) {
+                                        // Complete think block - yield text before, then show think content
+                                        const textToYield = streamBuffer.substring(0, matchIdx);
+                                        if (textToYield && textToYield.length > 0) {
+                                            yield { type: 'content', value: textToYield };
+                                        }
+                                        // Extract and format think content differently from assistant messages
+                                        const thinkContent = streamBuffer.substring(matchIdx + matchLen, thinkEnd);
+                                        if (thinkContent.trim().length > 0) {
+                                            const formattedThinkContent = this.formatThinkContent(thinkContent.trim());
+                                            // Add a single newline after think content to separate it from following content
+                                            const thinkWithNewline = formattedThinkContent + '\n';
+                                            yield { type: 'content', value: thinkWithNewline };
+                                        }
+                                        // Remove the think block and any trailing whitespace/newlines
+                                        let afterThink = streamBuffer.substring(thinkEnd + '</think>'.length);
+                                        // Clean up any excessive newlines that might follow the think block
+                                        afterThink = afterThink.replace(/^\s*\n+/, '\n');
+                                        streamBuffer = afterThink;
+                                        processing = true;
+                                    }
+                                    else {
+                                        // Incomplete think block - wait for more data
+                                        if (streamBuffer.length > SAFETY_MARGIN) {
+                                            const yieldLen = matchIdx;
+                                            if (yieldLen > 0) {
+                                                const textToYield = streamBuffer.substring(0, yieldLen);
+                                                if (textToYield.length > 0) {
+                                                    yield { type: 'content', value: textToYield };
+                                                }
+                                                streamBuffer = streamBuffer.substring(yieldLen);
+                                            }
+                                        }
+                                        processing = false;
+                                    }
+                                }
+                                else if (matchType === 'sep') {
+                                    // Special case: "FunctionName<sep>Args"
+                                    // We need to remove the "FunctionName" which is likely at the end of the text before matchIdx
+                                    let nameStart = matchIdx;
+                                    // Backtrack to find the start of the function name
+                                    while (nameStart > 0 && /[a-zA-Z0-9_]/.test(streamBuffer[nameStart - 1])) {
+                                        nameStart--;
+                                    }
+                                    // Yield text BEFORE the function name
+                                    const textToYield = streamBuffer.substring(0, nameStart);
+                                    if (textToYield && textToYield.length > 0) {
+                                        yield { type: 'content', value: textToYield };
+                                    }
+                                    // Remove the name + token from buffer and switch to tool mode
+                                    streamBuffer = streamBuffer.substring(matchIdx + matchLen);
+                                    inToolCall = true;
+                                    processing = true;
+                                }
+                                else if (matchType === 'end') {
+                                    // Found a standalone end token (hallucination/orphan). 
+                                    // Yield text before it, discard token, stay in text mode.
+                                    const textToYield = streamBuffer.substring(0, matchIdx);
+                                    if (textToYield && textToYield.length > 0) {
+                                        yield { type: 'content', value: textToYield };
+                                    }
+                                    streamBuffer = streamBuffer.substring(matchIdx + matchLen);
+                                    processing = true;
+                                }
+                                else if (matchType === 'start') {
+                                    // Normal Start Token
+                                    // Yield everything before the token
+                                    const textToYield = streamBuffer.substring(0, matchIdx);
+                                    if (textToYield && textToYield.length > 0) {
+                                        yield { type: 'content', value: textToYield };
+                                    }
+                                    // Remove token, switch to tool mode
+                                    streamBuffer = streamBuffer.substring(matchIdx + matchLen);
+                                    inToolCall = true;
+                                    processing = true;
+                                }
+                            }
+                            else {
+                                // No tokens found in buffer.
+                                // Keep the last SAFETY_MARGIN chars in buffer to handle split tokens.
+                                if (streamBuffer.length > SAFETY_MARGIN) {
+                                    const yieldLen = streamBuffer.length - SAFETY_MARGIN;
+                                    const textToYield = streamBuffer.substring(0, yieldLen);
+                                    if (textToYield && textToYield.length > 0) {
+                                        yield { type: 'content', value: textToYield };
+                                    }
+                                    streamBuffer = streamBuffer.substring(yieldLen);
+                                }
+                                // Stop processing loop, wait for more data
+                                processing = false;
+                            }
+                        }
+                    }
+                }
+                // STREAM FINISHED: Flush remaining buffer
+                // Only flush if we are NOT in a tool call.
+                if (!inToolCall && streamBuffer.length > 0) {
+                    yield { type: 'content', value: streamBuffer };
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            // Add the user message to history after successful send
+            this.addHistory(currentUserMessage);
+            // Add the model response to history
+            const modelResponse = {
+                role: 'model',
+                parts: [{ text: fullResponse }]
+            };
+            this.addHistory(modelResponse);
+            // CRITICAL FIX: Process tool calls IMMEDIATELY after streaming completes
+            // This ensures tool call events are emitted while the generator is still active
+            const encryptedTurn = new EncryptedTurn(this, prompt_id);
+            // Check if we have tool calls
+            if (currentTools && currentTools.length > 0 && this.containsToolCalls(fullResponse)) {
+                // Process the response and emit tool call events
+                // IMPORTANT: We must yield ALL events from processEncryptedResponse
+                for await (const event of encryptedTurn.processEncryptedResponse(fullResponse, true)) {
+                    // Yield ALL events including tool_call_request and finished
+                    // Don't skip any events - the UI needs them all
+                    if (event.type === 'tool_call_request') {
+                        yield event;
+                    }
+                    else if (event.type === 'finished') {
+                        // Yield the finished event from processEncryptedResponse
+                        yield event;
+                        // Don't yield another finished event below
+                        return;
+                    }
+                    // Skip content events since we already streamed them
+                }
+            }
+            else {
+                // No tool calls, just emit finished event
+                yield {
+                    type: 'finished',
+                    value: 'STOP'
+                };
+            }
+        }
+        catch (error) {
+            console.error('❌ EncryptedGeminiClientBridge.sendMessageStream failed:', error);
+            yield {
+                type: 'error',
+                value: {
+                    error: {
+                        message: error instanceof Error ? error.message : 'Unknown error in encrypted provider',
+                        status: 500
+                    }
+                }
+            };
+        }
+    }
+    /**
+     * Convert PartListUnion request to text string
+     */
+    convertRequestToText(request) {
+        if (typeof request === 'string') {
+            return request;
+        }
+        if (Array.isArray(request)) {
+            return request
+                .map(part => {
+                if (typeof part === 'string') {
+                    return part;
+                }
+                else if (part && typeof part === 'object' && 'text' in part) {
+                    return part.text;
+                }
+                else if (part && typeof part === 'object' && 'functionResponse' in part) {
+                    // Handle function response parts
+                    const funcResp = part.functionResponse;
+                    return `Function ${funcResp?.name} returned: ${JSON.stringify(funcResp?.response)}`;
+                }
+                return '';
+            })
+                .join('\n');
+        }
+        return String(request);
+    }
+    /**
+     * Convert Content[] history to message format expected by EncryptedChatService
+     * Now uses TOKEN-BASED truncation like the normal Blackbox provider
+     */
+    async convertHistoryToMessageFormat(history, toolsSystemPrompt = '') {
+        const messages = history.map(content => {
+            // CRITICAL FIX: Safely handle undefined or missing parts
+            // Ensure parts is always an array before filtering
+            let parts = content.parts;
+            // Validate that parts exists and is an array
+            if (!parts || !Array.isArray(parts)) {
+                console.warn('⚠️ [EncryptedGeminiClientBridge] Content has invalid or missing parts:', content);
+                parts = [];
+            }
+            // Extract text from parts
+            const textParts = parts.filter((part) => typeof part === 'object' && part !== null && 'text' in part);
+            const text = textParts.map(part => part.text).join('\n');
+            // Map roles
+            const role = content.role === 'model' ? 'assistant' : content.role;
+            return { role, content: text };
+        });
+        // Get the core system prompt like Gemini does
+        let coreSystemPrompt = 'You are a helpful AI assistant.';
+        let environmentContext = '';
+        if (this.config) {
+            const userMemory = this.config.getUserMemory();
+            coreSystemPrompt = getCoreSystemPrompt(userMemory, {}, this.config.getModel(), this.config.getApprovalMode() === ApprovalMode.YOLO);
+            // CRITICAL FIX: Get environment context like regular Gemini does
+            const envParts = await getEnvironmentContext(this.config);
+            environmentContext = envParts.map(part => typeof part === 'string' ? part : part.text || '').join('\n');
+        }
+        // Combine core system prompt with environment context (like regular Gemini)
+        const systemPromptWithEnvironment = environmentContext.trim()
+            ? `${coreSystemPrompt}\n\n${environmentContext}`
+            : coreSystemPrompt;
+        // Then combine with tools system prompt
+        const fullSystemPrompt = toolsSystemPrompt
+            ? `${systemPromptWithEnvironment}\n\n${toolsSystemPrompt}`
+            : systemPromptWithEnvironment;
+        // Add or update system message
+        if (messages.length > 0 && messages[0].role === 'system') {
+            // Replace existing system message with our full system prompt
+            messages[0].content = fullSystemPrompt;
+        }
+        else {
+            // Insert system message at the beginning
+            const systemMessage = {
+                role: 'system',
+                content: fullSystemPrompt
+            };
+            messages.unshift(systemMessage);
+        }
+        // CRITICAL FIX: Use TOKEN-BASED truncation like normal Blackbox provider
+        // This is more accurate and accounts for actual model limits
+        const model = this.config?.getModel() || 'blackbox-pro';
+        const maxOutputTokens = 8192; // Standard output limit
+        // Apply token-based truncation
+        const truncatedMessagesRaw = this.messageTruncator.truncateLongMessages(model, messages, maxOutputTokens, null // system prompt already in messages
+        );
+        // Convert back to the expected type (ensure role is properly typed)
+        const truncatedMessages = truncatedMessagesRaw.map(msg => ({
+            role: msg.role,
+            content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
+        }));
+        // Log truncation if it occurred
+        if (truncatedMessages.length < messages.length) {
+            console.log(`📦 [Bridge-Token] Truncated: ${messages.length} → ${truncatedMessages.length} messages`);
+        }
+        return truncatedMessages;
+    }
+    /**
+     * Check if text contains tool call markup
+     */
+    containsToolCalls(text) {
+        // Check for wrapped formats
+        const hasWrappedFormats = text.includes('<minimax:tool_call>') ||
+            text.includes('<invoke name=') ||
+            text.includes('<tool_call>') ||
+            text.includes('<｜tool▁calls▁begin｜>') ||
+            text.includes('<｜tool▁call▁begin｜>');
+        if (hasWrappedFormats) {
+            return true;
+        }
+        // Check for bare tool call formats
+        const bareToolPatterns = [
+            /<read_file[\s>]/,
+            /<read_data_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>]/,
+            /<read_many_files[\s>]/
+        ];
+        if (bareToolPatterns.some(pattern => pattern.test(text))) {
+            return true;
+        }
+        // Check for pipe-delimited formats
+        const pipeDelimitedPatterns = [
+            /<\|read_file\|>/,
+            /<\|read_data_file\|>/,
+            /<\|glob\|>/,
+            /<\|search_files\|>/,
+            /<\|list_files\|>/,
+            /<\|create_file\|>/,
+            /<\|edit_file\|>/,
+            /<\|execute_command\|>/,
+            /<\|browser_action\|>/,
+            /<\|ask_followup_question\|>/,
+            /<\|attempt_completion\|>/,
+            /<\|new_task\|>/,
+            /<\|retrieve_knowledge\|>/,
+            /<\|read_many_files\|>/
+        ];
+        return pipeDelimitedPatterns.some(pattern => pattern.test(text));
+    }
+    /**
+     * Get available tools
+     */
+    getTools() {
+        return this.tools || [];
+    }
+    /**
+     * Add tool execution result for processing
+     */
+    addToolResult(callId, toolName, result) {
+        this.pendingToolResults.set(callId, { toolName, result, callId });
+    }
+    /**
+     * Send tool results back to encrypted service and continue conversation
+     */
+    async *sendToolResultsAndContinue(signal, prompt_id) {
+        if (this.pendingToolResults.size === 0) {
+            return;
+        }
+        try {
+            // Convert tool results to array format
+            const toolResults = Array.from(this.pendingToolResults.values());
+            // Clear pending results
+            this.pendingToolResults.clear();
+            // Create a message indicating tool results are available
+            const toolResultsMessage = this.formatToolResultsMessage(toolResults);
+            // Convert current history to message format
+            const messageHistory = await this.convertHistoryToMessageFormat(this.history);
+            // Send tool results back to encrypted service
+            const encryptedStream = await this.encryptedService.sendMessageWithToolResults(toolResultsMessage, toolResults, messageHistory);
+            // Process the response stream
+            const reader = encryptedStream.getReader();
+            const decoder = new TextDecoder();
+            let fullResponse = '';
+            // Buffer for streaming logic to hide tool calls
+            let streamBuffer = '';
+            let inToolCall = false;
+            try {
+                while (true) {
+                    if (signal.aborted) {
+                        yield { type: 'user_cancelled' };
+                        return;
+                    }
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    const chunk = decoder.decode(value, { stream: true });
+                    fullResponse += chunk;
+                    streamBuffer += chunk;
+                    // Process buffer to yield clean text
+                    while (true) {
+                        if (inToolCall) {
+                            // Look for end tokens
+                            const endToken1 = '<｜tool▁call▁end｜>';
+                            const endToken2 = '<｜tool▁calls▁end｜>';
+                            const idx1 = streamBuffer.indexOf(endToken1);
+                            const idx2 = streamBuffer.indexOf(endToken2);
+                            let endIdx = -1;
+                            let tokenLen = 0;
+                            if (idx1 !== -1 && (idx2 === -1 || idx1 < idx2)) {
+                                endIdx = idx1;
+                                tokenLen = endToken1.length;
+                            }
+                            else if (idx2 !== -1) {
+                                endIdx = idx2;
+                                tokenLen = endToken2.length;
+                            }
+                            if (endIdx !== -1) {
+                                // Found end token - discard everything up to end of token
+                                streamBuffer = streamBuffer.substring(endIdx + tokenLen);
+                                inToolCall = false;
+                                continue; // Check buffer again in normal mode
+                            }
+                            else {
+                                // No end token yet. Keep buffer small but safe.
+                                const maxTokenLen = Math.max(endToken1.length, endToken2.length);
+                                if (streamBuffer.length > maxTokenLen) {
+                                    streamBuffer = streamBuffer.substring(streamBuffer.length - maxTokenLen);
+                                }
+                                break; // Need more data
+                            }
+                        }
+                        else {
+                            // Normal mode - check for start tokens
+                            const startToken1 = '<｜tool▁calls▁begin｜>';
+                            const startToken2 = '<｜tool▁call▁begin｜>';
+                            const sepToken = '<｜tool▁sep｜>';
+                            const idx1 = streamBuffer.indexOf(startToken1);
+                            const idx2 = streamBuffer.indexOf(startToken2);
+                            const idxSep = streamBuffer.indexOf(sepToken);
+                            // Find the earliest start token
+                            let startIdx = -1;
+                            let tokenLen = 0;
+                            let isSep = false;
+                            // Helper to update best match
+                            const updateMatch = (idx, len, sep) => {
+                                if (idx !== -1 && (startIdx === -1 || idx < startIdx)) {
+                                    startIdx = idx;
+                                    tokenLen = len;
+                                    isSep = sep;
+                                }
+                            };
+                            updateMatch(idx1, startToken1.length, false);
+                            updateMatch(idx2, startToken2.length, false);
+                            updateMatch(idxSep, sepToken.length, true);
+                            if (startIdx !== -1) {
+                                // Found start token
+                                if (isSep) {
+                                    // For separator, we need to remove the preceding tool name
+                                    // The tool name is [a-zA-Z0-9_]+ immediately before startIdx
+                                    let nameStart = startIdx;
+                                    while (nameStart > 0 && /[a-zA-Z0-9_]/.test(streamBuffer[nameStart - 1])) {
+                                        nameStart--;
+                                    }
+                                    // Yield everything up to nameStart
+                                    const textToYield = streamBuffer.substring(0, nameStart);
+                                    if (textToYield) {
+                                        yield {
+                                            type: 'content',
+                                            value: textToYield
+                                        };
+                                    }
+                                    // Remove up to end of token
+                                    streamBuffer = streamBuffer.substring(startIdx + tokenLen);
+                                    inToolCall = true;
+                                    continue;
+                                }
+                                else {
+                                    // Normal start token
+                                    const textToYield = streamBuffer.substring(0, startIdx);
+                                    if (textToYield) {
+                                        yield {
+                                            type: 'content',
+                                            value: textToYield
+                                        };
+                                    }
+                                    streamBuffer = streamBuffer.substring(startIdx + tokenLen);
+                                    inToolCall = true;
+                                    continue;
+                                }
+                            }
+                            else {
+                                // No start token found.
+                                // Keep the last 50 chars to be safe (covers max token length + max tool name)
+                                const keepLen = 50;
+                                if (streamBuffer.length > keepLen) {
+                                    const yieldLen = streamBuffer.length - keepLen;
+                                    const textToYield = streamBuffer.substring(0, yieldLen);
+                                    yield {
+                                        type: 'content',
+                                        value: textToYield
+                                    };
+                                    streamBuffer = streamBuffer.substring(yieldLen);
+                                }
+                                break; // Need more data
+                            }
+                        }
+                    }
+                }
+                // Flush remaining buffer if not in tool call
+                if (!inToolCall && streamBuffer.length > 0) {
+                    yield {
+                        type: 'content',
+                        value: streamBuffer
+                    };
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            // CRITICAL FIX: Process tool calls IMMEDIATELY after streaming completes
+            const encryptedTurn = new EncryptedTurn(this, prompt_id);
+            if (this.tools && this.tools.length > 0 && this.containsToolCalls(fullResponse)) {
+                // Process the response and emit any additional tool call events
+                for await (const event of encryptedTurn.processEncryptedResponse(fullResponse, true)) {
+                    if (event.type === 'tool_call_request') {
+                        yield event;
+                    }
+                    else if (event.type === 'finished') {
+                        // Yield the finished event from processEncryptedResponse
+                        yield event;
+                        // Don't yield another finished event below
+                        return;
+                    }
+                    // Skip content events since we already streamed them
+                }
+            }
+            else {
+                // No additional tool calls, just emit finished event
+                yield {
+                    type: 'finished',
+                    value: 'STOP'
+                };
+            }
+        }
+        catch (error) {
+            console.error('❌ EncryptedGeminiClientBridge.sendToolResultsAndContinue failed:', error);
+            yield {
+                type: 'error',
+                value: {
+                    error: {
+                        message: error instanceof Error ? error.message : 'Unknown error in tool results processing',
+                        status: 500
+                    }
+                }
+            };
+        }
+    }
+    /**
+     * Format tool results into a readable message
+     */
+    formatToolResultsMessage(toolResults) {
+        const resultSummaries = toolResults.map(({ toolName, result }) => {
+            const resultText = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+            return `${toolName}: ${resultText.substring(0, 500)}${resultText.length > 500 ? '...' : ''}`;
+        });
+        return `Tool execution completed. Results: ${resultSummaries.join('; ')}. Please continue with the user's original request.`;
+    }
+    /**
+     * Check if there are pending tool results
+     */
+    hasPendingToolResults() {
+        return this.pendingToolResults.size > 0;
+    }
+    /**
+     * Clear pending tool results
+     */
+    clearPendingToolResults() {
+        this.pendingToolResults.clear();
+    }
+    /**
+     * Reset all chat history and state
+     */
+    resetHistory() {
+        this.history = [];
+        this.pendingToolResults.clear();
+    }
+    /**
+     * Check if client is ready
+     */
+    isReady() {
+        return this.encryptedService.isReady();
+    }
+    /**
+     * Format think content with special styling to distinguish from assistant messages
+     */
+    formatThinkContent(thinkContent) {
+        return formatThinkContentUtil(thinkContent, {
+            debug: false,
+            maxConsecutiveNewlines: 2,
+            trimEnds: true
+        });
+    }
+}
+//# sourceMappingURL=encryptedGeminiClientBridge.js.map