@vybestack/llxprt-code-core 0.1.23-nightly.250904.97906524 → 0.1.23-nightly.250905.67589d14

package/dist/src/core/geminiChat.js

@@ -17,6 +17,9 @@ import { ApiErrorEvent, ApiRequestEvent, ApiResponseEvent, } from '../telemetry/
 import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
 import { hasCycleInSchema } from '../tools/tools.js';
 import { isStructuredError } from '../utils/quotaErrorDetection.js';
+import { DebugLogger } from '../debug/index.js';
+import { getCompressionPrompt } from './prompts.js';
+import { COMPRESSION_TOKEN_THRESHOLD, COMPRESSION_PRESERVE_THRESHOLD, } from './compression-config.js';
 /**
  * Custom createUserContent function that properly handles function response arrays.
  * This fixes the issue where multiple function responses are incorrectly nested.
@@ -56,9 +59,6 @@ function createUserContentWithFunctionResponseFix(message) {
                 }
                 else if (Array.isArray(item)) {
                     // Nested array case - flatten it
-                    if (process.env.DEBUG) {
-                        console.log('[DEBUG] createUserContentWithFunctionResponseFix - flattening nested array:', JSON.stringify(item, null, 2));
-                    }
                     for (const subItem of item) {
                         parts.push(subItem);
                     }
@@ -184,27 +184,59 @@ export class EmptyStreamError extends Error {
  */
 export class GeminiChat {
     config;
-    contentGenerator;
     generationConfig;
     // A promise to represent the current state of the message being sent to the
     // model.
     sendPromise = Promise.resolve();
+    // A promise to represent any ongoing compression operation
+    compressionPromise = null;
     historyService;
+    logger = new DebugLogger('llxprt:gemini:chat');
+    // Cache the compression threshold to avoid recalculating
+    cachedCompressionThreshold = null;
     constructor(config, contentGenerator, generationConfig = {}, initialHistory = [], historyService) {
         this.config = config;
-        this.contentGenerator = contentGenerator;
         this.generationConfig = generationConfig;
         validateHistory(initialHistory);
         // Use provided HistoryService or create a new one
         this.historyService = historyService || new HistoryService();
+        this.logger.debug('GeminiChat initialized:', {
+            model: this.config.getModel(),
+            initialHistoryLength: initialHistory.length,
+            hasHistoryService: !!historyService,
+        });
         // Convert and add initial history if provided
         if (initialHistory.length > 0) {
             const currentModel = this.config.getModel();
+            this.logger.debug('Adding initial history to service:', {
+                count: initialHistory.length,
+            });
+            const idGen = this.historyService.getIdGeneratorCallback();
             for (const content of initialHistory) {
-                this.historyService.add(ContentConverters.toIContent(content), currentModel);
+                const matcher = this.makePositionMatcher();
+                this.historyService.add(ContentConverters.toIContent(content, idGen, matcher), currentModel);
             }
         }
     }
+    /**
+     * Create a position-based matcher for Gemini tool responses.
+     * It returns the next unmatched tool call from the current history.
+     */
+    makePositionMatcher() {
+        const queue = this.historyService
+            .findUnmatchedToolCalls()
+            .map((b) => ({ historyId: b.id, toolName: b.name }));
+        // Return undefined if there are no unmatched tool calls
+        if (queue.length === 0) {
+            return undefined;
+        }
+        // Return a function that always returns a valid value (never undefined)
+        return () => {
+            const result = queue.shift();
+            // If queue is empty, return a fallback value
+            return result || { historyId: '', toolName: undefined };
+        };
+    }
     _getRequestTextFromContents(contents) {
         return JSON.stringify(contents);
     }
@@ -288,28 +320,62 @@ export class GeminiChat {
      */
     async sendMessage(params, prompt_id) {
         await this.sendPromise;
+        // Check compression - first check if already compressing, then check if needed
+        if (this.compressionPromise) {
+            this.logger.debug('Waiting for ongoing compression to complete');
+            await this.compressionPromise;
+        }
+        else if (this.shouldCompress()) {
+            // Only check shouldCompress if not already compressing
+            this.logger.debug('Triggering compression before message send');
+            this.compressionPromise = this.performCompression(prompt_id);
+            await this.compressionPromise;
+            this.compressionPromise = null;
+        }
         const userContent = createUserContentWithFunctionResponseFix(params.message);
-        // Add user content to history service
-        this.historyService.add(ContentConverters.toIContent(userContent), this.config.getModel());
-        // Get curated history and convert to Content[] for the request
-        const iContents = this.historyService.getCurated();
-        const requestContents = ContentConverters.toGeminiContents(iContents);
-        this._logApiRequest(requestContents, this.config.getModel(), prompt_id);
+        // DO NOT add user content to history yet - use send-then-commit pattern
+        // Get the active provider
+        const provider = this.getActiveProvider();
+        if (!provider) {
+            throw new Error('No active provider configured');
+        }
+        // Check if provider supports IContent interface
+        if (!this.providerSupportsIContent(provider)) {
+            throw new Error(`Provider ${provider.name} does not support IContent interface`);
+        }
+        // Get curated history WITHOUT the new user message
+        const currentHistory = this.historyService.getCuratedForProvider();
+        // Convert user content to IContent
+        const idGen = this.historyService.getIdGeneratorCallback();
+        const matcher = this.makePositionMatcher();
+        const userIContent = ContentConverters.toIContent(userContent, idGen, matcher);
+        // Build request with history + new message
+        const iContents = [...currentHistory, userIContent];
+        this._logApiRequest(ContentConverters.toGeminiContents(iContents), this.config.getModel(), prompt_id);
         const startTime = Date.now();
         let response;
         try {
-            const apiCall = () => {
+            const apiCall = async () => {
                 const modelToUse = this.config.getModel() || DEFAULT_GEMINI_FLASH_MODEL;
                 // Prevent Flash model calls immediately after quota error
                 if (this.config.getQuotaErrorOccurred() &&
                     modelToUse === DEFAULT_GEMINI_FLASH_MODEL) {
                     throw new Error('Please submit a new query to continue with the Flash model.');
                 }
-                return this.contentGenerator.generateContent({
-                    model: modelToUse,
-                    contents: requestContents,
-                    config: { ...this.generationConfig, ...params.config },
-                }, prompt_id);
+                // Get tools in the format the provider expects
+                const tools = this.generationConfig.tools;
+                // Call the provider directly with IContent
+                const streamResponse = provider.generateChatCompletion(iContents, tools);
+                // Collect all chunks from the stream
+                let lastResponse;
+                for await (const iContent of streamResponse) {
+                    lastResponse = iContent;
+                }
+                if (!lastResponse) {
+                    throw new Error('No response from provider');
+                }
+                // Convert the final IContent to GenerateContentResponse
+                return this.convertIContentToResponse(lastResponse);
             };
             response = await retryWithBackoff(apiCall, {
                 shouldRetry: (error) => {
@@ -331,51 +397,46 @@ export class GeminiChat {
             await this._logApiResponse(durationMs, prompt_id, response.usageMetadata, JSON.stringify(response));
             this.sendPromise = (async () => {
                 const outputContent = response.candidates?.[0]?.content;
-                // Because the AFC input contains the entire curated chat history in
-                // addition to the new user input, we need to truncate the AFC history
-                // to deduplicate the existing chat history.
+                // Send-then-commit: Now that we have a successful response, add both user and model messages
+                const currentModel = this.config.getModel();
+                // Handle AFC history or regular history
                 const fullAutomaticFunctionCallingHistory = response.automaticFunctionCallingHistory;
-                const curatedHistory = this.historyService.getCurated();
-                const index = ContentConverters.toGeminiContents(curatedHistory).length;
-                let automaticFunctionCallingHistory = [];
-                if (fullAutomaticFunctionCallingHistory != null) {
-                    automaticFunctionCallingHistory =
-                        fullAutomaticFunctionCallingHistory.slice(index) ?? [];
-                }
-                // Note: modelOutput variable no longer used directly since we handle
-                // responses inline below
-                // Remove the user content we added and handle AFC history if present
-                // Only do this if AFC history actually has content
-                if (automaticFunctionCallingHistory &&
-                    automaticFunctionCallingHistory.length > 0) {
-                    // Pop the user content and replace with AFC history
-                    const allHistory = this.historyService.getAll();
-                    const trimmedHistory = allHistory.slice(0, -1);
-                    this.historyService.clear();
-                    const currentModel = this.config.getModel();
-                    for (const content of trimmedHistory) {
-                        this.historyService.add(content, currentModel);
-                    }
+                if (fullAutomaticFunctionCallingHistory &&
+                    fullAutomaticFunctionCallingHistory.length > 0) {
+                    // AFC case: Add the AFC history which includes the user input
+                    const curatedHistory = this.historyService.getCurated();
+                    const index = ContentConverters.toGeminiContents(curatedHistory).length;
+                    const automaticFunctionCallingHistory = fullAutomaticFunctionCallingHistory.slice(index) ?? [];
                     for (const content of automaticFunctionCallingHistory) {
-                        this.historyService.add(ContentConverters.toIContent(content), currentModel);
+                        const idGen = this.historyService.getIdGeneratorCallback();
+                        const matcher = this.makePositionMatcher();
+                        this.historyService.add(ContentConverters.toIContent(content, idGen, matcher), currentModel);
                     }
                 }
+                else {
+                    // Regular case: Add user content first
+                    const idGen = this.historyService.getIdGeneratorCallback();
+                    const matcher = this.makePositionMatcher();
+                    this.historyService.add(ContentConverters.toIContent(userContent, idGen, matcher), currentModel);
+                }
                 // Add model response if we have one (but filter out pure thinking responses)
                 if (outputContent) {
                     // Check if this is pure thinking content that should be filtered
                     if (!this.isThoughtContent(outputContent)) {
                         // Not pure thinking, add it
-                        this.historyService.add(ContentConverters.toIContent(outputContent), this.config.getModel());
+                        const idGen = this.historyService.getIdGeneratorCallback();
+                        this.historyService.add(ContentConverters.toIContent(outputContent, idGen), currentModel);
                     }
                     // If it's pure thinking content, don't add it to history
                 }
                 else if (response.candidates && response.candidates.length > 0) {
                     // We have candidates but no content - add empty model response
                     // This handles the case where the model returns empty content
-                    if (!automaticFunctionCallingHistory ||
-                        automaticFunctionCallingHistory.length === 0) {
+                    if (!fullAutomaticFunctionCallingHistory ||
+                        fullAutomaticFunctionCallingHistory.length === 0) {
                         const emptyModelContent = { role: 'model', parts: [] };
-                        this.historyService.add(ContentConverters.toIContent(emptyModelContent), this.config.getModel());
+                        const idGen = this.historyService.getIdGeneratorCallback();
+                        this.historyService.add(ContentConverters.toIContent(emptyModelContent, idGen), currentModel);
                     }
                 }
                 // If no candidates at all, don't add anything (error case)
@@ -431,23 +492,62 @@ export class GeminiChat {
             console.log('DEBUG: GeminiChat.sendMessageStream params.message:', JSON.stringify(params.message, null, 2));
         }
         await this.sendPromise;
+        // Check compression - first check if already compressing, then check if needed
+        if (this.compressionPromise) {
+            this.logger.debug('Waiting for ongoing compression to complete');
+            await this.compressionPromise;
+        }
+        else if (this.shouldCompress()) {
+            // Only check shouldCompress if not already compressing
+            this.logger.debug('Triggering compression before message send in stream');
+            this.compressionPromise = this.performCompression(prompt_id);
+            await this.compressionPromise;
+            this.compressionPromise = null;
+        }
+        // Check if this is a paired tool call/response array
+        let userContent;
+        // Quick check for paired tool call/response
+        const messageArray = Array.isArray(params.message) ? params.message : null;
+        const isPairedToolResponse = messageArray &&
+            messageArray.length === 2 &&
+            messageArray[0] &&
+            typeof messageArray[0] === 'object' &&
+            'functionCall' in messageArray[0] &&
+            messageArray[1] &&
+            typeof messageArray[1] === 'object' &&
+            'functionResponse' in messageArray[1];
+        if (isPairedToolResponse && messageArray) {
+            // This is a paired tool call/response from the executor
+            // Create separate Content objects with correct roles
+            userContent = [
+                {
+                    role: 'model',
+                    parts: [messageArray[0]],
+                },
+                {
+                    role: 'user',
+                    parts: [messageArray[1]],
+                },
+            ];
+        }
+        else {
+            userContent = createUserContentWithFunctionResponseFix(params.message);
+        }
+        // DO NOT add anything to history here - wait until after successful send!
+        // Tool responses will be handled in recordHistory after the model responds
         let streamDoneResolver;
         const streamDonePromise = new Promise((resolve) => {
             streamDoneResolver = resolve;
         });
         this.sendPromise = streamDonePromise;
-        const userContent = createUserContentWithFunctionResponseFix(params.message);
-        // Add user content to history ONCE before any attempts.
-        this.historyService.add(ContentConverters.toIContent(userContent), this.config.getModel());
-        // Note: requestContents is no longer needed as adapter gets history from HistoryService
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
-        return (async function* () {
+        // DO NOT add user content to history yet - wait until successful send
+        // This is the send-then-commit pattern to avoid orphaned tool calls
+        return (async function* (instance) {
             try {
                 let lastError = new Error('Request failed after all retries.');
                 for (let attempt = 0; attempt <= INVALID_CONTENT_RETRY_OPTIONS.maxAttempts; attempt++) {
                     try {
-                        const stream = await self.makeApiCallAndProcessStream(params, prompt_id, userContent);
+                        const stream = await instance.makeApiCallAndProcessStream(params, prompt_id, userContent);
                         for await (const chunk of stream) {
                             yield chunk;
                         }
@@ -469,31 +569,27 @@ export class GeminiChat {
                     }
                 }
                 if (lastError) {
-                    // If the stream fails, remove the user message that was added.
-                    const allHistory = self.historyService.getAll();
-                    const lastIContent = allHistory[allHistory.length - 1];
-                    const userIContent = ContentConverters.toIContent(userContent);
-                    // Check if the last content is the user content we just added
-                    if (lastIContent?.speaker === userIContent.speaker &&
-                        JSON.stringify(lastIContent?.blocks) ===
-                            JSON.stringify(userIContent.blocks)) {
-                        // Remove the last item from history
-                        const trimmedHistory = allHistory.slice(0, -1);
-                        self.historyService.clear();
-                        for (const content of trimmedHistory) {
-                            self.historyService.add(content, self.config.getModel());
-                        }
-                    }
+                    // With send-then-commit pattern, we don't add to history until success,
+                    // so there's nothing to remove on failure
                     throw lastError;
                 }
             }
             finally {
                 streamDoneResolver();
             }
-        })();
+        })(this);
     }
-    async makeApiCallAndProcessStream(params, prompt_id, userContent) {
-        const apiCall = () => {
+    async makeApiCallAndProcessStream(_params, _prompt_id, userContent) {
+        // Get the active provider
+        const provider = this.getActiveProvider();
+        if (!provider) {
+            throw new Error('No active provider configured');
+        }
+        // Check if provider supports IContent interface
+        if (!this.providerSupportsIContent(provider)) {
+            throw new Error(`Provider ${provider.name} does not support IContent interface`);
+        }
+        const apiCall = async () => {
             const modelToUse = this.config.getModel();
             const authType = this.config.getContentGeneratorConfig()?.authType;
             // Prevent Flash model calls immediately after quota error (only for Gemini providers)
@@ -502,14 +598,39 @@ export class GeminiChat {
                 modelToUse === DEFAULT_GEMINI_FLASH_MODEL) {
                 throw new Error('Please submit a new query to continue with the Flash model.');
             }
-            // Get curated history for the request
-            const iContents = this.historyService.getCurated();
-            const requestContents = ContentConverters.toGeminiContents(iContents);
-            return this.contentGenerator.generateContentStream({
-                model: modelToUse,
-                contents: requestContents,
-                config: { ...this.generationConfig, ...params.config },
-            }, prompt_id);
+            // Convert user content to IContent first so we can check if it's a tool response
+            const idGen = this.historyService.getIdGeneratorCallback();
+            const matcher = this.makePositionMatcher();
+            let requestContents;
+            if (Array.isArray(userContent)) {
+                // This is a paired tool call/response - convert each separately
+                const userIContents = userContent.map((content) => ContentConverters.toIContent(content, idGen, matcher));
+                // Get curated history WITHOUT the new user message (since we haven't added it yet)
+                const currentHistory = this.historyService.getCuratedForProvider();
+                // Build request with history + new messages (but don't commit to history yet)
+                requestContents = [...currentHistory, ...userIContents];
+            }
+            else {
+                const userIContent = ContentConverters.toIContent(userContent, idGen, matcher);
+                // Get curated history WITHOUT the new user message (since we haven't added it yet)
+                const currentHistory = this.historyService.getCuratedForProvider();
+                // Build request with history + new message (but don't commit to history yet)
+                requestContents = [...currentHistory, userIContent];
+            }
+            // DEBUG: Check for malformed entries
+            if (process.env.DEBUG) {
+                console.log('[DEBUG] geminiChat IContent request (history + new message):', JSON.stringify(requestContents, null, 2));
+            }
+            // Get tools in the format the provider expects
+            const tools = this.generationConfig.tools;
+            // Call the provider directly with IContent
+            const streamResponse = provider.generateChatCompletion(requestContents, tools);
+            // Convert the IContent stream to GenerateContentResponse stream
+            return (async function* (instance) {
+                for await (const iContent of streamResponse) {
+                    yield instance.convertIContentToResponse(iContent);
+                }
+            })(this);
         };
         const streamResponse = await retryWithBackoff(apiCall, {
             shouldRetry: (error) => {
@@ -584,6 +705,188 @@ export class GeminiChat {
     setTools(tools) {
         this.generationConfig.tools = tools;
     }
+    /**
+     * Check if compression is needed based on token count
+     */
+    shouldCompress() {
+        // Calculate compression threshold only if not cached
+        if (this.cachedCompressionThreshold === null) {
+            const threshold = this.config.getEphemeralSetting('compression-threshold') ?? COMPRESSION_TOKEN_THRESHOLD;
+            const contextLimit = this.config.getEphemeralSetting('context-limit') ?? 60000; // Default context limit
+            this.cachedCompressionThreshold = threshold * contextLimit;
+            this.logger.debug('Calculated compression threshold:', {
+                threshold,
+                contextLimit,
+                compressionThreshold: this.cachedCompressionThreshold,
+            });
+        }
+        const currentTokens = this.historyService.getTotalTokens();
+        const shouldCompress = currentTokens >= this.cachedCompressionThreshold;
+        if (shouldCompress) {
+            this.logger.debug('Compression needed:', {
+                currentTokens,
+                threshold: this.cachedCompressionThreshold,
+            });
+        }
+        return shouldCompress;
+    }
+    /**
+     * Perform compression of chat history
+     * Made public to allow manual compression triggering
+     */
+    async performCompression(prompt_id) {
+        this.logger.debug('Starting compression');
+        // Reset cached threshold after compression in case settings changed
+        this.cachedCompressionThreshold = null;
+        // Lock history service
+        this.historyService.startCompression();
+        try {
+            // Get compression split
+            const { toCompress, toKeep } = this.getCompressionSplit();
+            if (toCompress.length === 0) {
+                this.logger.debug('Nothing to compress');
+                return;
+            }
+            // Perform direct compression API call
+            const summary = await this.directCompressionCall(toCompress, prompt_id);
+            // Apply compression atomically
+            this.applyCompression(summary, toKeep);
+            this.logger.debug('Compression completed successfully');
+        }
+        catch (error) {
+            this.logger.error('Compression failed:', error);
+            throw error;
+        }
+        finally {
+            // Always unlock
+            this.historyService.endCompression();
+        }
+    }
+    /**
+     * Get the split point for compression
+     */
+    getCompressionSplit() {
+        const curated = this.historyService.getCurated();
+        // Calculate split point (keep last 30%)
+        const preserveThreshold = this.config.getEphemeralSetting('compression-preserve-threshold') ?? COMPRESSION_PRESERVE_THRESHOLD;
+        let splitIndex = Math.floor(curated.length * (1 - preserveThreshold));
+        // Adjust for tool call boundaries
+        splitIndex = this.adjustForToolCallBoundary(curated, splitIndex);
+        // Never compress if too few messages
+        if (splitIndex < 4) {
+            return { toCompress: [], toKeep: curated };
+        }
+        return {
+            toCompress: curated.slice(0, splitIndex),
+            toKeep: curated.slice(splitIndex),
+        };
+    }
+    /**
+     * Adjust compression boundary to not split tool call/response pairs
+     */
+    adjustForToolCallBoundary(history, index) {
+        // Don't split tool responses from their calls
+        while (index < history.length && history[index].speaker === 'tool') {
+            index++;
+        }
+        // Check if previous message has unmatched tool calls
+        if (index > 0) {
+            const prev = history[index - 1];
+            if (prev.speaker === 'ai') {
+                const toolCalls = prev.blocks.filter((b) => b.type === 'tool_call');
+                if (toolCalls.length > 0) {
+                    // Check if there are matching tool responses in the kept portion
+                    const keptHistory = history.slice(index);
+                    const hasMatchingResponses = toolCalls.every((call) => {
+                        const toolCall = call;
+                        return keptHistory.some((msg) => msg.speaker === 'tool' &&
+                            msg.blocks.some((b) => b.type === 'tool_response' &&
+                                b.callId === toolCall.id));
+                    });
+                    if (!hasMatchingResponses) {
+                        // Include the AI message with unmatched calls in the compression
+                        return index - 1;
+                    }
+                }
+            }
+        }
+        return index;
+    }
+    /**
+     * Direct API call for compression, bypassing normal message flow
+     */
+    async directCompressionCall(historyToCompress, _prompt_id) {
+        const provider = this.getActiveProvider();
+        if (!provider || !this.providerSupportsIContent(provider)) {
+            throw new Error('Provider does not support compression');
+        }
+        // Build compression request with system prompt and user history
+        const compressionRequest = [
+            // Add system instruction as the first message
+            {
+                speaker: 'human',
+                blocks: [
+                    {
+                        type: 'text',
+                        text: getCompressionPrompt(),
+                    },
+                ],
+            },
+            // Add the history to compress
+            ...historyToCompress,
+            // Add the trigger instruction
+            {
+                speaker: 'human',
+                blocks: [
+                    {
+                        type: 'text',
+                        text: 'First, reason in your scratchpad. Then, generate the <state_snapshot>.',
+                    },
+                ],
+            },
+        ];
+        // Direct provider call without tools for compression
+        const stream = provider.generateChatCompletion(compressionRequest, undefined);
+        // Collect response
+        let summary = '';
+        for await (const chunk of stream) {
+            if (chunk.blocks) {
+                for (const block of chunk.blocks) {
+                    if (block.type === 'text') {
+                        summary += block.text;
+                    }
+                }
+            }
+        }
+        return summary;
+    }
+    /**
+     * Apply compression results to history
+     */
+    applyCompression(summary, toKeep) {
+        // Clear and rebuild history atomically
+        this.historyService.clear();
+        const currentModel = this.config.getModel();
+        // Add compressed summary as user message
+        this.historyService.add({
+            speaker: 'human',
+            blocks: [{ type: 'text', text: summary }],
+        }, currentModel);
+        // Add acknowledgment from AI
+        this.historyService.add({
+            speaker: 'ai',
+            blocks: [
+                {
+                    type: 'text',
+                    text: 'Got it. Thanks for the additional context!',
+                },
+            ],
+        }, currentModel);
+        // Add back the kept messages
+        for (const content of toKeep) {
+            this.historyService.add(content, currentModel);
+        }
+    }
     getFinalUsageMetadata(chunks) {
         const lastChunkWithMetadata = chunks
             .slice()
@@ -655,16 +958,20 @@ export class GeminiChat {
             }
         }
         else {
-            // Guard for streaming calls where the user input might already be in the history.
-            const allHistory = this.historyService.getAll();
-            const lastEntry = allHistory[allHistory.length - 1];
-            const userIContent = ContentConverters.toIContent(userInput);
-            // Check if user input is already in history
-            const isAlreadyInHistory = lastEntry &&
-                lastEntry.speaker === userIContent.speaker &&
-                JSON.stringify(lastEntry.blocks) ===
-                    JSON.stringify(userIContent.blocks);
-            if (!isAlreadyInHistory) {
+            // Handle both single Content and Content[] (for paired tool call/response)
+            const idGen = this.historyService.getIdGeneratorCallback();
+            const matcher = this.makePositionMatcher();
+            if (Array.isArray(userInput)) {
+                // This is a paired tool call/response from the executor
+                // Add each part to history
+                for (const content of userInput) {
+                    const userIContent = ContentConverters.toIContent(content, idGen, matcher);
+                    newHistoryEntries.push(userIContent);
+                }
+            }
+            else {
+                // Normal user message
+                const userIContent = ContentConverters.toIContent(userInput, idGen, matcher);
                 newHistoryEntries.push(userIContent);
             }
         }
@@ -675,6 +982,7 @@ export class GeminiChat {
             outputContents = nonThoughtModelOutput;
         }
         else if (modelOutput.length === 0 &&
+            !Array.isArray(userInput) &&
             !isFunctionResponse(userInput) &&
             !automaticFunctionCallingHistory) {
             // Add an empty model response if the model truly returned nothing.
@@ -702,7 +1010,15 @@ export class GeminiChat {
             this.historyService.add(entry, currentModel);
         }
         for (const content of consolidatedOutputContents) {
-            this.historyService.add(ContentConverters.toIContent(content), currentModel);
+            // Check if this contains tool calls
+            const hasToolCalls = content.parts?.some((part) => part && typeof part === 'object' && 'functionCall' in part);
+            if (!hasToolCalls) {
+                // Only add non-tool-call responses to history immediately
+                // Tool calls will be added when the executor returns with the response
+                this.historyService.add(ContentConverters.toIContent(content), currentModel);
+            }
+            // Tool calls are NOT added here - they'll come back from the executor
+            // along with their responses and be added together
         }
     }
     hasTextContent(content) {
@@ -855,7 +1171,7 @@ export class GeminiChat {
         // Check for potentially problematic cyclic tools with cyclic schemas
         // and include a recommendation to remove potentially problematic tools.
         if (isStructuredError(error) && isSchemaDepthError(error.message)) {
-            const tools = (await this.config.getToolRegistry()).getAllTools();
+            const tools = this.config.getToolRegistry().getAllTools();
             const cyclicSchemaTools = [];
             for (const tool of tools) {
                 if ((tool.schema.parametersJsonSchema &&
@@ -872,6 +1188,189 @@ export class GeminiChat {
             }
         }
     }
+    /**
+     * Convert PartListUnion (user input) to IContent format for provider/history
+     */
+    convertPartListUnionToIContent(input) {
+        const blocks = [];
+        if (typeof input === 'string') {
+            // Simple string input from user
+            return {
+                speaker: 'human',
+                blocks: [{ type: 'text', text: input }],
+            };
+        }
+        // Handle Part or Part[]
+        const parts = Array.isArray(input) ? input : [input];
+        // Check if all parts are function responses (tool responses)
+        const allFunctionResponses = parts.every((part) => part && typeof part === 'object' && 'functionResponse' in part);
+        if (allFunctionResponses) {
+            // Tool responses - speaker is 'tool'
+            for (const part of parts) {
+                if (typeof part === 'object' &&
+                    'functionResponse' in part &&
+                    part.functionResponse) {
+                    blocks.push({
+                        type: 'tool_response',
+                        callId: part.functionResponse.id || '',
+                        toolName: part.functionResponse.name || '',
+                        result: part.functionResponse.response || {},
+                        error: undefined,
+                    });
+                }
+            }
+            return {
+                speaker: 'tool',
+                blocks,
+            };
+        }
+        // Mixed content or function calls - must be from AI
+        let hasAIContent = false;
+        for (const part of parts) {
+            if (typeof part === 'string') {
+                blocks.push({ type: 'text', text: part });
+            }
+            else if ('text' in part && part.text !== undefined) {
+                blocks.push({ type: 'text', text: part.text });
+            }
+            else if ('functionCall' in part && part.functionCall) {
+                hasAIContent = true; // Function calls only come from AI
+                blocks.push({
+                    type: 'tool_call',
+                    id: part.functionCall.id || '',
+                    name: part.functionCall.name || '',
+                    parameters: part.functionCall.args || {},
+                });
+            }
+            else if ('functionResponse' in part && part.functionResponse) {
+                // Single function response in mixed content
+                blocks.push({
+                    type: 'tool_response',
+                    callId: part.functionResponse.id || '',
+                    toolName: part.functionResponse.name || '',
+                    result: part.functionResponse.response || {},
+                    error: undefined,
+                });
+            }
+        }
+        // If we have function calls, it's AI content; otherwise assume human
+        return {
+            speaker: hasAIContent ? 'ai' : 'human',
+            blocks,
+        };
+    }
+    /**
+     * Convert IContent (from provider) to GenerateContentResponse for SDK compatibility
+     */
+    convertIContentToResponse(input) {
+        // Convert IContent blocks to Gemini Parts
+        const parts = [];
+        for (const block of input.blocks) {
+            switch (block.type) {
+                case 'text':
+                    parts.push({ text: block.text });
+                    break;
+                case 'tool_call': {
+                    const toolCall = block;
+                    parts.push({
+                        functionCall: {
+                            id: toolCall.id,
+                            name: toolCall.name,
+                            args: toolCall.parameters,
+                        },
+                    });
+                    break;
+                }
+                case 'tool_response': {
+                    const toolResponse = block;
+                    parts.push({
+                        functionResponse: {
+                            id: toolResponse.callId,
+                            name: toolResponse.toolName,
+                            response: toolResponse.result,
+                        },
+                    });
+                    break;
+                }
+                case 'thinking':
+                    // Include thinking blocks as thought parts
+                    parts.push({
+                        thought: true,
+                        text: block.thought,
+                    });
+                    break;
+                default:
+                    // Skip unsupported block types
+                    break;
+            }
+        }
+        // Build the response structure
+        const response = {
+            candidates: [
+                {
+                    content: {
+                        role: 'model',
+                        parts,
+                    },
+                },
+            ],
+            // These are required properties that must be present
+            get text() {
+                return parts.find((p) => 'text' in p)?.text || '';
+            },
+            functionCalls: parts
+                .filter((p) => 'functionCall' in p)
+                .map((p) => p.functionCall),
+            executableCode: undefined,
+            codeExecutionResult: undefined,
+            // data property will be added below
+        };
+        // Add data property that returns self-reference
+        // Make it non-enumerable to avoid circular reference in JSON.stringify
+        Object.defineProperty(response, 'data', {
+            get() {
+                return response;
+            },
+            enumerable: false, // Changed from true to false
+            configurable: true,
+        });
+        // Add usage metadata if present
+        if (input.metadata?.usage) {
+            response.usageMetadata = {
+                promptTokenCount: input.metadata.usage.promptTokens || 0,
+                candidatesTokenCount: input.metadata.usage.completionTokens || 0,
+                totalTokenCount: input.metadata.usage.totalTokens || 0,
+            };
+        }
+        return response;
+    }
+    /**
+     * Get the active provider from the ProviderManager via Config
+     */
+    getActiveProvider() {
+        const providerManager = this.config.getProviderManager();
+        if (!providerManager) {
+            return undefined;
+        }
+        try {
+            return providerManager.getActiveProvider();
+        }
+        catch {
+            // No active provider set
+            return undefined;
+        }
+    }
+    /**
+     * Check if a provider supports the IContent interface
+     */
+    providerSupportsIContent(provider) {
+        if (!provider) {
+            return false;
+        }
+        // Check if the provider has the IContent method
+        return (typeof provider
+            .generateChatCompletion === 'function');
+    }
 }
 /** Visible for Testing */
 export function isSchemaDepthError(errorMessage) {