@office-ai/aioncli-core 0.8.1 → 0.18.4

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

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
-import { findCompressSplitPoint, isThinkingDefault, isThinkingSupported, GeminiClient, } from './client.js';
+import { GeminiClient } from './client.js';
 import { AuthType, } from './contentGenerator.js';
 import {} from './geminiChat.js';
 import { CompressionStatus, GeminiEventType, Turn, } from './turn.js';
@@ -14,8 +14,10 @@ import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
 import { setSimulate429 } from '../utils/testUtils.js';
 import { tokenLimit } from './tokenLimits.js';
 import { ideContextStore } from '../ide/ideContext.js';
-import { ClearcutLogger } from '../telemetry/clearcut-logger/clearcut-logger.js';
 import { uiTelemetryService } from '../telemetry/uiTelemetry.js';
+import { ChatCompressionService } from '../services/chatCompressionService.js';
+import { ClearcutLogger } from '../telemetry/clearcut-logger/clearcut-logger.js';
+vi.mock('../services/chatCompressionService.js');
 // Mock fs module to prevent actual file system operations during tests
 const mockFileSystem = new Map();
 vi.mock('node:fs', () => {
@@ -95,97 +97,6 @@ async function fromAsync(promise) {
     }
     return results;
 }
-describe('findCompressSplitPoint', () => {
-    it('should throw an error for non-positive numbers', () => {
-        expect(() => findCompressSplitPoint([], 0)).toThrow('Fraction must be between 0 and 1');
-    });
-    it('should throw an error for a fraction greater than or equal to 1', () => {
-        expect(() => findCompressSplitPoint([], 1)).toThrow('Fraction must be between 0 and 1');
-    });
-    it('should handle an empty history', () => {
-        expect(findCompressSplitPoint([], 0.5)).toBe(0);
-    });
-    it('should handle a fraction in the middle', () => {
-        const history = [
-            { role: 'user', parts: [{ text: 'This is the first message.' }] }, // JSON length: 66 (19%)
-            { role: 'model', parts: [{ text: 'This is the second message.' }] }, // JSON length: 68 (40%)
-            { role: 'user', parts: [{ text: 'This is the third message.' }] }, // JSON length: 66 (60%)
-            { role: 'model', parts: [{ text: 'This is the fourth message.' }] }, // JSON length: 68 (80%)
-            { role: 'user', parts: [{ text: 'This is the fifth message.' }] }, // JSON length: 65 (100%)
-        ];
-        expect(findCompressSplitPoint(history, 0.5)).toBe(4);
-    });
-    it('should handle a fraction of last index', () => {
-        const history = [
-            { role: 'user', parts: [{ text: 'This is the first message.' }] }, // JSON length: 66 (19%)
-            { role: 'model', parts: [{ text: 'This is the second message.' }] }, // JSON length: 68 (40%)
-            { role: 'user', parts: [{ text: 'This is the third message.' }] }, // JSON length: 66 (60%)
-            { role: 'model', parts: [{ text: 'This is the fourth message.' }] }, // JSON length: 68 (80%)
-            { role: 'user', parts: [{ text: 'This is the fifth message.' }] }, // JSON length: 65 (100%)
-        ];
-        expect(findCompressSplitPoint(history, 0.9)).toBe(4);
-    });
-    it('should handle a fraction of after last index', () => {
-        const history = [
-            { role: 'user', parts: [{ text: 'This is the first message.' }] }, // JSON length: 66 (24%%)
-            { role: 'model', parts: [{ text: 'This is the second message.' }] }, // JSON length: 68 (50%)
-            { role: 'user', parts: [{ text: 'This is the third message.' }] }, // JSON length: 66 (74%)
-            { role: 'model', parts: [{ text: 'This is the fourth message.' }] }, // JSON length: 68 (100%)
-        ];
-        expect(findCompressSplitPoint(history, 0.8)).toBe(4);
-    });
-    it('should return earlier splitpoint if no valid ones are after threshhold', () => {
-        const history = [
-            { role: 'user', parts: [{ text: 'This is the first message.' }] },
-            { role: 'model', parts: [{ text: 'This is the second message.' }] },
-            { role: 'user', parts: [{ text: 'This is the third message.' }] },
-            { role: 'model', parts: [{ functionCall: {} }] },
-        ];
-        // Can't return 4 because the previous item has a function call.
-        expect(findCompressSplitPoint(history, 0.99)).toBe(2);
-    });
-    it('should handle a history with only one item', () => {
-        const historyWithEmptyParts = [
-            { role: 'user', parts: [{ text: 'Message 1' }] },
-        ];
-        expect(findCompressSplitPoint(historyWithEmptyParts, 0.5)).toBe(0);
-    });
-    it('should handle history with weird parts', () => {
-        const historyWithEmptyParts = [
-            { role: 'user', parts: [{ text: 'Message 1' }] },
-            { role: 'model', parts: [{ fileData: { fileUri: 'derp' } }] },
-            { role: 'user', parts: [{ text: 'Message 2' }] },
-        ];
-        expect(findCompressSplitPoint(historyWithEmptyParts, 0.5)).toBe(2);
-    });
-});
-describe('isThinkingSupported', () => {
-    it('should return true for gemini-2.5', () => {
-        expect(isThinkingSupported('gemini-2.5')).toBe(true);
-    });
-    it('should return true for gemini-2.5-pro', () => {
-        expect(isThinkingSupported('gemini-2.5-pro')).toBe(true);
-    });
-    it('should return false for other models', () => {
-        expect(isThinkingSupported('gemini-1.5-flash')).toBe(false);
-        expect(isThinkingSupported('some-other-model')).toBe(false);
-    });
-});
-describe('isThinkingDefault', () => {
-    it('should return false for gemini-2.5-flash-lite', () => {
-        expect(isThinkingDefault('gemini-2.5-flash-lite')).toBe(false);
-    });
-    it('should return true for gemini-2.5', () => {
-        expect(isThinkingDefault('gemini-2.5')).toBe(true);
-    });
-    it('should return true for gemini-2.5-pro', () => {
-        expect(isThinkingDefault('gemini-2.5-pro')).toBe(true);
-    });
-    it('should return false for other models', () => {
-        expect(isThinkingDefault('gemini-1.5-flash')).toBe(false);
-        expect(isThinkingDefault('some-other-model')).toBe(false);
-    });
-});
 describe('Gemini Client (client.ts)', () => {
     let mockContentGenerator;
     let mockConfig;
@@ -193,7 +104,16 @@ describe('Gemini Client (client.ts)', () => {
     let mockGenerateContentFn;
     beforeEach(async () => {
         vi.resetAllMocks();
+        ClearcutLogger.clearInstance();
         vi.mocked(uiTelemetryService.setLastPromptTokenCount).mockClear();
+        vi.mocked(ChatCompressionService.prototype.compress).mockResolvedValue({
+            newHistory: null,
+            info: {
+                originalTokenCount: 0,
+                newTokenCount: 0,
+                compressionStatus: CompressionStatus.NOOP,
+            },
+        });
         mockGenerateContentFn = vi.fn().mockResolvedValue({
             candidates: [{ content: { parts: [{ text: '{"key": "value"}' }] } }],
         });
@@ -228,7 +148,6 @@ describe('Gemini Client (client.ts)', () => {
             getVertexAI: vi.fn().mockReturnValue(false),
             getUserAgent: vi.fn().mockReturnValue('test-agent'),
             getUserMemory: vi.fn().mockReturnValue(''),
-            getFullContext: vi.fn().mockReturnValue(false),
             getSessionId: vi.fn().mockReturnValue('test-session-id'),
             getProxy: vi.fn().mockReturnValue(undefined),
             getWorkingDir: vi.fn().mockReturnValue('/test/dir'),
@@ -241,6 +160,7 @@ describe('Gemini Client (client.ts)', () => {
             getIdeModeFeature: vi.fn().mockReturnValue(false),
             getIdeMode: vi.fn().mockReturnValue(true),
             getDebugMode: vi.fn().mockReturnValue(false),
+            getPreviewFeatures: vi.fn().mockReturnValue(false),
             getWorkspaceContext: vi.fn().mockReturnValue({
                 getDirectories: vi.fn().mockReturnValue(['/test/dir']),
             }),
@@ -254,6 +174,8 @@ describe('Gemini Client (client.ts)', () => {
             getSkipNextSpeakerCheck: vi.fn().mockReturnValue(false),
             getUseSmartEdit: vi.fn().mockReturnValue(false),
             getUseModelRouter: vi.fn().mockReturnValue(false),
+            getShowModelInfoInChat: vi.fn().mockReturnValue(false),
+            getContinueOnFailedApiCall: vi.fn(),
             getProjectRoot: vi.fn().mockReturnValue('/test/project/root'),
             storage: {
                 getProjectTempDir: vi.fn().mockReturnValue('/test/temp'),
@@ -265,10 +187,23 @@ describe('Gemini Client (client.ts)', () => {
                     reasoning: 'test',
                 }),
             }),
+            modelConfigService: {
+                getResolvedConfig(modelConfigKey) {
+                    return {
+                        model: modelConfigKey.model,
+                        generateContentConfig: {
+                            temperature: 0,
+                            topP: 1,
+                        },
+                    };
+                },
+            },
+            isInteractive: vi.fn().mockReturnValue(false),
         };
         client = new GeminiClient(mockConfig);
         await client.initialize();
         vi.mocked(mockConfig.getGeminiClient).mockReturnValue(client);
+        vi.mocked(uiTelemetryService.setLastPromptTokenCount).mockClear();
     });
     afterEach(() => {
         vi.restoreAllMocks();
@@ -309,6 +244,23 @@ describe('Gemini Client (client.ts)', () => {
             expect(JSON.stringify(newHistory)).not.toContain('some old message');
         });
     });
+    describe('startChat', () => {
+        it('should include environment context when resuming a session', async () => {
+            const extraHistory = [
+                { role: 'user', parts: [{ text: 'Old message' }] },
+                { role: 'model', parts: [{ text: 'Old response' }] },
+            ];
+            const chat = await client.startChat(extraHistory);
+            const history = chat.getHistory();
+            // The first message should be the environment context
+            expect(history[0].role).toBe('user');
+            expect(history[0].parts?.[0]?.text).toContain('This is the Gemini CLI');
+            expect(history[0].parts?.[0]?.text).toContain("The project's temporary directory is:");
+            // The subsequent messages should be the extra history
+            expect(history[1]).toEqual(extraHistory[0]);
+            expect(history[2]).toEqual(extraHistory[1]);
+        });
+    });
     describe('tryCompressChat', () => {
         const mockGetHistory = vi.fn();
         beforeEach(() => {
@@ -319,87 +271,64 @@ describe('Gemini Client (client.ts)', () => {
                 getHistory: mockGetHistory,
                 addHistory: vi.fn(),
                 setHistory: vi.fn(),
+                getLastPromptTokenCount: vi.fn(),
             };
         });
         function setup({ chatHistory = [
             { role: 'user', parts: [{ text: 'Long conversation' }] },
             { role: 'model', parts: [{ text: 'Long response' }] },
-        ], originalTokenCount = 1000, summaryText = 'This is a summary.', } = {}) {
+        ], originalTokenCount = 1000, newTokenCount = 500, compressionStatus = CompressionStatus.COMPRESSED, } = {}) {
             const mockOriginalChat = {
                 getHistory: vi.fn((_curated) => chatHistory),
                 setHistory: vi.fn(),
+                getLastPromptTokenCount: vi.fn().mockReturnValue(originalTokenCount),
             };
             client['chat'] = mockOriginalChat;
             vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(originalTokenCount);
-            mockGenerateContentFn.mockResolvedValue({
-                candidates: [
-                    {
-                        content: {
-                            role: 'model',
-                            parts: [{ text: summaryText }],
-                        },
-                    },
-                ],
-            });
-            // Calculate what the new history will be
-            const splitPoint = findCompressSplitPoint(chatHistory, 0.7); // 1 - 0.3
-            const historyToKeep = chatHistory.slice(splitPoint);
-            // This is the history that the new chat will have.
-            // It includes the default startChat history + the extra history from tryCompressChat
-            const newCompressedHistory = [
-                // Mocked envParts + canned response from startChat
-                {
-                    role: 'user',
-                    parts: [{ text: 'Mocked env context' }],
-                },
-                {
-                    role: 'model',
-                    parts: [{ text: 'Got it. Thanks for the context!' }],
-                },
-                // extraHistory from tryCompressChat
-                {
-                    role: 'user',
-                    parts: [{ text: summaryText }],
-                },
-                {
-                    role: 'model',
-                    parts: [{ text: 'Got it. Thanks for the additional context!' }],
-                },
-                ...historyToKeep,
+            const newHistory = [
+                { role: 'user', parts: [{ text: 'Summary' }] },
+                { role: 'model', parts: [{ text: 'Got it' }] },
             ];
+            vi.mocked(ChatCompressionService.prototype.compress).mockResolvedValue({
+                newHistory: compressionStatus === CompressionStatus.COMPRESSED
+                    ? newHistory
+                    : null,
+                info: {
+                    originalTokenCount,
+                    newTokenCount,
+                    compressionStatus,
+                },
+            });
             const mockNewChat = {
-                getHistory: vi.fn().mockReturnValue(newCompressedHistory),
+                getHistory: vi.fn().mockReturnValue(newHistory),
                 setHistory: vi.fn(),
+                getLastPromptTokenCount: vi.fn().mockReturnValue(newTokenCount),
             };
             client['startChat'] = vi
                 .fn()
                 .mockResolvedValue(mockNewChat);
-            const totalChars = newCompressedHistory.reduce((total, content) => total + JSON.stringify(content).length, 0);
-            const estimatedNewTokenCount = Math.floor(totalChars / 4);
             return {
                 client,
                 mockOriginalChat,
                 mockNewChat,
-                estimatedNewTokenCount,
+                estimatedNewTokenCount: newTokenCount,
             };
         }
         describe('when compression inflates the token count', () => {
             it('allows compression to be forced/manual after a failure', async () => {
-                // Call 1 (Fails): Setup with a long summary to inflate tokens
-                const longSummary = 'long summary '.repeat(100);
-                const { client, estimatedNewTokenCount: inflatedTokenCount } = setup({
+                // Call 1 (Fails): Setup with inflated tokens
+                setup({
                     originalTokenCount: 100,
-                    summaryText: longSummary,
+                    newTokenCount: 200,
+                    compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
                 });
-                expect(inflatedTokenCount).toBeGreaterThan(100); // Ensure setup is correct
                 await client.tryCompressChat('prompt-id-4', false); // Fails
-                // Call 2 (Forced): Re-setup with a short summary
-                const shortSummary = 'short';
+                // Call 2 (Forced): Re-setup with compressed tokens
                 const { estimatedNewTokenCount: compressedTokenCount } = setup({
                     originalTokenCount: 100,
-                    summaryText: shortSummary,
+                    newTokenCount: 50,
+                    compressionStatus: CompressionStatus.COMPRESSED,
                 });
-                expect(compressedTokenCount).toBeLessThanOrEqual(100); // Ensure setup is correct
                 const result = await client.tryCompressChat('prompt-id-4', true); // Forced
                 expect(result).toEqual({
                     compressionStatus: CompressionStatus.COMPRESSED,
@@ -408,12 +337,11 @@ describe('Gemini Client (client.ts)', () => {
                 });
             });
             it('yields the result even if the compression inflated the tokens', async () => {
-                const longSummary = 'long summary '.repeat(100);
                 const { client, estimatedNewTokenCount } = setup({
                     originalTokenCount: 100,
-                    summaryText: longSummary,
+                    newTokenCount: 200,
+                    compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
                 });
-                expect(estimatedNewTokenCount).toBeGreaterThan(100); // Ensure setup is correct
                 const result = await client.tryCompressChat('prompt-id-4', false);
                 expect(result).toEqual({
                     compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
@@ -424,47 +352,52 @@ describe('Gemini Client (client.ts)', () => {
                 expect(uiTelemetryService.setLastPromptTokenCount).not.toHaveBeenCalled();
             });
             it('does not manipulate the source chat', async () => {
-                const longSummary = 'long summary '.repeat(100);
-                const { client, mockOriginalChat, estimatedNewTokenCount } = setup({
+                const { client, mockOriginalChat } = setup({
                     originalTokenCount: 100,
-                    summaryText: longSummary,
+                    newTokenCount: 200,
+                    compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
                 });
-                expect(estimatedNewTokenCount).toBeGreaterThan(100); // Ensure setup is correct
                 await client.tryCompressChat('prompt-id-4', false);
                 // On failure, the chat should NOT be replaced
                 expect(client['chat']).toBe(mockOriginalChat);
             });
-            it('will not attempt to compress context after a failure', async () => {
-                const longSummary = 'long summary '.repeat(100);
-                const { client, estimatedNewTokenCount } = setup({
+            it.skip('will not attempt to compress context after a failure', async () => {
+                const { client } = setup({
                     originalTokenCount: 100,
-                    summaryText: longSummary,
+                    newTokenCount: 200,
+                    compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
                 });
-                expect(estimatedNewTokenCount).toBeGreaterThan(100); // Ensure setup is correct
                 await client.tryCompressChat('prompt-id-4', false); // This fails and sets hasFailedCompressionAttempt = true
+                // Mock the next call to return NOOP
+                vi.mocked(ChatCompressionService.prototype.compress).mockResolvedValueOnce({
+                    newHistory: null,
+                    info: {
+                        originalTokenCount: 0,
+                        newTokenCount: 0,
+                        compressionStatus: CompressionStatus.NOOP,
+                    },
+                });
                 // This call should now be a NOOP
                 const result = await client.tryCompressChat('prompt-id-5', false);
-                // generateContent (for summary) should only have been called once
-                expect(mockGenerateContentFn).toHaveBeenCalledTimes(1);
-                expect(result).toEqual({
-                    compressionStatus: CompressionStatus.NOOP,
-                    newTokenCount: 0,
-                    originalTokenCount: 0,
-                });
+                expect(result.compressionStatus).toBe(CompressionStatus.NOOP);
+                expect(ChatCompressionService.prototype.compress).toHaveBeenCalledTimes(2);
+                expect(ChatCompressionService.prototype.compress).toHaveBeenLastCalledWith(expect.anything(), 'prompt-id-5', false, expect.anything(), expect.anything(), true);
             });
         });
         it('should not trigger summarization if token count is below threshold', async () => {
             const MOCKED_TOKEN_LIMIT = 1000;
-            vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
-            mockGetHistory.mockReturnValue([
-                { role: 'user', parts: [{ text: '...history...' }] },
-            ]);
             const originalTokenCount = MOCKED_TOKEN_LIMIT * 0.699;
-            vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(originalTokenCount);
+            vi.mocked(ChatCompressionService.prototype.compress).mockResolvedValue({
+                newHistory: null,
+                info: {
+                    originalTokenCount,
+                    newTokenCount: originalTokenCount,
+                    compressionStatus: CompressionStatus.NOOP,
+                },
+            });
             const initialChat = client.getChat();
             const result = await client.tryCompressChat('prompt-id-2', false);
             const newChat = client.getChat();
-            expect(tokenLimit).toHaveBeenCalled();
             expect(result).toEqual({
                 compressionStatus: CompressionStatus.NOOP,
                 newTokenCount: originalTokenCount,
@@ -472,248 +405,19 @@ describe('Gemini Client (client.ts)', () => {
             });
             expect(newChat).toBe(initialChat);
         });
-        it('logs a telemetry event when compressing', async () => {
-            vi.spyOn(ClearcutLogger.prototype, 'logChatCompressionEvent');
-            const MOCKED_TOKEN_LIMIT = 1000;
-            const MOCKED_CONTEXT_PERCENTAGE_THRESHOLD = 0.5;
-            vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
-            vi.spyOn(client['config'], 'getChatCompression').mockReturnValue({
-                contextPercentageThreshold: MOCKED_CONTEXT_PERCENTAGE_THRESHOLD,
-            });
-            const history = [{ role: 'user', parts: [{ text: '...history...' }] }];
-            mockGetHistory.mockReturnValue(history);
-            const originalTokenCount = MOCKED_TOKEN_LIMIT * MOCKED_CONTEXT_PERCENTAGE_THRESHOLD;
-            vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(originalTokenCount);
-            // We need to control the estimated new token count.
-            // We mock startChat to return a chat with a known history.
-            const summaryText = 'This is a summary.';
-            const splitPoint = findCompressSplitPoint(history, 0.7);
-            const historyToKeep = history.slice(splitPoint);
-            const newCompressedHistory = [
-                { role: 'user', parts: [{ text: 'Mocked env context' }] },
-                { role: 'model', parts: [{ text: 'Got it. Thanks for the context!' }] },
-                { role: 'user', parts: [{ text: summaryText }] },
-                {
-                    role: 'model',
-                    parts: [{ text: 'Got it. Thanks for the additional context!' }],
-                },
-                ...historyToKeep,
-            ];
-            const mockNewChat = {
-                getHistory: vi.fn().mockReturnValue(newCompressedHistory),
-            };
-            client['startChat'] = vi
-                .fn()
-                .mockResolvedValue(mockNewChat);
-            const totalChars = newCompressedHistory.reduce((total, content) => total + JSON.stringify(content).length, 0);
-            const newTokenCount = Math.floor(totalChars / 4);
-            // Mock the summary response from the chat
-            mockGenerateContentFn.mockResolvedValue({
-                candidates: [
-                    {
-                        content: {
-                            role: 'model',
-                            parts: [{ text: summaryText }],
-                        },
-                    },
-                ],
-            });
-            await client.tryCompressChat('prompt-id-3', false);
-            expect(ClearcutLogger.prototype.logChatCompressionEvent).toHaveBeenCalledWith(expect.objectContaining({
-                tokens_before: originalTokenCount,
-                tokens_after: newTokenCount,
-            }));
-            expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledWith(newTokenCount);
-            expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalledTimes(1);
-        });
-        it('should trigger summarization if token count is at threshold with contextPercentageThreshold setting', async () => {
-            const MOCKED_TOKEN_LIMIT = 1000;
-            const MOCKED_CONTEXT_PERCENTAGE_THRESHOLD = 0.5;
-            vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
-            vi.spyOn(client['config'], 'getChatCompression').mockReturnValue({
-                contextPercentageThreshold: MOCKED_CONTEXT_PERCENTAGE_THRESHOLD,
-            });
-            const history = [{ role: 'user', parts: [{ text: '...history...' }] }];
-            mockGetHistory.mockReturnValue(history);
-            const originalTokenCount = MOCKED_TOKEN_LIMIT * MOCKED_CONTEXT_PERCENTAGE_THRESHOLD;
-            vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(originalTokenCount);
-            // Mock summary and new chat
-            const summaryText = 'This is a summary.';
-            const splitPoint = findCompressSplitPoint(history, 0.7);
-            const historyToKeep = history.slice(splitPoint);
-            const newCompressedHistory = [
-                { role: 'user', parts: [{ text: 'Mocked env context' }] },
-                { role: 'model', parts: [{ text: 'Got it. Thanks for the context!' }] },
-                { role: 'user', parts: [{ text: summaryText }] },
-                {
-                    role: 'model',
-                    parts: [{ text: 'Got it. Thanks for the additional context!' }],
-                },
-                ...historyToKeep,
-            ];
-            const mockNewChat = {
-                getHistory: vi.fn().mockReturnValue(newCompressedHistory),
-            };
-            client['startChat'] = vi
-                .fn()
-                .mockResolvedValue(mockNewChat);
-            const totalChars = newCompressedHistory.reduce((total, content) => total + JSON.stringify(content).length, 0);
-            const newTokenCount = Math.floor(totalChars / 4);
-            // Mock the summary response from the chat
-            mockGenerateContentFn.mockResolvedValue({
-                candidates: [
-                    {
-                        content: {
-                            role: 'model',
-                            parts: [{ text: summaryText }],
-                        },
-                    },
-                ],
-            });
-            const initialChat = client.getChat();
-            const result = await client.tryCompressChat('prompt-id-3', false);
-            const newChat = client.getChat();
-            expect(tokenLimit).toHaveBeenCalled();
-            expect(mockGenerateContentFn).toHaveBeenCalled();
-            // Assert that summarization happened and returned the correct stats
-            expect(result).toEqual({
-                compressionStatus: CompressionStatus.COMPRESSED,
-                originalTokenCount,
-                newTokenCount,
-            });
-            // Assert that the chat was reset
-            expect(newChat).not.toBe(initialChat);
-        });
-        it('should not compress across a function call response', async () => {
-            const MOCKED_TOKEN_LIMIT = 1000;
-            vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
-            const history = [
-                { role: 'user', parts: [{ text: '...history 1...' }] },
-                { role: 'model', parts: [{ text: '...history 2...' }] },
-                { role: 'user', parts: [{ text: '...history 3...' }] },
-                { role: 'model', parts: [{ text: '...history 4...' }] },
-                { role: 'user', parts: [{ text: '...history 5...' }] },
-                { role: 'model', parts: [{ text: '...history 6...' }] },
-                { role: 'user', parts: [{ text: '...history 7...' }] },
-                { role: 'model', parts: [{ text: '...history 8...' }] },
-                // Normally we would break here, but we have a function response.
-                {
-                    role: 'user',
-                    parts: [{ functionResponse: { name: '...history 8...' } }],
-                },
-                { role: 'model', parts: [{ text: '...history 10...' }] },
-                // Instead we will break here.
-                { role: 'user', parts: [{ text: '...history 10...' }] },
-            ];
-            mockGetHistory.mockReturnValue(history);
-            const originalTokenCount = 1000 * 0.7;
-            vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(originalTokenCount);
-            // Mock summary and new chat
-            const summaryText = 'This is a summary.';
-            const splitPoint = findCompressSplitPoint(history, 0.7); // This should be 10
-            expect(splitPoint).toBe(10); // Verify split point logic
-            const historyToKeep = history.slice(splitPoint); // Should keep last user message
-            expect(historyToKeep).toEqual([
-                { role: 'user', parts: [{ text: '...history 10...' }] },
-            ]);
-            const newCompressedHistory = [
-                { role: 'user', parts: [{ text: 'Mocked env context' }] },
-                { role: 'model', parts: [{ text: 'Got it. Thanks for the context!' }] },
-                { role: 'user', parts: [{ text: summaryText }] },
-                {
-                    role: 'model',
-                    parts: [{ text: 'Got it. Thanks for the additional context!' }],
-                },
-                ...historyToKeep,
-            ];
-            const mockNewChat = {
-                getHistory: vi.fn().mockReturnValue(newCompressedHistory),
-            };
-            client['startChat'] = vi
-                .fn()
-                .mockResolvedValue(mockNewChat);
-            const totalChars = newCompressedHistory.reduce((total, content) => total + JSON.stringify(content).length, 0);
-            const newTokenCount = Math.floor(totalChars / 4);
-            // Mock the summary response from the chat
-            mockGenerateContentFn.mockResolvedValue({
-                candidates: [
-                    {
-                        content: {
-                            role: 'model',
-                            parts: [{ text: summaryText }],
-                        },
-                    },
-                ],
-            });
-            const initialChat = client.getChat();
-            const result = await client.tryCompressChat('prompt-id-3', false);
-            const newChat = client.getChat();
-            expect(tokenLimit).toHaveBeenCalled();
-            expect(mockGenerateContentFn).toHaveBeenCalled();
-            // Assert that summarization happened and returned the correct stats
-            expect(result).toEqual({
-                compressionStatus: CompressionStatus.COMPRESSED,
-                originalTokenCount,
-                newTokenCount,
-            });
-            // Assert that the chat was reset
-            expect(newChat).not.toBe(initialChat);
-            // 1. standard start context message (env)
-            // 2. standard canned model response
-            // 3. compressed summary message (user)
-            // 4. standard canned model response
-            // 5. The last user message (historyToKeep)
-            expect(newChat.getHistory().length).toEqual(5);
-        });
-        it('should always trigger summarization when force is true, regardless of token count', async () => {
-            const history = [{ role: 'user', parts: [{ text: '...history...' }] }];
-            mockGetHistory.mockReturnValue(history);
-            const originalTokenCount = 100; // Well below threshold, but > estimated new count
-            vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(originalTokenCount);
-            // Mock summary and new chat
-            const summaryText = 'This is a summary.';
-            const splitPoint = findCompressSplitPoint(history, 0.7);
-            const historyToKeep = history.slice(splitPoint);
-            const newCompressedHistory = [
-                { role: 'user', parts: [{ text: 'Mocked env context' }] },
-                { role: 'model', parts: [{ text: 'Got it. Thanks for the context!' }] },
-                { role: 'user', parts: [{ text: summaryText }] },
-                {
-                    role: 'model',
-                    parts: [{ text: 'Got it. Thanks for the additional context!' }],
-                },
-                ...historyToKeep,
-            ];
-            const mockNewChat = {
-                getHistory: vi.fn().mockReturnValue(newCompressedHistory),
-            };
-            client['startChat'] = vi
-                .fn()
-                .mockResolvedValue(mockNewChat);
-            const totalChars = newCompressedHistory.reduce((total, content) => total + JSON.stringify(content).length, 0);
-            const newTokenCount = Math.floor(totalChars / 4);
-            // Mock the summary response from the chat
-            mockGenerateContentFn.mockResolvedValue({
-                candidates: [
-                    {
-                        content: {
-                            role: 'model',
-                            parts: [{ text: summaryText }],
-                        },
-                    },
-                ],
+        it('should return NOOP if history is too short to compress', async () => {
+            const { client } = setup({
+                chatHistory: [{ role: 'user', parts: [{ text: 'hi' }] }],
+                originalTokenCount: 50,
+                newTokenCount: 50,
+                compressionStatus: CompressionStatus.NOOP,
             });
-            const initialChat = client.getChat();
-            const result = await client.tryCompressChat('prompt-id-1', true); // force = true
-            const newChat = client.getChat();
-            expect(mockGenerateContentFn).toHaveBeenCalled();
+            const result = await client.tryCompressChat('prompt-id-noop', false);
             expect(result).toEqual({
-                compressionStatus: CompressionStatus.COMPRESSED,
-                originalTokenCount,
-                newTokenCount,
+                compressionStatus: CompressionStatus.NOOP,
+                originalTokenCount: 50,
+                newTokenCount: 50,
             });
-            // Assert that the chat was reset
-            expect(newChat).not.toBe(initialChat);
         });
     });
     describe('sendMessageStream', () => {
@@ -798,6 +502,7 @@ describe('Gemini Client (client.ts)', () => {
             const mockChat = {
                 addHistory: vi.fn(),
                 getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
             };
             client['chat'] = mockChat;
             const initialRequest = [{ text: 'Hi' }];
@@ -845,6 +550,7 @@ ${JSON.stringify({
             const mockChat = {
                 addHistory: vi.fn(),
                 getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
             };
             client['chat'] = mockChat;
             const initialRequest = [{ text: 'Hi' }];
@@ -855,11 +561,7 @@ ${JSON.stringify({
             }
             // Assert
             expect(ideContextStore.get).toHaveBeenCalled();
-            // The `turn.run` method is now called with the model name as the first
-            // argument. We use `expect.any(String)` because this test is
-            // concerned with the IDE context logic, not the model routing,
-            // which is tested in its own dedicated suite.
-            expect(mockTurnRunFn).toHaveBeenCalledWith(expect.any(String), initialRequest, expect.any(Object));
+            expect(mockTurnRunFn).toHaveBeenCalledWith({ model: 'default-routed-model' }, initialRequest, expect.any(AbortSignal));
         });
         it('should add context if ideMode is enabled and there is one active file', async () => {
             // Arrange
@@ -889,6 +591,7 @@ ${JSON.stringify({
             const mockChat = {
                 addHistory: vi.fn(),
                 getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
             };
             client['chat'] = mockChat;
             const initialRequest = [{ text: 'Hi' }];
@@ -949,6 +652,7 @@ ${JSON.stringify({
             const mockChat = {
                 addHistory: vi.fn(),
                 getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
             };
             client['chat'] = mockChat;
             const initialRequest = [{ text: 'Hi' }];
@@ -982,6 +686,7 @@ ${JSON.stringify({
             const mockChat = {
                 addHistory: vi.fn(),
                 getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
             };
             client['chat'] = mockChat;
             // Act
@@ -999,6 +704,7 @@ ${JSON.stringify({
             expect(finalResult).toBeInstanceOf(Turn);
         });
         it('should stop infinite loop after MAX_TURNS when nextSpeaker always returns model', async () => {
+            vi.spyOn(client['config'], 'getContinueOnFailedApiCall').mockReturnValue(true);
             // Get the mocked checkNextSpeaker function and configure it to trigger infinite loop
             const { checkNextSpeaker } = await import('../utils/nextSpeakerChecker.js');
             const mockCheckNextSpeaker = vi.mocked(checkNextSpeaker);
@@ -1014,6 +720,7 @@ ${JSON.stringify({
             const mockChat = {
                 addHistory: vi.fn(),
                 getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
             };
             client['chat'] = mockChat;
             // Use a signal that never gets aborted
@@ -1040,27 +747,10 @@ ${JSON.stringify({
             }
             // Assert
             expect(finalResult).toBeInstanceOf(Turn);
-            // Debug: Check how many times checkNextSpeaker was called
-            const callCount = mockCheckNextSpeaker.mock.calls.length;
             // If infinite loop protection is working, checkNextSpeaker should be called many times
             // but stop at MAX_TURNS (100). Since each recursive call should trigger checkNextSpeaker,
             // we expect it to be called multiple times before hitting the limit
             expect(mockCheckNextSpeaker).toHaveBeenCalled();
-            // The test should demonstrate that the infinite loop protection works:
-            // - If checkNextSpeaker is called many times (close to MAX_TURNS), it shows the loop was happening
-            // - If it's only called once, the recursive behavior might not be triggered
-            if (callCount === 0) {
-                throw new Error('checkNextSpeaker was never called - the recursive condition was not met');
-            }
-            else if (callCount === 1) {
-                // This might be expected behavior if the turn has pending tool calls or other conditions prevent recursion
-                console.log('checkNextSpeaker called only once - no infinite loop occurred');
-            }
-            else {
-                console.log(`checkNextSpeaker called ${callCount} times - infinite loop protection worked`);
-                // If called multiple times, we expect it to be stopped before MAX_TURNS
-                expect(callCount).toBeLessThanOrEqual(100); // Should not exceed MAX_TURNS
-            }
             // The stream should produce events and eventually terminate
             expect(eventCount).toBeGreaterThanOrEqual(1);
             expect(eventCount).toBeLessThan(200); // Should not exceed our safety limit
@@ -1076,6 +766,7 @@ ${JSON.stringify({
             const mockChat = {
                 addHistory: vi.fn(),
                 getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
             };
             client['chat'] = mockChat;
             // Act & Assert
@@ -1114,6 +805,7 @@ ${JSON.stringify({
             const mockChat = {
                 addHistory: vi.fn(),
                 getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
             };
             client['chat'] = mockChat;
             // Use a signal that never gets aborted
@@ -1141,9 +833,8 @@ ${JSON.stringify({
                     }
                 }
             }
-            catch (error) {
+            catch (_) {
                 // If the test framework times out, that also demonstrates the infinite loop
-                console.error('Test timed out or errored:', error);
             }
             // Assert that the fix works - the loop should stop at MAX_TURNS
             const callCount = mockCheckNextSpeaker.mock.calls.length;
@@ -1151,8 +842,90 @@ ${JSON.stringify({
             // the loop should stop at MAX_TURNS (100)
             expect(callCount).toBeLessThanOrEqual(100); // Should not exceed MAX_TURNS
             expect(eventCount).toBeLessThanOrEqual(200); // Should have reasonable number of events
-            console.log(`Infinite loop protection working: checkNextSpeaker called ${callCount} times, ` +
-                `${eventCount} events generated (properly bounded by MAX_TURNS)`);
+        });
+        it('should yield ContextWindowWillOverflow when the context window is about to overflow', async () => {
+            // Arrange
+            const MOCKED_TOKEN_LIMIT = 1000;
+            vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
+            // Set last prompt token count
+            const lastPromptTokenCount = 900;
+            const mockChat = {
+                getLastPromptTokenCount: vi.fn().mockReturnValue(lastPromptTokenCount),
+                getHistory: vi.fn().mockReturnValue([]),
+            };
+            client['chat'] = mockChat;
+            // Remaining = 100. Threshold (95%) = 95.
+            // We need a request > 95 tokens.
+            // A string of length 400 is roughly 100 tokens.
+            const longText = 'a'.repeat(400);
+            const request = [{ text: longText }];
+            const estimatedRequestTokenCount = Math.floor(JSON.stringify(request).length / 4);
+            const remainingTokenCount = MOCKED_TOKEN_LIMIT - lastPromptTokenCount;
+            // Mock tryCompressChat to not compress
+            vi.spyOn(client, 'tryCompressChat').mockResolvedValue({
+                originalTokenCount: lastPromptTokenCount,
+                newTokenCount: lastPromptTokenCount,
+                compressionStatus: CompressionStatus.NOOP,
+            });
+            // Act
+            const stream = client.sendMessageStream(request, new AbortController().signal, 'prompt-id-overflow');
+            const events = await fromAsync(stream);
+            // Assert
+            expect(events).toContainEqual({
+                type: GeminiEventType.ContextWindowWillOverflow,
+                value: {
+                    estimatedRequestTokenCount,
+                    remainingTokenCount,
+                },
+            });
+            // Ensure turn.run is not called
+            expect(mockTurnRunFn).not.toHaveBeenCalled();
+        });
+        it("should use the sticky model's token limit for the overflow check", async () => {
+            // Arrange
+            const STICKY_MODEL = 'gemini-1.5-flash';
+            const STICKY_MODEL_LIMIT = 1000;
+            const CONFIG_MODEL_LIMIT = 2000;
+            // Set up token limits
+            vi.mocked(tokenLimit).mockImplementation((model) => {
+                if (model === STICKY_MODEL)
+                    return STICKY_MODEL_LIMIT;
+                return CONFIG_MODEL_LIMIT;
+            });
+            // Set the sticky model
+            client['currentSequenceModel'] = STICKY_MODEL;
+            // Set token count
+            const lastPromptTokenCount = 900;
+            const mockChat = {
+                getLastPromptTokenCount: vi.fn().mockReturnValue(lastPromptTokenCount),
+                getHistory: vi.fn().mockReturnValue([]),
+            };
+            client['chat'] = mockChat;
+            // Remaining (sticky) = 100. Threshold (95%) = 95.
+            // We need a request > 95 tokens.
+            const longText = 'a'.repeat(400);
+            const request = [{ text: longText }];
+            const estimatedRequestTokenCount = Math.floor(JSON.stringify(request).length / 4);
+            const remainingTokenCount = STICKY_MODEL_LIMIT - lastPromptTokenCount;
+            vi.spyOn(client, 'tryCompressChat').mockResolvedValue({
+                originalTokenCount: lastPromptTokenCount,
+                newTokenCount: lastPromptTokenCount,
+                compressionStatus: CompressionStatus.NOOP,
+            });
+            // Act
+            const stream = client.sendMessageStream(request, new AbortController().signal, 'test-session-id');
+            const events = await fromAsync(stream);
+            // Assert
+            // Should overflow based on the sticky model's limit
+            expect(events).toContainEqual({
+                type: GeminiEventType.ContextWindowWillOverflow,
+                value: {
+                    estimatedRequestTokenCount,
+                    remainingTokenCount,
+                },
+            });
+            expect(tokenLimit).toHaveBeenCalledWith(STICKY_MODEL);
+            expect(mockTurnRunFn).not.toHaveBeenCalled();
         });
         describe('Model Routing', () => {
             let mockRouterService;
@@ -1166,35 +939,40 @@ ${JSON.stringify({
                 mockTurnRunFn.mockReturnValue((async function* () {
                     yield { type: 'content', value: 'Hello' };
                 })());
+                const mockChat = {
+                    addHistory: vi.fn(),
+                    getHistory: vi.fn().mockReturnValue([]),
+                    getLastPromptTokenCount: vi.fn(),
+                };
+                client['chat'] = mockChat;
             });
             it('should use the model router service to select a model on the first turn', async () => {
                 const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-1');
                 await fromAsync(stream); // consume stream
                 expect(mockConfig.getModelRouterService).toHaveBeenCalled();
                 expect(mockRouterService.route).toHaveBeenCalled();
-                expect(mockTurnRunFn).toHaveBeenCalledWith('routed-model', // The model from the router
-                [{ text: 'Hi' }], expect.any(Object));
+                expect(mockTurnRunFn).toHaveBeenCalledWith({ model: 'routed-model' }, [{ text: 'Hi' }], expect.any(AbortSignal));
             });
             it('should use the same model for subsequent turns in the same prompt (stickiness)', async () => {
                 // First turn
                 let stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-1');
                 await fromAsync(stream);
                 expect(mockRouterService.route).toHaveBeenCalledTimes(1);
-                expect(mockTurnRunFn).toHaveBeenCalledWith('routed-model', [{ text: 'Hi' }], expect.any(Object));
+                expect(mockTurnRunFn).toHaveBeenCalledWith({ model: 'routed-model' }, [{ text: 'Hi' }], expect.any(AbortSignal));
                 // Second turn
                 stream = client.sendMessageStream([{ text: 'Continue' }], new AbortController().signal, 'prompt-1');
                 await fromAsync(stream);
                 // Router should not be called again
                 expect(mockRouterService.route).toHaveBeenCalledTimes(1);
                 // Should stick to the first model
-                expect(mockTurnRunFn).toHaveBeenCalledWith('routed-model', [{ text: 'Continue' }], expect.any(Object));
+                expect(mockTurnRunFn).toHaveBeenCalledWith({ model: 'routed-model' }, [{ text: 'Continue' }], expect.any(AbortSignal));
             });
             it('should reset the sticky model and re-route when the prompt_id changes', async () => {
                 // First prompt
                 let stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-1');
                 await fromAsync(stream);
                 expect(mockRouterService.route).toHaveBeenCalledTimes(1);
-                expect(mockTurnRunFn).toHaveBeenCalledWith('routed-model', [{ text: 'Hi' }], expect.any(Object));
+                expect(mockTurnRunFn).toHaveBeenCalledWith({ model: 'routed-model' }, [{ text: 'Hi' }], expect.any(AbortSignal));
                 // New prompt
                 mockRouterService.route.mockResolvedValue({
                     model: 'new-routed-model',
@@ -1205,7 +983,7 @@ ${JSON.stringify({
                 // Router should be called again for the new prompt
                 expect(mockRouterService.route).toHaveBeenCalledTimes(2);
                 // Should use the newly routed model
-                expect(mockTurnRunFn).toHaveBeenCalledWith('new-routed-model', [{ text: 'A new topic' }], expect.any(Object));
+                expect(mockTurnRunFn).toHaveBeenCalledWith({ model: 'new-routed-model' }, [{ text: 'A new topic' }], expect.any(AbortSignal));
             });
             it('should use the fallback model and bypass routing when in fallback mode', async () => {
                 vi.mocked(mockConfig.isInFallbackMode).mockReturnValue(true);
@@ -1215,7 +993,7 @@ ${JSON.stringify({
                 });
                 const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-1');
                 await fromAsync(stream);
-                expect(mockTurnRunFn).toHaveBeenCalledWith(DEFAULT_GEMINI_FLASH_MODEL, [{ text: 'Hi' }], expect.any(Object));
+                expect(mockTurnRunFn).toHaveBeenCalledWith({ model: DEFAULT_GEMINI_FLASH_MODEL }, [{ text: 'Hi' }], expect.any(AbortSignal));
             });
             it('should stick to the fallback model for the entire sequence even if fallback mode ends', async () => {
                 // Start the sequence in fallback mode
@@ -1227,7 +1005,7 @@ ${JSON.stringify({
                 let stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-fallback-stickiness');
                 await fromAsync(stream);
                 // First call should use fallback model
-                expect(mockTurnRunFn).toHaveBeenCalledWith(DEFAULT_GEMINI_FLASH_MODEL, [{ text: 'Hi' }], expect.any(Object));
+                expect(mockTurnRunFn).toHaveBeenCalledWith({ model: DEFAULT_GEMINI_FLASH_MODEL }, [{ text: 'Hi' }], expect.any(AbortSignal));
                 // End fallback mode
                 vi.mocked(mockConfig.isInFallbackMode).mockReturnValue(false);
                 // Second call in the same sequence
@@ -1235,10 +1013,102 @@ ${JSON.stringify({
                 await fromAsync(stream);
                 // Router should still not be called, and it should stick to the fallback model
                 expect(mockTurnRunFn).toHaveBeenCalledTimes(2); // Ensure it was called again
-                expect(mockTurnRunFn).toHaveBeenLastCalledWith(DEFAULT_GEMINI_FLASH_MODEL, // Still the fallback model
-                [{ text: 'Continue' }], expect.any(Object));
+                expect(mockTurnRunFn).toHaveBeenLastCalledWith({ model: DEFAULT_GEMINI_FLASH_MODEL }, // Still the fallback model
+                [{ text: 'Continue' }], expect.any(AbortSignal));
             });
         });
+        it('should recursively call sendMessageStream with "Please continue." when InvalidStream event is received', async () => {
+            vi.spyOn(client['config'], 'getContinueOnFailedApiCall').mockReturnValue(true);
+            // Arrange
+            const mockStream1 = (async function* () {
+                yield { type: GeminiEventType.InvalidStream };
+            })();
+            const mockStream2 = (async function* () {
+                yield { type: GeminiEventType.Content, value: 'Continued content' };
+            })();
+            mockTurnRunFn
+                .mockReturnValueOnce(mockStream1)
+                .mockReturnValueOnce(mockStream2);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            const initialRequest = [{ text: 'Hi' }];
+            const promptId = 'prompt-id-invalid-stream';
+            const signal = new AbortController().signal;
+            // Act
+            const stream = client.sendMessageStream(initialRequest, signal, promptId);
+            const events = await fromAsync(stream);
+            // Assert
+            expect(events).toEqual([
+                { type: GeminiEventType.ModelInfo, value: 'default-routed-model' },
+                { type: GeminiEventType.InvalidStream },
+                { type: GeminiEventType.Content, value: 'Continued content' },
+            ]);
+            // Verify that turn.run was called twice
+            expect(mockTurnRunFn).toHaveBeenCalledTimes(2);
+            // First call with original request
+            expect(mockTurnRunFn).toHaveBeenNthCalledWith(1, { model: 'default-routed-model' }, initialRequest, expect.any(AbortSignal));
+            // Second call with "Please continue."
+            expect(mockTurnRunFn).toHaveBeenNthCalledWith(2, { model: 'default-routed-model' }, [{ text: 'System: Please continue.' }], expect.any(AbortSignal));
+        });
+        it('should not recursively call sendMessageStream with "Please continue." when InvalidStream event is received and flag is false', async () => {
+            vi.spyOn(client['config'], 'getContinueOnFailedApiCall').mockReturnValue(false);
+            // Arrange
+            const mockStream1 = (async function* () {
+                yield { type: GeminiEventType.InvalidStream };
+            })();
+            mockTurnRunFn.mockReturnValueOnce(mockStream1);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            const initialRequest = [{ text: 'Hi' }];
+            const promptId = 'prompt-id-invalid-stream';
+            const signal = new AbortController().signal;
+            // Act
+            const stream = client.sendMessageStream(initialRequest, signal, promptId);
+            const events = await fromAsync(stream);
+            // Assert
+            expect(events).toEqual([
+                { type: GeminiEventType.ModelInfo, value: 'default-routed-model' },
+                { type: GeminiEventType.InvalidStream },
+            ]);
+            // Verify that turn.run was called only once
+            expect(mockTurnRunFn).toHaveBeenCalledTimes(1);
+        });
+        it('should stop recursing after one retry when InvalidStream events are repeatedly received', async () => {
+            vi.spyOn(client['config'], 'getContinueOnFailedApiCall').mockReturnValue(true);
+            // Arrange
+            // Always return a new invalid stream
+            mockTurnRunFn.mockImplementation(() => (async function* () {
+                yield { type: GeminiEventType.InvalidStream };
+            })());
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            const initialRequest = [{ text: 'Hi' }];
+            const promptId = 'prompt-id-infinite-invalid-stream';
+            const signal = new AbortController().signal;
+            // Act
+            const stream = client.sendMessageStream(initialRequest, signal, promptId);
+            const events = await fromAsync(stream);
+            // Assert
+            // We expect 3 events (model_info + original + 1 retry)
+            expect(events.length).toBe(3);
+            expect(events
+                .filter((e) => e.type !== GeminiEventType.ModelInfo)
+                .every((e) => e.type === GeminiEventType.InvalidStream)).toBe(true);
+            // Verify that turn.run was called twice
+            expect(mockTurnRunFn).toHaveBeenCalledTimes(2);
+        });
         describe('Editor context delta', () => {
             const mockStream = (async function* () {
                 yield { type: 'content', value: 'Hello' };
@@ -1261,6 +1131,7 @@ ${JSON.stringify({
                         .mockReturnValue([
                         { role: 'user', parts: [{ text: 'previous message' }] },
                     ]),
+                    getLastPromptTokenCount: vi.fn(),
                 };
                 client['chat'] = mockChat;
             });
@@ -1381,7 +1252,11 @@ ${JSON.stringify({
                 vi.mocked(ideContextStore.get).mockReturnValue({
                     workspaceState: {
                         openFiles: [
-                            { ...currentActiveFile, isActive: true, timestamp: Date.now() },
+                            {
+                                ...currentActiveFile,
+                                isActive: true,
+                                timestamp: Date.now(),
+                            },
                         ],
                     },
                 });
@@ -1469,6 +1344,7 @@ ${JSON.stringify({
                     addHistory: vi.fn(),
                     getHistory: vi.fn().mockReturnValue([]), // Default empty history
                     setHistory: vi.fn(),
+                    getLastPromptTokenCount: vi.fn(),
                 };
                 client['chat'] = mockChat;
                 vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
@@ -1732,6 +1608,7 @@ ${JSON.stringify({
             const mockChat = {
                 addHistory: vi.fn(),
                 getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
             };
             client['chat'] = mockChat;
             // Act
@@ -1757,6 +1634,7 @@ ${JSON.stringify({
             const mockChat = {
                 addHistory: vi.fn(),
                 getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
             };
             client['chat'] = mockChat;
             // Act
@@ -1774,7 +1652,7 @@ ${JSON.stringify({
                 .mockReturnValueOnce(false)
                 .mockReturnValueOnce(true);
             let capturedSignal;
-            mockTurnRunFn.mockImplementation((model, request, signal) => {
+            mockTurnRunFn.mockImplementation((_modelConfigKey, _request, signal) => {
                 capturedSignal = signal;
                 return (async function* () {
                     yield { type: 'content', value: 'First event' };
@@ -1784,6 +1662,7 @@ ${JSON.stringify({
             const mockChat = {
                 addHistory: vi.fn(),
                 getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
             };
             client['chat'] = mockChat;
             // Act
@@ -1800,15 +1679,14 @@ ${JSON.stringify({
     describe('generateContent', () => {
         it('should call generateContent with the correct parameters', async () => {
             const contents = [{ role: 'user', parts: [{ text: 'hello' }] }];
-            const generationConfig = { temperature: 0.5 };
             const abortSignal = new AbortController().signal;
-            await client.generateContent(contents, generationConfig, abortSignal, DEFAULT_GEMINI_FLASH_MODEL);
+            await client.generateContent({ model: DEFAULT_GEMINI_FLASH_MODEL }, contents, abortSignal);
             expect(mockContentGenerator.generateContent).toHaveBeenCalledWith({
                 model: DEFAULT_GEMINI_FLASH_MODEL,
                 config: {
                     abortSignal,
-                    systemInstruction: getCoreSystemPrompt(''),
-                    temperature: 0.5,
+                    systemInstruction: getCoreSystemPrompt({}, ''),
+                    temperature: 0,
                     topP: 1,
                 },
                 contents,
@@ -1819,7 +1697,7 @@ ${JSON.stringify({
             const contents = [{ role: 'user', parts: [{ text: 'test' }] }];
             const currentModel = initialModel + '-changed';
             vi.spyOn(client['config'], 'getModel').mockReturnValueOnce(currentModel);
-            await client.generateContent(contents, {}, new AbortController().signal, DEFAULT_GEMINI_FLASH_MODEL);
+            await client.generateContent({ model: DEFAULT_GEMINI_FLASH_MODEL }, contents, new AbortController().signal);
             expect(mockContentGenerator.generateContent).not.toHaveBeenCalledWith({
                 model: initialModel,
                 config: expect.any(Object),
@@ -1833,12 +1711,11 @@ ${JSON.stringify({
         });
         it('should use the Flash model when fallback mode is active', async () => {
             const contents = [{ role: 'user', parts: [{ text: 'hello' }] }];
-            const generationConfig = { temperature: 0.5 };
             const abortSignal = new AbortController().signal;
             const requestedModel = 'gemini-2.5-pro'; // A non-flash model
             // Mock config to be in fallback mode
             vi.spyOn(client['config'], 'isInFallbackMode').mockReturnValue(true);
-            await client.generateContent(contents, generationConfig, abortSignal, requestedModel);
+            await client.generateContent({ model: requestedModel }, contents, abortSignal);
             expect(mockGenerateContentFn).toHaveBeenCalledWith(expect.objectContaining({
                 model: DEFAULT_GEMINI_FLASH_MODEL,
             }), 'test-session-id');