@machina.ai/cell-cli-core 1.41.1-rc2 → 1.45.1-rc1

package/dist/src/core/geminiChat.js

@@ -6,7 +6,9 @@
 // DISCLAIMER: This is a copied version of https://github.com/googleapis/js-genai/blob/main/src/chats.ts with the intention of working around a key bug
 // where function responses are not treated as "valid" responses: https://b.corp.google.com/issues/420354090
 import { createUserContent, FinishReason, } from '@google/genai';
+export { AgentChatHistory } from './agentChatHistory.js';
 import { AgentChatHistory } from './agentChatHistory.js';
+import { randomUUID } from 'node:crypto';
 import { toParts } from '../code_assist/converter.js';
 import { retryWithBackoff, isRetryableError, getRetryErrorType, } from '../utils/retry.js';
 import { resolveModel, supportsModernFeatures } from '../config/models.js';
@@ -16,7 +18,9 @@ import { ChatRecordingService, } from '../services/chatRecordingService.js';
 import { ContentRetryEvent, ContentRetryFailureEvent, NetworkRetryAttemptEvent, } from '../telemetry/types.js';
 import { handleFallback } from '../fallback/handler.js';
 import { isFunctionResponse } from '../utils/messageInspectors.js';
-import { partListUnionToString } from './geminiRequest.js';
+import { scrubHistory, scrubContents } from '../utils/historyHardening.js';
+import { partListUnionToString, ensureStableToolIds, } from '../utils/sessionUtils.js';
+import { BINARY_INJECTION_KEY } from '../utils/generateContentResponseUtilities.js';
 import { estimateTokenCountSync } from '../utils/tokenCalculation.js';
 import { applyModelSelection, createAvailabilityContextProvider, } from '../availability/policyHelpers.js';
 import { coreEvents } from '../utils/events.js';
@@ -38,6 +42,9 @@ const MID_STREAM_RETRY_OPTIONS = {
     useExponentialBackoff: true,
 };
 export const SYNTHETIC_THOUGHT_SIGNATURE = 'skip_thought_signature_validator';
+function isIndexedPart(part) {
+    return 'callIndex' in part;
+}
 /**
  * Returns true if the response is valid, false otherwise.
  */
@@ -82,7 +89,8 @@ function isValidContent(content) {
  * @throws Error if the history contains an invalid role.
  */
 function validateHistory(history) {
-    for (const content of history) {
+    for (const item of history) {
+        const content = 'content' in item ? item.content : item;
         if (content.role !== 'user' && content.role !== 'model') {
             throw new Error(`Role must be user or model, but got ${content.role}.`);
         }
@@ -104,16 +112,16 @@ function extractCuratedHistory(comprehensiveHistory) {
     const length = comprehensiveHistory.length;
     let i = 0;
     while (i < length) {
-        if (comprehensiveHistory[i].role === 'user') {
+        if (comprehensiveHistory[i].content.role === 'user') {
             curatedHistory.push(comprehensiveHistory[i]);
             i++;
         }
         else {
             const modelOutput = [];
             let isValid = true;
-            while (i < length && comprehensiveHistory[i].role === 'model') {
+            while (i < length && comprehensiveHistory[i].content.role === 'model') {
                 modelOutput.push(comprehensiveHistory[i]);
-                if (isValid && !isValidContent(comprehensiveHistory[i])) {
+                if (isValid && !isValidContent(comprehensiveHistory[i].content)) {
                     isValid = false;
                 }
                 i++;
@@ -178,6 +186,7 @@ export class GeminiChat {
     sendPromise = Promise.resolve();
     chatRecordingService;
     lastPromptTokenCount;
+    callCounter = 0;
     agentHistory;
     constructor(context, systemInstruction = '', tools = [], history = [], resumedSessionData, onModelChanged) {
         this.context = context;
@@ -185,16 +194,53 @@ export class GeminiChat {
         this.tools = tools;
         this.onModelChanged = onModelChanged;
         validateHistory(history);
-        this.agentHistory = new AgentChatHistory(history);
+        let initialHistory;
+        // If history is passed, it is the most up-to-date in-memory state and takes precedence.
+        // This is critical for hot-restarts after operations like context compression.
+        if (history.length > 0) {
+            initialHistory = history.map((item) => 'id' in item && 'content' in item
+                ? item
+                : { id: randomUUID(), content: item });
+        }
+        else if (resumedSessionData) {
+            // Otherwise, if resuming from disk, build from the persisted record.
+            initialHistory = resumedSessionData.conversation.messages
+                .filter((m) => m.type === 'user' || m.type === 'gemini')
+                .map((m) => ({
+                id: m.id,
+                content: {
+                    role: m.type === 'user' ? 'user' : 'model',
+                    parts: Array.isArray(m.content)
+                        ? // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                            m.content
+                        : [{ text: String(m.content) }],
+                },
+            }));
+        }
+        else {
+            initialHistory = [];
+        }
+        this.agentHistory = new AgentChatHistory(initialHistory);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        ensureStableToolIds(this.agentHistory.get());
         this.chatRecordingService = new ChatRecordingService(context);
-        this.lastPromptTokenCount = estimateTokenCountSync(this.agentHistory.flatMap((c) => c.parts || []));
+        this.lastPromptTokenCount = estimateTokenCountSync(this.agentHistory.flatMap((c) => c.content.parts || []));
+    }
+    get loopContext() {
+        return this.context;
     }
     async initialize(resumedSessionData, kind = 'main') {
         await this.chatRecordingService.initialize(resumedSessionData, kind);
+        // Sync initial history with the recorder to ensure all turns (even bootstrapped ones)
+        // are durable and coordinated.
+        this.chatRecordingService.updateMessagesFromHistory(this.agentHistory.get());
     }
     setSystemInstruction(sysInstr) {
         this.systemInstruction = sysInstr;
     }
+    getSystemInstruction() {
+        return this.systemInstruction;
+    }
     /**
      * Sends a message to the model and returns the response in chunks.
      *
@@ -221,15 +267,16 @@ export class GeminiChat {
      * }
      * ```
      */
-    async sendMessageStream(modelConfigKey, message, prompt_id, signal, role, displayContent) {
+    async sendMessageStream(modelConfigKey, message, prompt_id, signal, role, displayContent, apiHistoryOverride) {
         await this.sendPromise;
         let streamDoneResolver;
         const streamDonePromise = new Promise((resolve) => {
             streamDoneResolver = resolve;
         });
         this.sendPromise = streamDonePromise;
-        const userContent = createUserContent(message);
+        let userContent = createUserContent(message);
         const { model } = this.context.config.modelConfigService.getResolvedConfig(modelConfigKey);
+        const isContextManagementEnabled = this.context.config.isContextManagementEnabled();
         // Record user input - capture complete message with all parts (text, files, images, etc.)
         // but skip recording function responses (tool call results) as they should be stored in tool call records
         if (!isFunctionResponse(userContent)) {
@@ -243,16 +290,89 @@ export class GeminiChat {
                     finalDisplayContent = displayParts;
                 }
             }
-            this.chatRecordingService.recordMessage({
-                model,
-                type: 'user',
-                content: userMessageParts,
-                displayContent: finalDisplayContent,
-            });
+            if (!isContextManagementEnabled) {
+                const id = this.chatRecordingService.recordMessage({
+                    model,
+                    type: 'user',
+                    content: userMessageParts,
+                    displayContent: finalDisplayContent,
+                });
+                this.agentHistory.push({ id, content: userContent });
+            }
+            else {
+                // With Context Management, the client has already recorded the user message
+                // and called setHistory to ensure the graph is in sync.
+                // We just verify it's there.
+                const history = this.agentHistory.get();
+                const lastTurn = history[history.length - 1];
+                if (!lastTurn ||
+                    partListUnionToString(lastTurn.content.parts || []) !==
+                        userMessageContent) {
+                    const id = this.chatRecordingService.recordMessage({
+                        model,
+                        type: 'user',
+                        content: userMessageParts,
+                        displayContent: finalDisplayContent,
+                    });
+                    this.agentHistory.push({ id, content: userContent });
+                }
+            }
         }
-        // Add user content to history ONCE before any attempts.
-        this.agentHistory.push(userContent);
-        const requestContents = this.getHistory(true);
+        else {
+            // Record tool response as a message to ensure durable ID and linear history for resume.
+            const id = this.chatRecordingService.recordSyntheticMessage('user', userContent.parts || []);
+            if (!isContextManagementEnabled) {
+                // Binary injections: If the tool output contains binary data, we expand the history.
+                const binaryParts = this.extractBinaryInjections(userContent.parts);
+                if (binaryParts) {
+                    // Turn 1: The original tool response (now cleaned)
+                    this.agentHistory.push({ id, content: userContent });
+                    // Turn 2: Synthetic Model Acknowledgment
+                    const modelId = this.chatRecordingService.recordSyntheticMessage('gemini', [
+                        {
+                            text: 'Binary content received. Proceeding with analysis.',
+                            thought: true,
+                            thoughtSignature: SYNTHETIC_THOUGHT_SIGNATURE,
+                        },
+                    ]);
+                    this.agentHistory.push({
+                        id: modelId,
+                        content: {
+                            role: 'model',
+                            parts: [
+                                {
+                                    text: 'Binary content received. Proceeding with analysis.',
+                                    thought: true,
+                                    thoughtSignature: SYNTHETIC_THOUGHT_SIGNATURE,
+                                },
+                            ],
+                        },
+                    });
+                    // Turn 3: The actual binary data (becomes the current request message)
+                    const binaryId = this.chatRecordingService.recordSyntheticMessage('info', binaryParts);
+                    userContent = {
+                        role: 'user',
+                        parts: binaryParts,
+                    };
+                    this.agentHistory.push({ id: binaryId, content: userContent });
+                }
+                else {
+                    this.agentHistory.push({ id, content: userContent });
+                }
+            }
+            else {
+                // With Context Management, we just push it to the history if not already there.
+                // (The client should have handled this, but we're defensive).
+                const history = this.agentHistory.get();
+                const lastTurn = history[history.length - 1];
+                if (!lastTurn ||
+                    partListUnionToString(lastTurn.content.parts || []) !==
+                        partListUnionToString(userContent.parts || [])) {
+                    this.agentHistory.push({ id, content: userContent });
+                }
+            }
+        }
+        const requestHistory = this.getHistoryTurns(true);
         const streamWithRetries = async function* () {
             try {
                 const maxAttempts = this.context.config.getMaxAttempts();
@@ -267,7 +387,7 @@ export class GeminiChat {
                             ? { ...modelConfigKey, isRetry: true }
                             : modelConfigKey;
                         isConnectionPhase = true;
-                        const stream = await this.makeApiCallAndProcessStream(currentConfigKey, requestContents, prompt_id, signal, role);
+                        const stream = await this.makeApiCallAndProcessStream(currentConfigKey, requestHistory, prompt_id, signal, role, apiHistoryOverride);
                         isConnectionPhase = false;
                         for await (const chunk of stream) {
                             yield { type: StreamEventType.CHUNK, value: chunk };
@@ -304,10 +424,11 @@ export class GeminiChat {
                         // like ERR_SSL_SSLV3_ALERT_BAD_RECORD_MAC or ApiError)
                         const isRetryable = isRetryableError(error, this.context.config.getRetryFetchErrors());
                         const isContentError = error instanceof InvalidStreamError;
+                        const isRetryableContentError = isContentError && error.type !== 'NO_RESPONSE_TEXT';
                         const errorType = isContentError
                             ? error.type
                             : getRetryErrorType(error);
-                        if (isContentError || (isRetryable && !signal.aborted)) {
+                        if (isRetryableContentError || (isRetryable && !signal.aborted)) {
                             // The issue requests exactly 3 retries (4 attempts) for API errors during stream iteration.
                             // Regardless of the global maxAttempts (e.g. 10), we only want to retry these mid-stream API errors
                             // up to 3 times before finally throwing the error to the user.
@@ -350,7 +471,33 @@ export class GeminiChat {
         };
         return streamWithRetries.call(this);
     }
-    async makeApiCallAndProcessStream(modelConfigKey, requestContents, prompt_id, abortSignal, role) {
+    extractBinaryInjections(parts) {
+        const binaryParts = [];
+        if (parts) {
+            for (const part of parts) {
+                const response = part.functionResponse?.response;
+                if (response && BINARY_INJECTION_KEY in response) {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                    const injected = response[BINARY_INJECTION_KEY];
+                    delete response[BINARY_INJECTION_KEY];
+                    if (Array.isArray(injected)) {
+                        binaryParts.push(...injected);
+                    }
+                }
+            }
+        }
+        return binaryParts.length > 0 ? binaryParts : undefined;
+    }
+    async makeApiCallAndProcessStream(modelConfigKey, requestHistory, prompt_id, abortSignal, role, apiHistoryOverride) {
+        // Last mile scrubbing to remove internal tracking properties (e.g. callIndex)
+        // before sending to the Gemini API. This whitelists only standard Gemini fields.
+        const scrubbedHistory = this.context.config.isContextManagementEnabled()
+            ? scrubHistory([...requestHistory])
+            : [...requestHistory];
+        const scrubbedContents = scrubbedHistory.map((h) => h.content);
+        const requestContents = apiHistoryOverride
+            ? scrubContents(apiHistoryOverride)
+            : scrubbedContents;
         const contentsForPreviewModel = this.ensureActiveLoopHasThoughtSignatures(requestContents);
         // Track final request parameters for AfterModel hooks
         const { model: availabilityFinalModel, config: newAvailabilityConfig, maxAttempts: availabilityMaxAttempts, } = applyModelSelection(this.context.config, modelConfigKey);
@@ -363,14 +510,13 @@ export class GeminiChat {
         const initialActiveModel = this.context.config.getActiveModel();
         const apiCall = async () => {
             const useGemini3_1 = (await this.context.config.getGemini31Launched?.()) ?? false;
-            const useGemini3_1FlashLite = (await this.context.config.getGemini31FlashLiteLaunched?.()) ?? false;
             const hasAccessToPreview = this.context.config.getHasAccessToPreviewModel?.() ?? true;
             // Default to the last used model (which respects arguments/availability selection)
-            let modelToUse = resolveModel(lastModelToUse, useGemini3_1, useGemini3_1FlashLite, false, hasAccessToPreview, this.context.config);
+            let modelToUse = resolveModel(lastModelToUse, useGemini3_1, false, hasAccessToPreview, this.context.config, this.context.config.hasGemini35FlashGAAccess?.() ?? false);
             // If the active model has changed (e.g. due to a fallback updating the config),
             // we switch to the new active model.
             if (this.context.config.getActiveModel() !== initialActiveModel) {
-                modelToUse = resolveModel(this.context.config.getActiveModel(), useGemini3_1, useGemini3_1FlashLite, false, hasAccessToPreview, this.context.config);
+                modelToUse = resolveModel(this.context.config.getActiveModel(), useGemini3_1, false, hasAccessToPreview, this.context.config, this.context.config.hasGemini35FlashGAAccess?.() ?? false);
             }
             if (modelToUse !== lastModelToUse) {
                 const { generateContentConfig: newConfig } = this.context.config.modelConfigService.getResolvedConfig({
@@ -411,7 +557,7 @@ export class GeminiChat {
                     throw new AgentExecutionBlockedError(beforeModelResult.reason || 'Model call blocked by hook', syntheticResponse);
                 }
                 if (beforeModelResult.modifiedModel) {
-                    modelToUse = resolveModel(beforeModelResult.modifiedModel, useGemini3_1, useGemini3_1FlashLite, false, hasAccessToPreview, this.context.config);
+                    modelToUse = resolveModel(beforeModelResult.modifiedModel, useGemini3_1, false, hasAccessToPreview, this.context.config, this.context.config.hasGemini35FlashGAAccess?.() ?? false);
                     lastModelToUse = modelToUse;
                     // Re-evaluate contentsToUse based on the new model's feature support
                     contentsToUse = supportsModernFeatures(modelToUse)
@@ -447,9 +593,10 @@ export class GeminiChat {
             lastModelToUse = modelToUse;
             lastConfig = config;
             lastContentsToUse = contentsToUse;
+            const finalContents = stripToolCallIdPrefixes(contentsToUse);
             return this.context.config.getContentGenerator().generateContentStream({
                 model: modelToUse,
-                contents: contentsToUse,
+                contents: finalContents,
                 config,
             }, prompt_id, role);
         };
@@ -512,10 +659,18 @@ export class GeminiChat {
      * chat session.
      */
     getHistory(curated = false) {
+        return this.getHistoryTurns(curated).map((h) => h.content);
+    }
+    /**
+     * Returns the chat history as HistoryTurns.
+     */
+    getHistoryTurns(curated = false) {
         const history = curated
-            ? extractCuratedHistory([...this.agentHistory.get()])
-            : this.agentHistory.get();
-        return [...history];
+            ? extractCuratedHistory(this.agentHistory.get())
+            : [...this.agentHistory.get()];
+        return this.context.config.isContextManagementEnabled()
+            ? scrubHistory(history)
+            : history;
     }
     /**
      * Clears the chat history.
@@ -527,16 +682,32 @@ export class GeminiChat {
      * Adds a new entry to the chat history.
      */
     addHistory(content) {
-        this.agentHistory.push(content);
+        if ('id' in content && 'content' in content) {
+            this.agentHistory.push(content);
+        }
+        else {
+            const id = this.chatRecordingService.recordSyntheticMessage(content.role === 'user' ? 'user' : 'gemini', content.parts || []);
+            this.agentHistory.push({ id, content });
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        ensureStableToolIds(this.agentHistory.get());
     }
     setHistory(history) {
-        this.agentHistory.set(history);
-        this.lastPromptTokenCount = estimateTokenCountSync(this.agentHistory.flatMap((c) => c.parts || []));
-        this.chatRecordingService.updateMessagesFromHistory(history);
+        const wrappedHistory = history.map((item) => {
+            if ('id' in item && 'content' in item) {
+                return item;
+            }
+            const id = this.chatRecordingService.recordSyntheticMessage(item.role === 'user' ? 'user' : 'gemini', item.parts || []);
+            return { id, content: item };
+        });
+        ensureStableToolIds(wrappedHistory);
+        this.agentHistory.set(wrappedHistory);
+        this.lastPromptTokenCount = estimateTokenCountSync(this.agentHistory.flatMap((c) => c.content.parts || []));
+        this.chatRecordingService.updateMessagesFromHistory(this.agentHistory.get());
     }
     stripThoughtsFromHistory() {
-        this.agentHistory.map((content) => {
-            const newContent = { ...content };
+        const newHistory = this.agentHistory.map((turn) => {
+            const newContent = { ...turn.content };
             if (newContent.parts) {
                 newContent.parts = newContent.parts.map((part) => {
                     if (part && typeof part === 'object' && 'thoughtSignature' in part) {
@@ -547,8 +718,9 @@ export class GeminiChat {
                     return part;
                 });
             }
-            return newContent;
+            return { id: turn.id, content: newContent };
         });
+        this.agentHistory.set(newHistory);
     }
     // To ensure our requests validate, the first function call in every model
     // turn within the active loop must have a `thoughtSignature` property.
@@ -599,6 +771,9 @@ export class GeminiChat {
     setTools(tools) {
         this.tools = tools;
     }
+    getTools() {
+        return this.tools;
+    }
     async maybeIncludeSchemaDepthContext(error) {
         // Check for potentially problematic cyclic tools with cyclic schemas
         // and include a recommendation to remove potentially problematic tools.
@@ -627,15 +802,49 @@ export class GeminiChat {
         let hasThoughts = false;
         let finishReason;
         // The SDK provides fully assembled FunctionCall objects in chunk.functionCalls
-        const finalFunctionCalls = [];
+        // We use a Map to ensure we only keep the latest version of each call (by ID)
+        const finalFunctionCallsMap = new Map();
+        const legacyFunctionCalls = [];
+        // Map to track synthetic IDs assigned to each call index across chunks
+        const callIndexToId = new Map();
+        let runningFunctionCallCounter = 0;
         for await (const chunk of streamResponse) {
+            const currentChunkStartCounter = runningFunctionCallCounter;
             const candidateWithReason = chunk?.candidates?.find((candidate) => candidate.finishReason);
             if (candidateWithReason) {
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                 finishReason = candidateWithReason.finishReason;
             }
             if (chunk.functionCalls && chunk.functionCalls.length > 0) {
-                finalFunctionCalls.push(...chunk.functionCalls);
+                if (this.context.config.isContextManagementEnabled()) {
+                    for (let i = 0; i < chunk.functionCalls.length; i++) {
+                        const fnCall = chunk.functionCalls[i];
+                        const globalIndex = currentChunkStartCounter + i;
+                        if (!fnCall.id) {
+                            let id = callIndexToId.get(globalIndex);
+                            if (!id) {
+                                id = `synth_${this.context.promptId}_${Date.now()}_${this.callCounter++}`;
+                                callIndexToId.set(globalIndex, id);
+                            }
+                            fnCall.id = id;
+                        }
+                        const name = fnCall.name?.trim() || 'generic_tool';
+                        if (fnCall.id && !fnCall.id.startsWith(`${name}__`)) {
+                            fnCall.id = `${name}__${fnCall.id}`;
+                        }
+                        finalFunctionCallsMap.set(fnCall.id, fnCall);
+                    }
+                    runningFunctionCallCounter += chunk.functionCalls.length;
+                }
+                else {
+                    for (const fnCall of chunk.functionCalls) {
+                        const name = fnCall.name?.trim() || 'generic_tool';
+                        if (fnCall.id && !fnCall.id.startsWith(`${name}__`)) {
+                            fnCall.id = `${name}__${fnCall.id}`;
+                        }
+                    }
+                    legacyFunctionCalls.push(...chunk.functionCalls);
+                }
             }
             if (isValidResponse(chunk)) {
                 const content = chunk.candidates?.[0]?.content;
@@ -648,7 +857,23 @@ export class GeminiChat {
                     if (content.parts.some((part) => part.functionCall)) {
                         hasToolCall = true;
                     }
-                    modelResponseParts.push(...content.parts.filter((part) => !part.thought));
+                    let localFunctionCallCounter = 0;
+                    modelResponseParts.push(...content.parts
+                        .filter((part) => !part.thought)
+                        .map((part) => {
+                        if (!this.context.config.isContextManagementEnabled()) {
+                            return part;
+                        }
+                        let callIndex;
+                        if (part.functionCall) {
+                            callIndex =
+                                currentChunkStartCounter + localFunctionCallCounter++;
+                        }
+                        return {
+                            ...part,
+                            callIndex,
+                        };
+                    }));
                 }
             }
             // Record token usage if this chunk has usageMetadata
@@ -675,23 +900,17 @@ export class GeminiChat {
         }
         // String thoughts and consolidate text parts.
         const consolidatedParts = [];
+        const finalFunctionCalls = this.context.config.isContextManagementEnabled()
+            ? Array.from(finalFunctionCallsMap.values())
+            : legacyFunctionCalls;
+        let currentCallSourceIndex = -1;
         if (this.context.config.isContextManagementEnabled()) {
             for (const part of modelResponseParts) {
                 if (part.functionCall) {
-                    // Skip partial functionCall stream chunks! We will replace them
-                    // entirely with the pristine, fully assembled objects from the SDK
-                    // (finalFunctionCalls) immediately below. We only push the very first
-                    // partial chunk of a sequence as a placeholder so we know *where*
-                    // in the sequence of parts the tool call happened.
-                    const lastPart = consolidatedParts[consolidatedParts.length - 1];
-                    const currentId = part.functionCall.id;
-                    const lastId = lastPart?.functionCall?.id;
-                    const isNewCall = !lastPart?.functionCall ||
-                        (currentId !== undefined &&
-                            lastId !== undefined &&
-                            currentId !== lastId) ||
-                        lastPart.functionCall.name !== part.functionCall.name;
+                    const partIndex = isIndexedPart(part) ? part.callIndex : undefined;
+                    const isNewCall = partIndex !== undefined && partIndex > currentCallSourceIndex;
                     if (isNewCall) {
+                        currentCallSourceIndex = partIndex;
                         consolidatedParts.push({ ...part }); // Push placeholder
                     }
                 }
@@ -737,16 +956,21 @@ export class GeminiChat {
             .map((part) => part.text)
             .join('')
             .trim();
+        let id;
         // Record model response text from the collected parts.
         // Also flush when there are thoughts or a tool call (even with no text)
         // so that BeforeTool hooks always see the latest transcript state.
         if (responseText || hasThoughts || hasToolCall) {
-            this.chatRecordingService.recordMessage({
+            id = this.chatRecordingService.recordMessage({
                 model,
                 type: 'gemini',
                 content: responseText,
             });
         }
+        else {
+            // Still need a durable ID even if response is empty (e.g. only tool calls)
+            id = this.chatRecordingService.recordSyntheticMessage('gemini', consolidatedParts);
+        }
         // Stream validation logic: A stream is considered successful if:
         // 1. There's a tool call OR
         // 2. A not MALFORMED_FUNCTION_CALL finish reason and a non-mepty resp
@@ -769,7 +993,10 @@ export class GeminiChat {
                 throw new InvalidStreamError('Model stream ended with empty response text.', 'NO_RESPONSE_TEXT');
             }
         }
-        this.agentHistory.push({ role: 'model', parts: consolidatedParts });
+        this.agentHistory.push({
+            id,
+            content: { role: 'model', parts: consolidatedParts },
+        });
     }
     getLastPromptTokenCount() {
         return this.lastPromptTokenCount;
@@ -837,4 +1064,35 @@ export function isSchemaDepthError(errorMessage) {
 export function isInvalidArgumentError(errorMessage) {
     return errorMessage.includes('Request contains an invalid argument');
 }
+export function stripToolCallIdPrefixes(contents) {
+    return contents.map((content) => ({
+        ...content,
+        parts: (content.parts || []).map((part) => {
+            const newPart = { ...part };
+            if (newPart.functionCall) {
+                const fc = newPart.functionCall;
+                const name = fc.name?.trim() || 'generic_tool';
+                if (fc.id && fc.id.startsWith(`${name}__`)) {
+                    newPart.functionCall = {
+                        name: fc.name,
+                        args: fc.args,
+                        id: fc.id.substring(name.length + 2),
+                    };
+                }
+            }
+            if (newPart.functionResponse) {
+                const fr = newPart.functionResponse;
+                const name = fr.name?.trim() || 'generic_tool';
+                if (fr.id && fr.id.startsWith(`${name}__`)) {
+                    newPart.functionResponse = {
+                        name: fr.name,
+                        response: fr.response,
+                        id: fr.id.substring(name.length + 2),
+                    };
+                }
+            }
+            return newPart;
+        }),
+    }));
+}
 //# sourceMappingURL=geminiChat.js.map