@office-ai/aioncli-core 0.8.1 → 0.18.5

package/dist/src/core/geminiChat.test.js

@@ -4,13 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { ApiError } from '@google/genai';
-import { GeminiChat, InvalidStreamError, StreamEventType, } from './geminiChat.js';
+import { ApiError, ThinkingLevel } from '@google/genai';
+import { GeminiChat, InvalidStreamError, StreamEventType, SYNTHETIC_THOUGHT_SIGNATURE, } from './geminiChat.js';
 import { setSimulate429 } from '../utils/testUtils.js';
-import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
+import { DEFAULT_GEMINI_FLASH_MODEL, DEFAULT_GEMINI_MODEL, DEFAULT_THINKING_MODE, PREVIEW_GEMINI_MODEL, } from '../config/models.js';
 import { AuthType } from './contentGenerator.js';
-import {} from '../utils/retry.js';
-import { Kind } from '../tools/tools.js';
+import { TerminalQuotaError } from '../utils/googleQuotaErrors.js';
+import { retryWithBackoff } from '../utils/retry.js';
 import { uiTelemetryService } from '../telemetry/uiTelemetry.js';
 // Mock fs module to prevent actual file system operations during tests
 const mockFileSystem = new Map();
@@ -65,7 +65,6 @@ describe('GeminiChat', () => {
     let mockContentGenerator;
     let chat;
     let mockConfig;
-    const config = {};
     beforeEach(() => {
         vi.clearAllMocks();
         vi.mocked(uiTelemetryService.setLastPromptTokenCount).mockClear();
@@ -84,6 +83,7 @@ describe('GeminiChat', () => {
             getTelemetryLogPromptsEnabled: () => true,
             getUsageStatisticsEnabled: () => true,
             getDebugMode: () => false,
+            getPreviewFeatures: () => false,
             getContentGeneratorConfig: vi.fn().mockReturnValue({
                 authType: 'oauth-personal', // Ensure this is set for fallback tests
                 model: 'test-model',
@@ -102,16 +102,55 @@ describe('GeminiChat', () => {
                 getTool: vi.fn(),
             }),
             getContentGenerator: vi.fn().mockReturnValue(mockContentGenerator),
+            getRetryFetchErrors: vi.fn().mockReturnValue(false),
+            modelConfigService: {
+                getResolvedConfig: vi.fn().mockImplementation((modelConfigKey) => {
+                    const thinkingConfig = modelConfigKey.model.startsWith('gemini-3')
+                        ? {
+                            thinkingLevel: ThinkingLevel.HIGH,
+                        }
+                        : {
+                            thinkingBudget: DEFAULT_THINKING_MODE,
+                        };
+                    return {
+                        model: modelConfigKey.model,
+                        generateContentConfig: {
+                            temperature: 0,
+                            thinkingConfig,
+                        },
+                    };
+                }),
+            },
+            isPreviewModelBypassMode: vi.fn().mockReturnValue(false),
+            setPreviewModelBypassMode: vi.fn(),
+            isPreviewModelFallbackMode: vi.fn().mockReturnValue(false),
+            setPreviewModelFallbackMode: vi.fn(),
+            isInteractive: vi.fn().mockReturnValue(false),
         };
         // Disable 429 simulation for tests
         setSimulate429(false);
         // Reset history for each test by creating a new instance
-        chat = new GeminiChat(mockConfig, config, []);
+        chat = new GeminiChat(mockConfig);
     });
     afterEach(() => {
         vi.restoreAllMocks();
         vi.resetAllMocks();
     });
+    describe('constructor', () => {
+        it('should initialize lastPromptTokenCount based on history size', () => {
+            const history = [
+                { role: 'user', parts: [{ text: 'Hello' }] },
+                { role: 'model', parts: [{ text: 'Hi there' }] },
+            ];
+            const chatWithHistory = new GeminiChat(mockConfig, '', [], history);
+            const estimatedTokens = Math.ceil(JSON.stringify(history).length / 4);
+            expect(chatWithHistory.getLastPromptTokenCount()).toBe(estimatedTokens);
+        });
+        it('should initialize lastPromptTokenCount for empty history', () => {
+            const chatEmpty = new GeminiChat(mockConfig);
+            expect(chatEmpty.getLastPromptTokenCount()).toBe(Math.ceil(JSON.stringify([]).length / 4));
+        });
+    });
     describe('sendMessageStream', () => {
         it('should succeed if a tool call is followed by an empty part', async () => {
             // 1. Mock a stream that contains a tool call, then an invalid (empty) part.
@@ -141,7 +180,7 @@ describe('GeminiChat', () => {
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamWithToolCall);
             // 2. Action & Assert: The stream processing should complete without throwing an error
             // because the presence of a tool call makes the empty final chunk acceptable.
-            const stream = await chat.sendMessageStream('test-model', { message: 'test message' }, 'prompt-id-tool-call-empty-end');
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test message', 'prompt-id-tool-call-empty-end', new AbortController().signal);
             await expect((async () => {
                 for await (const _ of stream) {
                     /* consume stream */
@@ -181,7 +220,7 @@ describe('GeminiChat', () => {
             })();
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamWithNoFinish);
             // 2. Action & Assert: The stream should fail because there's no finish reason.
-            const stream = await chat.sendMessageStream('test-model', { message: 'test message' }, 'prompt-id-no-finish-empty-end');
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test message', 'prompt-id-no-finish-empty-end', new AbortController().signal);
             await expect((async () => {
                 for await (const _ of stream) {
                     /* consume stream */
@@ -216,7 +255,7 @@ describe('GeminiChat', () => {
             })();
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamWithInvalidEnd);
             // 2. Action & Assert: The stream should complete without throwing an error.
-            const stream = await chat.sendMessageStream('test-model', { message: 'test message' }, 'prompt-id-valid-then-invalid-end');
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test message', 'prompt-id-valid-then-invalid-end', new AbortController().signal);
             await expect((async () => {
                 for await (const _ of stream) {
                     /* consume stream */
@@ -251,7 +290,7 @@ describe('GeminiChat', () => {
             })();
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(multiChunkStream);
             // 2. Action: Send a message and consume the stream.
-            const stream = await chat.sendMessageStream('test-model', { message: 'test message' }, 'prompt-id-empty-chunk-consolidation');
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test message', 'prompt-id-empty-chunk-consolidation', new AbortController().signal);
             for await (const _ of stream) {
                 // Consume the stream
             }
@@ -299,7 +338,7 @@ describe('GeminiChat', () => {
             })();
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(multiChunkStream);
             // 2. Action: Send a message and consume the stream.
-            const stream = await chat.sendMessageStream('test-model', { message: 'test message' }, 'prompt-id-multi-chunk');
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test message', 'prompt-id-multi-chunk', new AbortController().signal);
             for await (const _ of stream) {
                 // Consume the stream to trigger history recording.
             }
@@ -335,7 +374,7 @@ describe('GeminiChat', () => {
             })();
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(mixedContentStream);
             // 2. Action: Send a message and fully consume the stream to trigger history recording.
-            const stream = await chat.sendMessageStream('test-model', { message: 'test message' }, 'prompt-id-mixed-chunk');
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test message', 'prompt-id-mixed-chunk', new AbortController().signal);
             for await (const _ of stream) {
                 // This loop consumes the stream.
             }
@@ -351,6 +390,84 @@ describe('GeminiChat', () => {
             expect(modelTurn?.parts?.length).toBe(1);
             expect(modelTurn?.parts[0].text).toBe('This is the visible text that should not be lost.');
         });
+        it('should use maxAttempts=1 for retryWithBackoff when in Preview Model Fallback Mode', async () => {
+            vi.mocked(mockConfig.isPreviewModelFallbackMode).mockReturnValue(true);
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue((async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: { parts: [{ text: 'Success' }] },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })());
+            const stream = await chat.sendMessageStream({ model: PREVIEW_GEMINI_MODEL }, 'test', 'prompt-id-fast-retry', new AbortController().signal);
+            for await (const _ of stream) {
+                // consume stream
+            }
+            expect(mockRetryWithBackoff).toHaveBeenCalledWith(expect.any(Function), expect.objectContaining({
+                maxAttempts: 1,
+            }));
+        });
+        it('should NOT use maxAttempts=1 for other models even in Preview Model Fallback Mode', async () => {
+            vi.mocked(mockConfig.isPreviewModelFallbackMode).mockReturnValue(true);
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue((async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: { parts: [{ text: 'Success' }] },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })());
+            const stream = await chat.sendMessageStream({ model: DEFAULT_GEMINI_FLASH_MODEL }, 'test', 'prompt-id-normal-retry', new AbortController().signal);
+            for await (const _ of stream) {
+                // consume stream
+            }
+            expect(mockRetryWithBackoff).toHaveBeenCalledWith(expect.any(Function), expect.objectContaining({
+                maxAttempts: undefined, // Should use default
+            }));
+        });
+        it('should pass DEFAULT_GEMINI_MODEL to handleFallback when Preview Model is bypassed (downgraded)', async () => {
+            // ARRANGE
+            vi.mocked(mockConfig.isPreviewModelBypassMode).mockReturnValue(true);
+            // Mock retryWithBackoff to simulate catching the error and calling onPersistent429
+            vi.mocked(retryWithBackoff).mockImplementation(async (apiCall, options) => {
+                const onPersistent429 = options?.onPersistent429;
+                try {
+                    await apiCall();
+                }
+                catch (error) {
+                    if (onPersistent429) {
+                        await onPersistent429(AuthType.LOGIN_WITH_GOOGLE, error);
+                    }
+                    throw error;
+                }
+            });
+            // We need the API call to fail so retryWithBackoff calls the callback.
+            vi.mocked(mockContentGenerator.generateContentStream).mockRejectedValue(new TerminalQuotaError('Simulated Quota Error', {
+                code: 429,
+                message: 'Simulated Quota Error',
+                details: [],
+            }));
+            // ACT
+            const consumeStream = async () => {
+                const stream = await chat.sendMessageStream({ model: PREVIEW_GEMINI_MODEL }, 'test', 'prompt-id-bypass', new AbortController().signal);
+                // Consume the stream to trigger execution
+                for await (const _ of stream) {
+                    // do nothing
+                }
+            };
+            await expect(consumeStream()).rejects.toThrow('Simulated Quota Error');
+            expect(retryWithBackoff).toHaveBeenCalled();
+            // ASSERT
+            // handleFallback is called via onPersistent429Callback
+            // We verify it was called with DEFAULT_GEMINI_MODEL
+            expect(mockHandleFallback).toHaveBeenCalledWith(expect.anything(), DEFAULT_GEMINI_MODEL, // This is the key assertion
+            expect.anything(), expect.anything());
+        });
         it('should throw an error when a tool call is followed by an empty stream response', async () => {
             // 1. Setup: A history where the model has just made a function call.
             const initialHistory = [
@@ -384,14 +501,12 @@ describe('GeminiChat', () => {
             })();
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(emptyStreamResponse);
             // 3. Action: Send the function response back to the model and consume the stream.
-            const stream = await chat.sendMessageStream('test-model', {
-                message: {
-                    functionResponse: {
-                        name: 'find_restaurant',
-                        response: { name: 'Vesuvio' },
-                    },
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, {
+                functionResponse: {
+                    name: 'find_restaurant',
+                    response: { name: 'Vesuvio' },
                 },
-            }, 'prompt-id-stream-1');
+            }, 'prompt-id-stream-1', new AbortController().signal);
             // 4. Assert: The stream processing should throw an InvalidStreamError.
             await expect((async () => {
                 for await (const _ of stream) {
@@ -422,7 +537,7 @@ describe('GeminiChat', () => {
                 };
             })();
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamWithToolCall);
-            const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-1');
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test message', 'prompt-id-1', new AbortController().signal);
             // Should not throw an error
             await expect((async () => {
                 for await (const _ of stream) {
@@ -446,7 +561,7 @@ describe('GeminiChat', () => {
                 };
             })();
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamWithoutFinishReason);
-            const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-1');
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test message', 'prompt-id-1', new AbortController().signal);
             await expect((async () => {
                 for await (const _ of stream) {
                     // consume stream
@@ -469,7 +584,7 @@ describe('GeminiChat', () => {
                 };
             })();
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamWithEmptyResponse);
-            const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-1');
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test message', 'prompt-id-1', new AbortController().signal);
             await expect((async () => {
                 for await (const _ of stream) {
                     // consume stream
@@ -492,7 +607,7 @@ describe('GeminiChat', () => {
                 };
             })();
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(validStream);
-            const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-1');
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test message', 'prompt-id-1', new AbortController().signal);
             // Should not throw an error
             await expect((async () => {
                 for await (const _ of stream) {
@@ -500,6 +615,71 @@ describe('GeminiChat', () => {
                 }
             })()).resolves.not.toThrow();
         });
+        it('should throw InvalidStreamError when finishReason is MALFORMED_FUNCTION_CALL', async () => {
+            // Setup: Stream with MALFORMED_FUNCTION_CALL finish reason and empty response
+            const streamWithMalformedFunctionCall = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: {
+                                role: 'model',
+                                parts: [], // Empty parts
+                            },
+                            finishReason: 'MALFORMED_FUNCTION_CALL',
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(streamWithMalformedFunctionCall);
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.5-pro' }, 'test', 'prompt-id-malformed', new AbortController().signal);
+            // Should throw an error
+            await expect((async () => {
+                for await (const _ of stream) {
+                    // consume stream
+                }
+            })()).rejects.toThrow(InvalidStreamError);
+        });
+        it('should retry when finishReason is MALFORMED_FUNCTION_CALL', async () => {
+            // 1. Mock the API to fail once with MALFORMED_FUNCTION_CALL, then succeed.
+            vi.mocked(mockContentGenerator.generateContentStream)
+                .mockImplementationOnce(async () => (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: { parts: [], role: 'model' },
+                            finishReason: 'MALFORMED_FUNCTION_CALL',
+                        },
+                    ],
+                };
+            })())
+                .mockImplementationOnce(async () => 
+            // Second attempt succeeds
+            (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: { parts: [{ text: 'Success after retry' }] },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })());
+            // 2. Send a message
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.5-pro' }, 'test retry', 'prompt-id-retry-malformed', new AbortController().signal);
+            const events = [];
+            for await (const event of stream) {
+                events.push(event);
+            }
+            // 3. Assertions
+            // Should be called twice (initial + retry)
+            expect(mockContentGenerator.generateContentStream).toHaveBeenCalledTimes(2);
+            // Check for a retry event
+            expect(events.some((e) => e.type === StreamEventType.RETRY)).toBe(true);
+            // Check for the successful content chunk
+            expect(events.some((e) => e.type === StreamEventType.CHUNK &&
+                e.value.candidates?.[0]?.content?.parts?.[0]?.text ===
+                    'Success after retry')).toBe(true);
+        });
         it('should call generateContentStream with the correct parameters', async () => {
             const response = (async function* () {
                 yield {
@@ -523,7 +703,7 @@ describe('GeminiChat', () => {
                 };
             })();
             vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(response);
-            const stream = await chat.sendMessageStream('test-model', { message: 'hello' }, 'prompt-id-1');
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, 'hello', 'prompt-id-1', new AbortController().signal);
             for await (const _ of stream) {
                 // consume stream
             }
@@ -535,11 +715,68 @@ describe('GeminiChat', () => {
                         parts: [{ text: 'hello' }],
                     },
                 ],
-                config: {},
+                config: {
+                    systemInstruction: '',
+                    tools: [],
+                    temperature: 0,
+                    thinkingConfig: {
+                        thinkingBudget: DEFAULT_THINKING_MODE,
+                    },
+                    abortSignal: expect.any(AbortSignal),
+                },
             }, 'prompt-id-1');
-            // Verify that token counting is called when usageMetadata is present
-            expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledWith(42);
-            expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledTimes(1);
+        });
+        it('should use thinkingLevel and remove thinkingBudget for gemini-3 models', async () => {
+            const response = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: { parts: [{ text: 'response' }], role: 'model' },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(response);
+            const stream = await chat.sendMessageStream({ model: 'gemini-3-test-only-model-string-for-testing' }, 'hello', 'prompt-id-thinking-level', new AbortController().signal);
+            for await (const _ of stream) {
+                // consume stream
+            }
+            expect(mockContentGenerator.generateContentStream).toHaveBeenCalledWith(expect.objectContaining({
+                model: 'gemini-3-test-only-model-string-for-testing',
+                config: expect.objectContaining({
+                    thinkingConfig: {
+                        thinkingBudget: undefined,
+                        thinkingLevel: ThinkingLevel.HIGH,
+                    },
+                }),
+            }), 'prompt-id-thinking-level');
+        });
+        it('should use thinkingBudget and remove thinkingLevel for non-gemini-3 models', async () => {
+            const response = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: { parts: [{ text: 'response' }], role: 'model' },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(response);
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'hello', 'prompt-id-thinking-budget', new AbortController().signal);
+            for await (const _ of stream) {
+                // consume stream
+            }
+            expect(mockContentGenerator.generateContentStream).toHaveBeenCalledWith(expect.objectContaining({
+                model: 'gemini-2.0-flash',
+                config: expect.objectContaining({
+                    thinkingConfig: {
+                        thinkingBudget: DEFAULT_THINKING_MODE,
+                        thinkingLevel: undefined,
+                    },
+                }),
+            }), 'prompt-id-thinking-budget');
         });
     });
     describe('addHistory', () => {
@@ -571,6 +808,23 @@ describe('GeminiChat', () => {
         });
     });
     describe('sendMessageStream with retries', () => {
+        it('should not retry on invalid content if model does not start with gemini-2', async () => {
+            // Mock the stream to fail.
+            vi.mocked(mockContentGenerator.generateContentStream).mockImplementation(async () => (async function* () {
+                yield {
+                    candidates: [{ content: { parts: [{ text: '' }] } }],
+                };
+            })());
+            const stream = await chat.sendMessageStream({ model: 'gemini-1.5-pro' }, 'test', 'prompt-id-no-retry', new AbortController().signal);
+            await expect((async () => {
+                for await (const _ of stream) {
+                    // Must loop to trigger the internal logic that throws.
+                }
+            })()).rejects.toThrow(InvalidStreamError);
+            // Should be called only 1 time (no retry)
+            expect(mockContentGenerator.generateContentStream).toHaveBeenCalledTimes(1);
+            expect(mockLogContentRetry).not.toHaveBeenCalled();
+        });
         it('should yield a RETRY event when an invalid stream is encountered', async () => {
             // ARRANGE: Mock the stream to fail once, then succeed.
             vi.mocked(mockContentGenerator.generateContentStream)
@@ -594,7 +848,7 @@ describe('GeminiChat', () => {
                 };
             })());
             // ACT: Send a message and collect all events from the stream.
-            const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-yield-retry');
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test message', 'prompt-id-yield-retry', new AbortController().signal);
             const events = [];
             for await (const event of stream) {
                 events.push(event);
@@ -626,7 +880,7 @@ describe('GeminiChat', () => {
                     ],
                 };
             })());
-            const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-retry-success');
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test', 'prompt-id-retry-success', new AbortController().signal);
             const chunks = [];
             for await (const chunk of stream) {
                 chunks.push(chunk);
@@ -655,6 +909,46 @@ describe('GeminiChat', () => {
             // Verify that token counting is not called when usageMetadata is missing
             expect(uiTelemetryService.setLastPromptTokenCount).not.toHaveBeenCalled();
         });
+        it('should set temperature to 1 on retry', async () => {
+            // Use mockImplementationOnce to provide a fresh, promise-wrapped generator for each attempt.
+            vi.mocked(mockContentGenerator.generateContentStream)
+                .mockImplementationOnce(async () => 
+            // First call returns an invalid stream
+            (async function* () {
+                yield {
+                    candidates: [{ content: { parts: [{ text: '' }] } }], // Invalid empty text part
+                };
+            })())
+                .mockImplementationOnce(async () => 
+            // Second call returns a valid stream
+            (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: { parts: [{ text: 'Successful response' }] },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })());
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test message', 'prompt-id-retry-temperature', new AbortController().signal);
+            for await (const _ of stream) {
+                // consume stream
+            }
+            expect(mockContentGenerator.generateContentStream).toHaveBeenCalledTimes(2);
+            // First call should have original temperature
+            expect(mockContentGenerator.generateContentStream).toHaveBeenNthCalledWith(1, expect.objectContaining({
+                config: expect.objectContaining({
+                    temperature: 0,
+                }),
+            }), 'prompt-id-retry-temperature');
+            // Second call (retry) should have temperature 1
+            expect(mockContentGenerator.generateContentStream).toHaveBeenNthCalledWith(2, expect.objectContaining({
+                config: expect.objectContaining({
+                    temperature: 1,
+                }),
+            }), 'prompt-id-retry-temperature');
+        });
         it('should fail after all retries on persistent invalid content and report metrics', async () => {
             vi.mocked(mockContentGenerator.generateContentStream).mockImplementation(async () => (async function* () {
                 yield {
@@ -668,7 +962,7 @@ describe('GeminiChat', () => {
                     ],
                 };
             })());
-            const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-retry-fail');
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test', 'prompt-id-retry-fail', new AbortController().signal);
             await expect(async () => {
                 for await (const _ of stream) {
                     // Must loop to trigger the internal logic that throws.
@@ -689,13 +983,24 @@ describe('GeminiChat', () => {
         describe('API error retry behavior', () => {
             beforeEach(() => {
                 // Use a more direct mock for retry testing
-                mockRetryWithBackoff.mockImplementation(async (apiCall, options) => {
+                mockRetryWithBackoff.mockImplementation(async (apiCall) => {
                     try {
                         return await apiCall();
                     }
                     catch (error) {
-                        if (options?.shouldRetryOnError &&
-                            options.shouldRetryOnError(error)) {
+                        // Simulate the logic of defaultShouldRetry for ApiError
+                        let shouldRetry = false;
+                        if (error instanceof ApiError && error.message) {
+                            if (error.status === 429 ||
+                                (error.status >= 500 && error.status < 600)) {
+                                shouldRetry = true;
+                            }
+                            // Explicitly don't retry on these
+                            if (error.status === 400) {
+                                shouldRetry = false;
+                            }
+                        }
+                        if (shouldRetry) {
                             // Try again
                             return await apiCall();
                         }
@@ -706,7 +1011,7 @@ describe('GeminiChat', () => {
             it('should not retry on 400 Bad Request errors', async () => {
                 const error400 = new ApiError({ message: 'Bad Request', status: 400 });
                 vi.mocked(mockContentGenerator.generateContentStream).mockRejectedValue(error400);
-                const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-400');
+                const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test message', 'prompt-id-400', new AbortController().signal);
                 await expect((async () => {
                     for await (const _ of stream) {
                         /* consume stream */
@@ -729,7 +1034,7 @@ describe('GeminiChat', () => {
                         ],
                     };
                 })());
-                const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-429-retry');
+                const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test message', 'prompt-id-429-retry', new AbortController().signal);
                 const events = [];
                 for await (const event of stream) {
                     events.push(event);
@@ -741,21 +1046,6 @@ describe('GeminiChat', () => {
                     e.value.candidates?.[0]?.content?.parts?.[0]?.text ===
                         'Success after retry')).toBe(true);
             });
-            it('should not retry on schema depth errors', async () => {
-                const schemaError = new ApiError({
-                    message: 'Request failed: maximum schema depth exceeded',
-                    status: 500,
-                });
-                vi.mocked(mockContentGenerator.generateContentStream).mockRejectedValue(schemaError);
-                const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-schema');
-                await expect((async () => {
-                    for await (const _ of stream) {
-                        /* consume stream */
-                    }
-                })()).rejects.toThrow(schemaError);
-                // Should only be called once (no retry)
-                expect(mockContentGenerator.generateContentStream).toHaveBeenCalledTimes(1);
-            });
             it('should retry on 5xx server errors', async () => {
                 const error500 = new ApiError({
                     message: 'Internal Server Error 500',
@@ -773,7 +1063,7 @@ describe('GeminiChat', () => {
                         ],
                     };
                 })());
-                const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-500-retry');
+                const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test message', 'prompt-id-500-retry', new AbortController().signal);
                 const events = [];
                 for await (const event of stream) {
                     events.push(event);
@@ -781,6 +1071,44 @@ describe('GeminiChat', () => {
                 // Should be called twice (initial + retry)
                 expect(mockContentGenerator.generateContentStream).toHaveBeenCalledTimes(2);
             });
+            it('should retry on specific fetch errors when configured', async () => {
+                vi.mocked(mockConfig.getRetryFetchErrors).mockReturnValue(true);
+                const fetchError = new Error('exception TypeError: fetch failed sending request');
+                vi.mocked(mockContentGenerator.generateContentStream)
+                    .mockRejectedValueOnce(fetchError)
+                    .mockResolvedValueOnce((async function* () {
+                    yield {
+                        candidates: [
+                            {
+                                content: { parts: [{ text: 'Success after fetch error' }] },
+                                finishReason: 'STOP',
+                            },
+                        ],
+                    };
+                })());
+                mockRetryWithBackoff.mockImplementation(async (apiCall, options) => {
+                    try {
+                        return await apiCall();
+                    }
+                    catch (error) {
+                        if (options?.retryFetchErrors &&
+                            error instanceof Error &&
+                            error.message.includes('exception TypeError: fetch failed sending request')) {
+                            return await apiCall();
+                        }
+                        throw error;
+                    }
+                });
+                const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test message', 'prompt-id-fetch-error-retry', new AbortController().signal);
+                const events = [];
+                for await (const event of stream) {
+                    events.push(event);
+                }
+                expect(mockContentGenerator.generateContentStream).toHaveBeenCalledTimes(2);
+                expect(events.some((e) => e.type === StreamEventType.CHUNK &&
+                    e.value.candidates?.[0]?.content?.parts?.[0]?.text ===
+                        'Success after fetch error')).toBe(true);
+            });
             afterEach(() => {
                 // Reset to default behavior
                 mockRetryWithBackoff.mockImplementation(async (apiCall) => apiCall());
@@ -814,7 +1142,7 @@ describe('GeminiChat', () => {
             };
         })());
         // 3. Send a new message
-        const stream = await chat.sendMessageStream('test-model', { message: 'Second question' }, 'prompt-id-retry-existing');
+        const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'Second question', 'prompt-id-retry-existing', new AbortController().signal);
         for await (const _ of stream) {
             // consume stream
         }
@@ -866,7 +1194,7 @@ describe('GeminiChat', () => {
             };
         })());
         // 2. Call the method and consume the stream.
-        const stream = await chat.sendMessageStream('test-model', { message: 'test empty stream' }, 'prompt-id-empty-stream');
+        const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test empty stream', 'prompt-id-empty-stream', new AbortController().signal);
         const chunks = [];
         for await (const chunk of stream) {
             chunks.push(chunk);
@@ -927,11 +1255,11 @@ describe('GeminiChat', () => {
             .mockResolvedValueOnce(firstStreamGenerator)
             .mockResolvedValueOnce(secondStreamGenerator);
         // 3. Start the first stream and consume only the first chunk to pause it
-        const firstStream = await chat.sendMessageStream('test-model', { message: 'first' }, 'prompt-1');
+        const firstStream = await chat.sendMessageStream({ model: 'test-model' }, 'first', 'prompt-1', new AbortController().signal);
         const firstStreamIterator = firstStream[Symbol.asyncIterator]();
         await firstStreamIterator.next();
         // 4. While the first stream is paused, start the second call. It will block.
-        const secondStreamPromise = chat.sendMessageStream('test-model', { message: 'second' }, 'prompt-2');
+        const secondStreamPromise = chat.sendMessageStream({ model: 'test-model' }, 'second', 'prompt-2', new AbortController().signal);
         // 5. Assert that only one API call has been made so far.
         expect(mockContentGenerator.generateContentStream).toHaveBeenCalledTimes(1);
         // 6. Unblock and fully consume the first stream to completion.
@@ -956,215 +1284,6 @@ describe('GeminiChat', () => {
         }
         expect(turn4.parts[0].text).toBe('second response');
     });
-    describe('stopBeforeSecondMutator', () => {
-        beforeEach(() => {
-            // Common setup for these tests: mock the tool registry.
-            const mockToolRegistry = {
-                getTool: vi.fn((toolName) => {
-                    if (toolName === 'edit') {
-                        return { kind: Kind.Edit };
-                    }
-                    return { kind: Kind.Other };
-                }),
-            };
-            vi.mocked(mockConfig.getToolRegistry).mockReturnValue(mockToolRegistry);
-        });
-        it('should stop streaming before a second mutator tool call', async () => {
-            const responses = [
-                {
-                    candidates: [
-                        { content: { role: 'model', parts: [{ text: 'First part. ' }] } },
-                    ],
-                },
-                {
-                    candidates: [
-                        {
-                            content: {
-                                role: 'model',
-                                parts: [{ functionCall: { name: 'edit', args: {} } }],
-                            },
-                        },
-                    ],
-                },
-                {
-                    candidates: [
-                        {
-                            content: {
-                                role: 'model',
-                                parts: [{ functionCall: { name: 'fetch', args: {} } }],
-                            },
-                        },
-                    ],
-                },
-                // This chunk contains the second mutator and should be clipped.
-                {
-                    candidates: [
-                        {
-                            content: {
-                                role: 'model',
-                                parts: [
-                                    { functionCall: { name: 'edit', args: {} } },
-                                    { text: 'some trailing text' },
-                                ],
-                            },
-                        },
-                    ],
-                },
-                // This chunk should never be reached.
-                {
-                    candidates: [
-                        {
-                            content: {
-                                role: 'model',
-                                parts: [{ text: 'This should not appear.' }],
-                            },
-                        },
-                    ],
-                },
-            ];
-            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue((async function* () {
-                for (const response of responses) {
-                    yield response;
-                }
-            })());
-            const stream = await chat.sendMessageStream('test-model', { message: 'test message' }, 'prompt-id-mutator-test');
-            for await (const _ of stream) {
-                // Consume the stream to trigger history recording.
-            }
-            const history = chat.getHistory();
-            expect(history.length).toBe(2);
-            const modelTurn = history[1];
-            expect(modelTurn.role).toBe('model');
-            expect(modelTurn?.parts?.length).toBe(3);
-            expect(modelTurn?.parts[0].text).toBe('First part. ');
-            expect(modelTurn.parts[1].functionCall?.name).toBe('edit');
-            expect(modelTurn.parts[2].functionCall?.name).toBe('fetch');
-        });
-        it('should not stop streaming if only one mutator is present', async () => {
-            const responses = [
-                {
-                    candidates: [
-                        { content: { role: 'model', parts: [{ text: 'Part 1. ' }] } },
-                    ],
-                },
-                {
-                    candidates: [
-                        {
-                            content: {
-                                role: 'model',
-                                parts: [{ functionCall: { name: 'edit', args: {} } }],
-                            },
-                        },
-                    ],
-                },
-                {
-                    candidates: [
-                        {
-                            content: {
-                                role: 'model',
-                                parts: [{ text: 'Part 2.' }],
-                            },
-                            finishReason: 'STOP',
-                        },
-                    ],
-                },
-            ];
-            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue((async function* () {
-                for (const response of responses) {
-                    yield response;
-                }
-            })());
-            const stream = await chat.sendMessageStream('test-model', { message: 'test message' }, 'prompt-id-one-mutator');
-            for await (const _ of stream) {
-                /* consume */
-            }
-            const history = chat.getHistory();
-            const modelTurn = history[1];
-            expect(modelTurn?.parts?.length).toBe(3);
-            expect(modelTurn.parts[1].functionCall?.name).toBe('edit');
-            expect(modelTurn.parts[2].text).toBe('Part 2.');
-        });
-        it('should clip the chunk containing the second mutator, preserving prior parts', async () => {
-            const responses = [
-                {
-                    candidates: [
-                        {
-                            content: {
-                                role: 'model',
-                                parts: [{ functionCall: { name: 'edit', args: {} } }],
-                            },
-                        },
-                    ],
-                },
-                // This chunk has a valid part before the second mutator.
-                // The valid part should be kept, the rest of the chunk discarded.
-                {
-                    candidates: [
-                        {
-                            content: {
-                                role: 'model',
-                                parts: [
-                                    { text: 'Keep this text. ' },
-                                    { functionCall: { name: 'edit', args: {} } },
-                                    { text: 'Discard this text.' },
-                                ],
-                            },
-                            finishReason: 'STOP',
-                        },
-                    ],
-                },
-            ];
-            const stream = (async function* () {
-                for (const response of responses) {
-                    yield response;
-                }
-            })();
-            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(stream);
-            const resultStream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-clip-chunk');
-            for await (const _ of resultStream) {
-                /* consume */
-            }
-            const history = chat.getHistory();
-            const modelTurn = history[1];
-            expect(modelTurn?.parts?.length).toBe(2);
-            expect(modelTurn.parts[0].functionCall?.name).toBe('edit');
-            expect(modelTurn.parts[1].text).toBe('Keep this text. ');
-        });
-        it('should handle two mutators in the same chunk (parallel call scenario)', async () => {
-            const responses = [
-                {
-                    candidates: [
-                        {
-                            content: {
-                                role: 'model',
-                                parts: [
-                                    { text: 'Some text. ' },
-                                    { functionCall: { name: 'edit', args: {} } },
-                                    { functionCall: { name: 'edit', args: {} } },
-                                ],
-                            },
-                            finishReason: 'STOP',
-                        },
-                    ],
-                },
-            ];
-            const stream = (async function* () {
-                for (const response of responses) {
-                    yield response;
-                }
-            })();
-            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(stream);
-            const resultStream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-parallel-mutators');
-            for await (const _ of resultStream) {
-                /* consume */
-            }
-            const history = chat.getHistory();
-            const modelTurn = history[1];
-            expect(modelTurn?.parts?.length).toBe(2);
-            expect(modelTurn.parts[0].text).toBe('Some text. ');
-            expect(modelTurn.parts[1].functionCall?.name).toBe('edit');
-        });
-    });
     describe('Model Resolution', () => {
         const mockResponse = {
             candidates: [
@@ -1180,7 +1299,7 @@ describe('GeminiChat', () => {
             vi.mocked(mockContentGenerator.generateContentStream).mockImplementation(async () => (async function* () {
                 yield mockResponse;
             })());
-            const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-res3');
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, 'test message', 'prompt-id-res3', new AbortController().signal);
             for await (const _ of stream) {
                 // consume stream
             }
@@ -1243,7 +1362,7 @@ describe('GeminiChat', () => {
                 isInFallbackModeSpy.mockReturnValue(true);
                 return true; // Signal retry
             });
-            const stream = await chat.sendMessageStream('test-model', { message: 'trigger 429' }, 'prompt-id-fb1');
+            const stream = await chat.sendMessageStream({ model: 'test-model' }, 'trigger 429', 'prompt-id-fb1', new AbortController().signal);
             // Consume stream to trigger logic
             for await (const _ of stream) {
                 // no-op
@@ -1255,11 +1374,69 @@ describe('GeminiChat', () => {
             const modelTurn = history[1];
             expect(modelTurn.parts[0].text).toBe('Success on retry');
         });
+        it('should switch to DEFAULT_GEMINI_FLASH_MODEL and use thinkingBudget when falling back from a gemini-3 model', async () => {
+            // ARRANGE
+            const authType = AuthType.LOGIN_WITH_GOOGLE;
+            vi.mocked(mockConfig.getContentGeneratorConfig).mockReturnValue({
+                authType,
+            });
+            // Initial state: Not in fallback mode
+            const isInFallbackModeSpy = vi.spyOn(mockConfig, 'isInFallbackMode');
+            isInFallbackModeSpy.mockReturnValue(false);
+            // Mock API calls:
+            // 1. Fails with 429 (simulating gemini-3 failure)
+            // 2. Succeeds (simulating fallback success)
+            vi.mocked(mockContentGenerator.generateContentStream)
+                .mockRejectedValueOnce(error429)
+                .mockResolvedValueOnce((async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: { parts: [{ text: 'Fallback success' }] },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })());
+            // Mock handleFallback to enable fallback mode and signal retry
+            mockHandleFallback.mockImplementation(async () => {
+                isInFallbackModeSpy.mockReturnValue(true); // Next call will see fallback mode = true
+                return true;
+            });
+            // ACT
+            const stream = await chat.sendMessageStream({ model: 'gemini-3-test-model' }, // Start with a gemini-3 model
+            'test fallback thinking', 'prompt-id-fb3', new AbortController().signal);
+            for await (const _ of stream) {
+                // consume stream
+            }
+            // ASSERT
+            expect(mockContentGenerator.generateContentStream).toHaveBeenCalledTimes(2);
+            // First call: gemini-3 model, thinkingLevel set
+            expect(mockContentGenerator.generateContentStream).toHaveBeenNthCalledWith(1, expect.objectContaining({
+                model: 'gemini-3-test-model',
+                config: expect.objectContaining({
+                    thinkingConfig: {
+                        thinkingBudget: undefined,
+                        thinkingLevel: ThinkingLevel.HIGH,
+                    },
+                }),
+            }), 'prompt-id-fb3');
+            // Second call: DEFAULT_GEMINI_FLASH_MODEL (due to fallback), thinkingBudget set (due to fix)
+            expect(mockContentGenerator.generateContentStream).toHaveBeenNthCalledWith(2, expect.objectContaining({
+                model: DEFAULT_GEMINI_FLASH_MODEL,
+                config: expect.objectContaining({
+                    thinkingConfig: {
+                        thinkingBudget: DEFAULT_THINKING_MODE,
+                        thinkingLevel: undefined,
+                    },
+                }),
+            }), 'prompt-id-fb3');
+        });
         it('should stop retrying if handleFallback returns false (e.g., auth intent)', async () => {
             vi.mocked(mockConfig.getModel).mockReturnValue('gemini-pro');
             vi.mocked(mockContentGenerator.generateContentStream).mockRejectedValue(error429);
             mockHandleFallback.mockResolvedValue(false);
-            const stream = await chat.sendMessageStream('test-model', { message: 'test stop' }, 'prompt-id-fb2');
+            const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test stop', 'prompt-id-fb2', new AbortController().signal);
             await expect((async () => {
                 for await (const _ of stream) {
                     /* consume stream */
@@ -1303,7 +1480,7 @@ describe('GeminiChat', () => {
             };
         })());
         // Send a message and consume the stream
-        const stream = await chat.sendMessageStream('test-model', { message: 'test' }, 'prompt-id-discard-test');
+        const stream = await chat.sendMessageStream({ model: 'gemini-2.0-flash' }, 'test message', 'prompt-id-discard-test', new AbortController().signal);
         const events = [];
         for await (const event of stream) {
             events.push(event);
@@ -1354,5 +1531,139 @@ describe('GeminiChat', () => {
             ]);
         });
     });
+    describe('Preview Model Fallback Logic', () => {
+        it('should reset previewModelBypassMode to false at the start of sendMessageStream', async () => {
+            const stream = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: { role: 'model', parts: [{ text: 'Success' }] },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(stream);
+            await chat.sendMessageStream({ model: 'test-model' }, 'test', 'prompt-id-preview-model-reset', new AbortController().signal);
+            expect(mockConfig.setPreviewModelBypassMode).toHaveBeenCalledWith(false);
+        });
+        it('should reset previewModelFallbackMode to false upon successful Preview Model usage', async () => {
+            const stream = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: { role: 'model', parts: [{ text: 'Success' }] },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(stream);
+            const resultStream = await chat.sendMessageStream({ model: PREVIEW_GEMINI_MODEL }, 'test', 'prompt-id-preview-model-healing', new AbortController().signal);
+            for await (const _ of resultStream) {
+                // consume stream
+            }
+            expect(mockConfig.setPreviewModelFallbackMode).toHaveBeenCalledWith(false);
+        });
+        it('should NOT reset previewModelFallbackMode if Preview Model was bypassed (downgraded)', async () => {
+            const stream = (async function* () {
+                yield {
+                    candidates: [
+                        {
+                            content: { role: 'model', parts: [{ text: 'Success' }] },
+                            finishReason: 'STOP',
+                        },
+                    ],
+                };
+            })();
+            vi.mocked(mockContentGenerator.generateContentStream).mockResolvedValue(stream);
+            // Simulate bypass mode being active (downgrade happened)
+            vi.mocked(mockConfig.isPreviewModelBypassMode).mockReturnValue(true);
+            const resultStream = await chat.sendMessageStream({ model: PREVIEW_GEMINI_MODEL }, 'test', 'prompt-id-bypass-no-healing', new AbortController().signal);
+            for await (const _ of resultStream) {
+                // consume stream
+            }
+            expect(mockConfig.setPreviewModelFallbackMode).not.toHaveBeenCalled();
+        });
+    });
+    describe('ensureActiveLoopHasThoughtSignatures', () => {
+        it('should add thoughtSignature to the first functionCall in each model turn of the active loop', () => {
+            const chat = new GeminiChat(mockConfig, '', [], []);
+            const history = [
+                { role: 'user', parts: [{ text: 'Old message' }] },
+                {
+                    role: 'model',
+                    parts: [{ functionCall: { name: 'old_tool', args: {} } }],
+                },
+                { role: 'user', parts: [{ text: 'Find a restaurant' }] }, // active loop starts here
+                {
+                    role: 'model',
+                    parts: [
+                        { functionCall: { name: 'find_restaurant', args: {} } }, // This one gets a signature
+                        { functionCall: { name: 'find_restaurant_2', args: {} } }, // This one does NOT
+                    ],
+                },
+                {
+                    role: 'user',
+                    parts: [
+                        { functionResponse: { name: 'find_restaurant', response: {} } },
+                    ],
+                },
+                {
+                    role: 'model',
+                    parts: [
+                        {
+                            functionCall: { name: 'tool_with_sig', args: {} },
+                            thoughtSignature: 'existing-sig',
+                        },
+                        { functionCall: { name: 'another_tool', args: {} } }, // This one does NOT get a signature
+                    ],
+                },
+            ];
+            const newContents = chat.ensureActiveLoopHasThoughtSignatures(history);
+            // Outside active loop - unchanged
+            expect(newContents[1]?.parts?.[0]).not.toHaveProperty('thoughtSignature');
+            // Inside active loop, first model turn
+            // First function call gets a signature
+            expect(newContents[3]?.parts?.[0]?.thoughtSignature).toBe(SYNTHETIC_THOUGHT_SIGNATURE);
+            // Second function call does NOT
+            expect(newContents[3]?.parts?.[1]).not.toHaveProperty('thoughtSignature');
+            // User functionResponse part - unchanged (this is not a model turn)
+            expect(newContents[4]?.parts?.[0]).not.toHaveProperty('thoughtSignature');
+            // Inside active loop, second model turn
+            // First function call already has a signature, so nothing changes
+            expect(newContents[5]?.parts?.[0]?.thoughtSignature).toBe('existing-sig');
+            // Second function call does NOT get a signature
+            expect(newContents[5]?.parts?.[1]).not.toHaveProperty('thoughtSignature');
+        });
+        it('should not modify contents if there is no user text message', () => {
+            const chat = new GeminiChat(mockConfig, '', [], []);
+            const history = [
+                {
+                    role: 'user',
+                    parts: [{ functionResponse: { name: 'tool1', response: {} } }],
+                },
+                {
+                    role: 'model',
+                    parts: [{ functionCall: { name: 'tool2', args: {} } }],
+                },
+            ];
+            const newContents = chat.ensureActiveLoopHasThoughtSignatures(history);
+            expect(newContents).toEqual(history);
+            expect(newContents[1]?.parts?.[0]).not.toHaveProperty('thoughtSignature');
+        });
+        it('should handle an empty history', () => {
+            const chat = new GeminiChat(mockConfig, '', []);
+            const history = [];
+            const newContents = chat.ensureActiveLoopHasThoughtSignatures(history);
+            expect(newContents).toEqual([]);
+        });
+        it('should handle history with only a user message', () => {
+            const chat = new GeminiChat(mockConfig, '', []);
+            const history = [{ role: 'user', parts: [{ text: 'Hello' }] }];
+            const newContents = chat.ensureActiveLoopHasThoughtSignatures(history);
+            expect(newContents).toEqual(history);
+        });
+    });
 });
 //# sourceMappingURL=geminiChat.test.js.map