@didim365/agent-cli-core 0.1.0

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

@@ -0,0 +1,2654 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
+import { GeminiClient } from './client.js';
+import { AuthType, } from './contentGenerator.js';
+import { GeminiChat } from './geminiChat.js';
+import { CompressionStatus, LlmEventType, Turn, } from './turn.js';
+import { getCoreSystemPrompt } from './prompts.js';
+import { DEFAULT_GEMINI_MODEL_AUTO } from '../config/models.js';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+import { setSimulate429 } from '../utils/testUtils.js';
+import { tokenLimit } from './tokenLimits.js';
+import { ideContextStore } from '../ide/ideContext.js';
+import { uiTelemetryService } from '../telemetry/uiTelemetry.js';
+import { ChatCompressionService } from '../services/chatCompressionService.js';
+import { createAvailabilityServiceMock } from '../availability/testUtils.js';
+import { ClearcutLogger } from '../telemetry/clearcut-logger/clearcut-logger.js';
+import * as policyCatalog from '../availability/policyCatalog.js';
+import { partToString } from '../utils/partUtils.js';
+import { coreEvents } from '../utils/events.js';
+// Mock fs module to prevent actual file system operations during tests
+const mockFileSystem = new Map();
+vi.mock('node:fs', () => {
+    const fsModule = {
+        mkdirSync: vi.fn(),
+        writeFileSync: vi.fn((path, data) => {
+            mockFileSystem.set(path, data);
+        }),
+        readFileSync: vi.fn((path) => {
+            if (mockFileSystem.has(path)) {
+                return mockFileSystem.get(path);
+            }
+            throw Object.assign(new Error('ENOENT: no such file or directory'), {
+                code: 'ENOENT',
+            });
+        }),
+        existsSync: vi.fn((path) => mockFileSystem.has(path)),
+        createWriteStream: vi.fn(() => ({
+            write: vi.fn(),
+            on: vi.fn(),
+        })),
+    };
+    return {
+        default: fsModule,
+        ...fsModule,
+    };
+});
+const mockTurnRunFn = vi.fn();
+vi.mock('./turn', async (importOriginal) => {
+    const actual = await importOriginal();
+    // Define a mock class that has the same shape as the real Turn
+    class MockTurn {
+        pendingToolCalls = [];
+        // The run method is a property that holds our mock function
+        run = mockTurnRunFn;
+        constructor() {
+            // The constructor can be empty or do some mock setup
+        }
+        getResponseText = vi.fn().mockReturnValue('Mock Response');
+    }
+    // Export the mock class as 'Turn'
+    return {
+        ...actual,
+        Turn: MockTurn,
+    };
+});
+vi.mock('../config/config.js');
+vi.mock('./prompts');
+vi.mock('../utils/getFolderStructure', () => ({
+    getFolderStructure: vi.fn().mockResolvedValue('Mock Folder Structure'),
+}));
+vi.mock('../utils/errorReporting', () => ({ reportError: vi.fn() }));
+vi.mock('../utils/nextSpeakerChecker', () => ({
+    checkNextSpeaker: vi.fn().mockResolvedValue(null),
+}));
+vi.mock('../utils/generateContentResponseUtilities', () => ({
+    getResponseText: (result) => result.candidates?.[0]?.content?.parts?.map((part) => part.text).join('') ||
+        undefined,
+}));
+vi.mock('../telemetry/index.js', () => ({
+    logApiRequest: vi.fn(),
+    logApiResponse: vi.fn(),
+    logApiError: vi.fn(),
+}));
+vi.mock('../ide/ideContext.js');
+vi.mock('../telemetry/uiTelemetry.js', () => ({
+    uiTelemetryService: {
+        setLastPromptTokenCount: vi.fn(),
+        getLastPromptTokenCount: vi.fn(),
+    },
+}));
+vi.mock('../hooks/hookSystem.js');
+const mockHookSystem = {
+    fireBeforeAgentEvent: vi.fn().mockResolvedValue(undefined),
+    fireAfterAgentEvent: vi.fn().mockResolvedValue(undefined),
+    firePreCompressEvent: vi.fn().mockResolvedValue(undefined),
+};
+/**
+ * Array.fromAsync ponyfill, which will be available in es 2024.
+ *
+ * Buffers an async generator into an array and returns the result.
+ */
+async function fromAsync(promise) {
+    const results = [];
+    for await (const result of promise) {
+        results.push(result);
+    }
+    return results;
+}
+describe('Gemini Client (client.ts)', () => {
+    let mockContentGenerator;
+    let mockConfig;
+    let client;
+    let mockGenerateContentFn;
+    let mockRouterService;
+    beforeEach(async () => {
+        vi.resetAllMocks();
+        ClearcutLogger.clearInstance();
+        vi.mocked(uiTelemetryService.setLastPromptTokenCount).mockClear();
+        mockGenerateContentFn = vi.fn().mockResolvedValue({
+            candidates: [{ content: { parts: [{ text: '{"key": "value"}' }] } }],
+        });
+        // Disable 429 simulation for tests
+        setSimulate429(false);
+        mockRouterService = {
+            route: vi
+                .fn()
+                .mockResolvedValue({ model: 'default-routed-model', reason: 'test' }),
+        };
+        mockContentGenerator = {
+            generateContent: mockGenerateContentFn,
+            generateContentStream: vi.fn(),
+            batchEmbedContents: vi.fn(),
+            countTokens: vi.fn().mockResolvedValue({ totalTokens: 100 }),
+        };
+        // Because the GeminiClient constructor kicks off an async process (startChat)
+        // that depends on a fully-formed Config object, we need to mock the
+        // entire implementation of Config for these tests.
+        const mockToolRegistry = {
+            getFunctionDeclarations: vi.fn().mockReturnValue([]),
+            getTool: vi.fn().mockReturnValue(null),
+        };
+        const fileService = new FileDiscoveryService('/test/dir');
+        const contentGeneratorConfig = {
+            apiKey: 'test-key',
+            vertexai: false,
+            authType: AuthType.USE_GEMINI,
+        };
+        mockConfig = {
+            getContentGeneratorConfig: vi
+                .fn()
+                .mockReturnValue(contentGeneratorConfig),
+            getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
+            getModel: vi.fn().mockReturnValue('test-model'),
+            getUserTier: vi.fn().mockReturnValue(undefined),
+            getEmbeddingModel: vi.fn().mockReturnValue('test-embedding-model'),
+            getApiKey: vi.fn().mockReturnValue('test-key'),
+            getVertexAI: vi.fn().mockReturnValue(false),
+            getUserAgent: vi.fn().mockReturnValue('test-agent'),
+            getUserMemory: vi.fn().mockReturnValue(''),
+            getGlobalMemory: vi.fn().mockReturnValue(''),
+            getEnvironmentMemory: vi.fn().mockReturnValue(''),
+            isJitContextEnabled: vi.fn().mockReturnValue(false),
+            getSessionId: vi.fn().mockReturnValue('test-session-id'),
+            getProxy: vi.fn().mockReturnValue(undefined),
+            getWorkingDir: vi.fn().mockReturnValue('/test/dir'),
+            getFileService: vi.fn().mockReturnValue(fileService),
+            getMaxSessionTurns: vi.fn().mockReturnValue(0),
+            getQuotaErrorOccurred: vi.fn().mockReturnValue(false),
+            setQuotaErrorOccurred: vi.fn(),
+            getNoBrowser: vi.fn().mockReturnValue(false),
+            getUsageStatisticsEnabled: vi.fn().mockReturnValue(true),
+            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']),
+            }),
+            getGeminiClient: vi.fn(),
+            getModelRouterService: vi
+                .fn()
+                .mockReturnValue(mockRouterService),
+            getMessageBus: vi.fn().mockReturnValue(undefined),
+            getEnableHooks: vi.fn().mockReturnValue(false),
+            getChatCompression: vi.fn().mockReturnValue(undefined),
+            getCompressionThreshold: vi.fn().mockReturnValue(undefined),
+            getSkipNextSpeakerCheck: 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'),
+            },
+            getContentGenerator: vi.fn().mockReturnValue(mockContentGenerator),
+            getBaseLlmClient: vi.fn().mockReturnValue({
+                generateJson: vi.fn().mockResolvedValue({
+                    next_speaker: 'user',
+                    reasoning: 'test',
+                }),
+            }),
+            modelConfigService: {
+                getResolvedConfig(modelConfigKey) {
+                    return {
+                        model: modelConfigKey.model,
+                        generateContentConfig: {
+                            temperature: 0,
+                            topP: 1,
+                        },
+                    };
+                },
+            },
+            isInteractive: vi.fn().mockReturnValue(false),
+            getExperiments: () => { },
+            getActiveModel: vi.fn().mockReturnValue('test-model'),
+            setActiveModel: vi.fn(),
+            setModel: vi.fn(),
+            resetTurn: vi.fn(),
+            getModelAvailabilityService: vi
+                .fn()
+                .mockReturnValue(createAvailabilityServiceMock()),
+        };
+        mockConfig.getHookSystem = vi.fn().mockReturnValue(mockHookSystem);
+        client = new GeminiClient(mockConfig);
+        await client.initialize();
+        vi.mocked(mockConfig.getGeminiClient).mockReturnValue(client);
+        vi.mocked(uiTelemetryService.setLastPromptTokenCount).mockClear();
+    });
+    afterEach(() => {
+        client.dispose();
+        vi.restoreAllMocks();
+    });
+    describe('addHistory', () => {
+        it('should call chat.addHistory with the provided content', async () => {
+            const mockChat = {
+                addHistory: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            const newContent = {
+                role: 'user',
+                parts: [{ text: 'New history item' }],
+            };
+            await client.addHistory(newContent);
+            expect(mockChat.addHistory).toHaveBeenCalledWith(newContent);
+        });
+    });
+    describe('setHistory', () => {
+        it('should update telemetry token count when history is set', () => {
+            const history = [
+                { role: 'user', parts: [{ text: 'some message' }] },
+            ];
+            client.setHistory(history);
+            expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalled();
+        });
+    });
+    describe('resumeChat', () => {
+        it('should update telemetry token count when a chat is resumed', async () => {
+            const history = [
+                { role: 'user', parts: [{ text: 'resumed message' }] },
+            ];
+            await client.resumeChat(history);
+            expect(uiTelemetryService.setLastPromptTokenCount).toHaveBeenCalled();
+        });
+    });
+    describe('resetChat', () => {
+        it('should create a new chat session, clearing the old history', async () => {
+            // 1. Get the initial chat instance and add some history.
+            const initialChat = client.getChat();
+            const initialHistory = client.getHistory();
+            await client.addHistory({
+                role: 'user',
+                parts: [{ text: 'some old message' }],
+            });
+            const historyWithOldMessage = client.getHistory();
+            expect(historyWithOldMessage.length).toBeGreaterThan(initialHistory.length);
+            // 2. Call resetChat.
+            await client.resetChat();
+            // 3. Get the new chat instance and its history.
+            const newChat = client.getChat();
+            const newHistory = client.getHistory();
+            // 4. Assert that the chat instance is new and the history is reset.
+            expect(newChat).not.toBe(initialChat);
+            expect(newHistory.length).toBe(initialHistory.length);
+            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(() => {
+            vi.mock('./tokenLimits', () => ({
+                tokenLimit: vi.fn(),
+            }));
+            client['chat'] = {
+                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, newTokenCount = 500, compressionStatus = CompressionStatus.COMPRESSED, } = {}) {
+            const mockOriginalChat = {
+                getHistory: vi.fn((_curated) => chatHistory),
+                setHistory: vi.fn(),
+                getLastPromptTokenCount: vi.fn().mockReturnValue(originalTokenCount),
+                getChatRecordingService: vi.fn().mockReturnValue({
+                    getConversation: vi.fn().mockReturnValue(null),
+                    getConversationFilePath: vi.fn().mockReturnValue(null),
+                }),
+            };
+            client['chat'] = mockOriginalChat;
+            vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(originalTokenCount);
+            const newHistory = [
+                { role: 'user', parts: [{ text: 'Summary' }] },
+                { role: 'model', parts: [{ text: 'Got it' }] },
+            ];
+            vi.spyOn(ChatCompressionService.prototype, 'compress').mockResolvedValue({
+                newHistory: compressionStatus === CompressionStatus.COMPRESSED
+                    ? newHistory
+                    : null,
+                info: {
+                    originalTokenCount,
+                    newTokenCount,
+                    compressionStatus,
+                },
+            });
+            const mockNewChat = {
+                getHistory: vi.fn().mockReturnValue(newHistory),
+                setHistory: vi.fn(),
+                getLastPromptTokenCount: vi.fn().mockReturnValue(newTokenCount),
+            };
+            client['startChat'] = vi
+                .fn()
+                .mockResolvedValue(mockNewChat);
+            return {
+                client,
+                mockOriginalChat,
+                mockNewChat,
+                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 inflated tokens
+                setup({
+                    originalTokenCount: 100,
+                    newTokenCount: 200,
+                    compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
+                });
+                await client.tryCompressChat('prompt-id-4', false); // Fails
+                // Call 2 (Forced): Re-setup with compressed tokens
+                const { estimatedNewTokenCount: compressedTokenCount } = setup({
+                    originalTokenCount: 100,
+                    newTokenCount: 50,
+                    compressionStatus: CompressionStatus.COMPRESSED,
+                });
+                const result = await client.tryCompressChat('prompt-id-4', true); // Forced
+                expect(result).toEqual({
+                    compressionStatus: CompressionStatus.COMPRESSED,
+                    newTokenCount: compressedTokenCount,
+                    originalTokenCount: 100,
+                });
+            });
+            it('yields the result even if the compression inflated the tokens', async () => {
+                const { client, estimatedNewTokenCount } = setup({
+                    originalTokenCount: 100,
+                    newTokenCount: 200,
+                    compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
+                });
+                const result = await client.tryCompressChat('prompt-id-4', false);
+                expect(result).toEqual({
+                    compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
+                    newTokenCount: estimatedNewTokenCount,
+                    originalTokenCount: 100,
+                });
+                // IMPORTANT: The change in client.ts means setLastPromptTokenCount is NOT called on failure
+                expect(uiTelemetryService.setLastPromptTokenCount).not.toHaveBeenCalled();
+            });
+            it('does not manipulate the source chat', async () => {
+                const { client, mockOriginalChat } = setup({
+                    originalTokenCount: 100,
+                    newTokenCount: 200,
+                    compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
+                });
+                await client.tryCompressChat('prompt-id-4', false);
+                // On failure, the chat should NOT be replaced
+                expect(client['chat']).toBe(mockOriginalChat);
+            });
+            it.skip('will not attempt to compress context after a failure', async () => {
+                const { client } = setup({
+                    originalTokenCount: 100,
+                    newTokenCount: 200,
+                    compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
+                });
+                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);
+                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 correctly latch hasFailedCompressionAttempt flag', async () => {
+            // 1. Setup: Call setup() from this test file
+            // This helper function mocks the compression service for us.
+            const { client } = setup({
+                originalTokenCount: 100,
+                newTokenCount: 200, // Inflated
+                compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
+            });
+            // 2. Test Step 1: Trigger a non-forced failure
+            await client.tryCompressChat('prompt-1', false); // force = false
+            // 3. Assert Step 1: Check that the flag became true
+            // 3. Assert Step 1: Check that the flag became true
+            expect(client
+                .hasFailedCompressionAttempt).toBe(true);
+            // 4. Test Step 2: Trigger a forced failure
+            await client.tryCompressChat('prompt-2', true); // force = true
+            // 5. Assert Step 2: Check that the flag REMAINS true
+            // 5. Assert Step 2: Check that the flag REMAINS true
+            expect(client
+                .hasFailedCompressionAttempt).toBe(true);
+        });
+        it('should not trigger summarization if token count is below threshold', async () => {
+            const MOCKED_TOKEN_LIMIT = 1000;
+            const originalTokenCount = MOCKED_TOKEN_LIMIT * 0.699;
+            vi.spyOn(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(result).toEqual({
+                compressionStatus: CompressionStatus.NOOP,
+                newTokenCount: originalTokenCount,
+                originalTokenCount,
+            });
+            expect(newChat).toBe(initialChat);
+        });
+        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 result = await client.tryCompressChat('prompt-id-noop', false);
+            expect(result).toEqual({
+                compressionStatus: CompressionStatus.NOOP,
+                originalTokenCount: 50,
+                newTokenCount: 50,
+            });
+        });
+        it('should resume the session file when compression succeeds', async () => {
+            const { client, mockOriginalChat } = setup({
+                compressionStatus: CompressionStatus.COMPRESSED,
+            });
+            const mockConversation = { some: 'conversation' };
+            const mockFilePath = '/tmp/session.json';
+            // Override the mock to return values
+            const mockRecordingService = {
+                getConversation: vi.fn().mockReturnValue(mockConversation),
+                getConversationFilePath: vi.fn().mockReturnValue(mockFilePath),
+            };
+            vi.mocked(mockOriginalChat.getChatRecordingService).mockReturnValue(mockRecordingService);
+            await client.tryCompressChat('prompt-id', false);
+            expect(client['startChat']).toHaveBeenCalledWith(expect.anything(), // newHistory
+            {
+                conversation: mockConversation,
+                filePath: mockFilePath,
+            });
+        });
+    });
+    describe('sendMessageStream', () => {
+        it('emits a compression event when the context was automatically compressed', async () => {
+            // Arrange
+            mockTurnRunFn.mockReturnValue((async function* () {
+                yield { type: 'content', value: 'Hello' };
+            })());
+            const compressionInfo = {
+                compressionStatus: CompressionStatus.COMPRESSED,
+                originalTokenCount: 1000,
+                newTokenCount: 500,
+            };
+            vi.spyOn(client, 'tryCompressChat').mockResolvedValueOnce(compressionInfo);
+            // Act
+            const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-1');
+            const events = await fromAsync(stream);
+            // Assert
+            expect(events).toContainEqual({
+                type: LlmEventType.ChatCompressed,
+                originalTokens: compressionInfo.originalTokenCount,
+                compressedTokens: compressionInfo.newTokenCount,
+            });
+        });
+        it('does not emit ModelInfo event if signal is aborted', async () => {
+            // Arrange
+            mockTurnRunFn.mockReturnValue((async function* () {
+                yield { type: 'content', value: 'Hello' };
+            })());
+            const controller = new AbortController();
+            controller.abort();
+            // Act
+            const stream = client.sendMessageStream([{ text: 'Hi' }], controller.signal, 'prompt-id-1');
+            const events = await fromAsync(stream);
+            // Assert
+            expect(events).not.toContainEqual(expect.objectContaining({
+                type: LlmEventType.ModelInfo,
+            }));
+        });
+        it.each([
+            {
+                compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
+            },
+            { compressionStatus: CompressionStatus.NOOP },
+        ])('does not emit a compression event when the status is $compressionStatus', async ({ compressionStatus }) => {
+            // Arrange
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Hello' };
+            })();
+            mockTurnRunFn.mockReturnValue(mockStream);
+            const compressionInfo = {
+                compressionStatus,
+                originalTokenCount: 1000,
+                newTokenCount: 500,
+            };
+            vi.spyOn(client, 'tryCompressChat').mockResolvedValueOnce(compressionInfo);
+            // Act
+            const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-1');
+            const events = await fromAsync(stream);
+            // Assert
+            expect(events).not.toContainEqual(expect.objectContaining({
+                type: LlmEventType.ChatCompressed,
+            }));
+        });
+        it('should include editor context when ideMode is enabled', async () => {
+            // Arrange
+            vi.mocked(ideContextStore.get).mockReturnValue({
+                workspaceState: {
+                    openFiles: [
+                        {
+                            path: '/path/to/active/file.ts',
+                            timestamp: Date.now(),
+                            isActive: true,
+                            selectedText: 'hello',
+                            cursor: { line: 5, character: 10 },
+                        },
+                        {
+                            path: '/path/to/recent/file1.ts',
+                            timestamp: Date.now(),
+                        },
+                        {
+                            path: '/path/to/recent/file2.ts',
+                            timestamp: Date.now(),
+                        },
+                    ],
+                },
+            });
+            vi.mocked(mockConfig.getIdeMode).mockReturnValue(true);
+            vi.spyOn(client, 'tryCompressChat').mockResolvedValue({
+                originalTokenCount: 0,
+                newTokenCount: 0,
+                compressionStatus: CompressionStatus.COMPRESSED,
+            });
+            mockTurnRunFn.mockReturnValue((async function* () {
+                yield { type: 'content', value: 'Hello' };
+            })());
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            const initialRequest = [{ text: 'Hi' }];
+            // Act
+            const stream = client.sendMessageStream(initialRequest, new AbortController().signal, 'prompt-id-ide');
+            for await (const _ of stream) {
+                // consume stream
+            }
+            // Assert
+            expect(ideContextStore.get).toHaveBeenCalled();
+            const expectedContext = `
+Here is the user's editor context as a JSON object. This is for your information only.
+\`\`\`json
+${JSON.stringify({
+                activeFile: {
+                    path: '/path/to/active/file.ts',
+                    cursor: {
+                        line: 5,
+                        character: 10,
+                    },
+                    selectedText: 'hello',
+                },
+                otherOpenFiles: ['/path/to/recent/file1.ts', '/path/to/recent/file2.ts'],
+            }, null, 2)}
+\`\`\`
+      `.trim();
+            const expectedRequest = [{ text: expectedContext }];
+            expect(mockChat.addHistory).toHaveBeenCalledWith({
+                role: 'user',
+                parts: expectedRequest,
+            });
+        });
+        it('should not add context if ideMode is enabled but no open files', async () => {
+            // Arrange
+            vi.mocked(ideContextStore.get).mockReturnValue({
+                workspaceState: {
+                    openFiles: [],
+                },
+            });
+            vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Hello' };
+            })();
+            mockTurnRunFn.mockReturnValue(mockStream);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            const initialRequest = [{ text: 'Hi' }];
+            // Act
+            const stream = client.sendMessageStream(initialRequest, new AbortController().signal, 'prompt-id-ide');
+            for await (const _ of stream) {
+                // consume stream
+            }
+            // Assert
+            expect(ideContextStore.get).toHaveBeenCalled();
+            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
+            vi.mocked(ideContextStore.get).mockReturnValue({
+                workspaceState: {
+                    openFiles: [
+                        {
+                            path: '/path/to/active/file.ts',
+                            timestamp: Date.now(),
+                            isActive: true,
+                            selectedText: 'hello',
+                            cursor: { line: 5, character: 10 },
+                        },
+                    ],
+                },
+            });
+            vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+            vi.spyOn(client, 'tryCompressChat').mockResolvedValue({
+                originalTokenCount: 0,
+                newTokenCount: 0,
+                compressionStatus: CompressionStatus.COMPRESSED,
+            });
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Hello' };
+            })();
+            mockTurnRunFn.mockReturnValue(mockStream);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            const initialRequest = [{ text: 'Hi' }];
+            // Act
+            const stream = client.sendMessageStream(initialRequest, new AbortController().signal, 'prompt-id-ide');
+            for await (const _ of stream) {
+                // consume stream
+            }
+            // Assert
+            expect(ideContextStore.get).toHaveBeenCalled();
+            const expectedContext = `
+Here is the user's editor context as a JSON object. This is for your information only.
+\`\`\`json
+${JSON.stringify({
+                activeFile: {
+                    path: '/path/to/active/file.ts',
+                    cursor: {
+                        line: 5,
+                        character: 10,
+                    },
+                    selectedText: 'hello',
+                },
+            }, null, 2)}
+\`\`\`
+      `.trim();
+            const expectedRequest = [{ text: expectedContext }];
+            expect(mockChat.addHistory).toHaveBeenCalledWith({
+                role: 'user',
+                parts: expectedRequest,
+            });
+        });
+        it('should add context if ideMode is enabled and there are open files but no active file', async () => {
+            // Arrange
+            vi.mocked(ideContextStore.get).mockReturnValue({
+                workspaceState: {
+                    openFiles: [
+                        {
+                            path: '/path/to/recent/file1.ts',
+                            timestamp: Date.now(),
+                        },
+                        {
+                            path: '/path/to/recent/file2.ts',
+                            timestamp: Date.now(),
+                        },
+                    ],
+                },
+            });
+            vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+            vi.spyOn(client, 'tryCompressChat').mockResolvedValue({
+                originalTokenCount: 0,
+                newTokenCount: 0,
+                compressionStatus: CompressionStatus.COMPRESSED,
+            });
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Hello' };
+            })();
+            mockTurnRunFn.mockReturnValue(mockStream);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            const initialRequest = [{ text: 'Hi' }];
+            // Act
+            const stream = client.sendMessageStream(initialRequest, new AbortController().signal, 'prompt-id-ide');
+            for await (const _ of stream) {
+                // consume stream
+            }
+            // Assert
+            expect(ideContextStore.get).toHaveBeenCalled();
+            const expectedContext = `
+Here is the user's editor context as a JSON object. This is for your information only.
+\`\`\`json
+${JSON.stringify({
+                otherOpenFiles: ['/path/to/recent/file1.ts', '/path/to/recent/file2.ts'],
+            }, null, 2)}
+\`\`\`
+      `.trim();
+            const expectedRequest = [{ text: expectedContext }];
+            expect(mockChat.addHistory).toHaveBeenCalledWith({
+                role: 'user',
+                parts: expectedRequest,
+            });
+        });
+        it('should use local estimation for text-only requests and NOT call countTokens', async () => {
+            const request = [{ text: 'Hello world' }];
+            const generator = client['getContentGeneratorOrFail']();
+            const countTokensSpy = vi.spyOn(generator, 'countTokens');
+            const stream = client.sendMessageStream(request, new AbortController().signal, 'test-prompt-id');
+            await stream.next(); // Trigger the generator
+            expect(countTokensSpy).not.toHaveBeenCalled();
+        });
+        it('should use countTokens API for requests with non-text parts', async () => {
+            const request = [
+                { text: 'Describe this image' },
+                { inlineData: { mimeType: 'image/png', data: 'base64...' } },
+            ];
+            const generator = client['getContentGeneratorOrFail']();
+            const countTokensSpy = vi
+                .spyOn(generator, 'countTokens')
+                .mockResolvedValue({ totalTokens: 123 });
+            const stream = client.sendMessageStream(request, new AbortController().signal, 'test-prompt-id');
+            await stream.next(); // Trigger the generator
+            expect(countTokensSpy).toHaveBeenCalledWith(expect.objectContaining({
+                contents: expect.arrayContaining([
+                    expect.objectContaining({
+                        parts: expect.arrayContaining([
+                            { text: 'Describe this image' },
+                            { inlineData: { mimeType: 'image/png', data: 'base64...' } },
+                        ]),
+                    }),
+                ]),
+            }));
+        });
+        it('should estimate CJK characters more conservatively (closer to 1 token/char)', async () => {
+            const request = [{ text: '你好世界' }]; // 4 chars
+            const generator = client['getContentGeneratorOrFail']();
+            const countTokensSpy = vi.spyOn(generator, 'countTokens');
+            // 4 chars.
+            // Old logic: 4/4 = 1.
+            // New logic (heuristic): 4 * 1 = 4. (Or at least > 1).
+            // Let's assert it's roughly accurate.
+            const stream = client.sendMessageStream(request, new AbortController().signal, 'test-prompt-id');
+            await stream.next();
+            // Should NOT call countTokens (it's text only)
+            expect(countTokensSpy).not.toHaveBeenCalled();
+            // The actual token calculation is unit tested in tokenCalculation.test.ts
+        });
+        it('should return the turn instance after the stream is complete', async () => {
+            // Arrange
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Hello' };
+            })();
+            mockTurnRunFn.mockReturnValue(mockStream);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            // Act
+            const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-1');
+            // Consume the stream manually to get the final return value.
+            let finalResult;
+            while (true) {
+                const result = await stream.next();
+                if (result.done) {
+                    finalResult = result.value;
+                    break;
+                }
+            }
+            // Assert
+            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);
+            mockCheckNextSpeaker.mockResolvedValue({
+                next_speaker: 'model',
+                reasoning: 'Test case - always continue',
+            });
+            // Mock Turn to have no pending tool calls (which would allow nextSpeaker check)
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Continue...' };
+            })();
+            mockTurnRunFn.mockReturnValue(mockStream);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            // Use a signal that never gets aborted
+            const abortController = new AbortController();
+            const signal = abortController.signal;
+            // Act - Start the stream that should loop
+            const stream = client.sendMessageStream([{ text: 'Start conversation' }], signal, 'prompt-id-2');
+            // Count how many stream events we get
+            let eventCount = 0;
+            let finalResult;
+            // Consume the stream and count iterations
+            while (true) {
+                const result = await stream.next();
+                if (result.done) {
+                    finalResult = result.value;
+                    break;
+                }
+                eventCount++;
+                // Safety check to prevent actual infinite loop in test
+                if (eventCount > 200) {
+                    abortController.abort();
+                    throw new Error('Test exceeded expected event limit - possible actual infinite loop');
+                }
+            }
+            // Assert
+            expect(finalResult).toBeInstanceOf(Turn);
+            // 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 stream should produce events and eventually terminate
+            expect(eventCount).toBeGreaterThanOrEqual(1);
+            expect(eventCount).toBeLessThan(200); // Should not exceed our safety limit
+        });
+        it('should yield MaxSessionTurns and stop when session turn limit is reached', async () => {
+            // Arrange
+            const MAX_SESSION_TURNS = 5;
+            vi.spyOn(client['config'], 'getMaxSessionTurns').mockReturnValue(MAX_SESSION_TURNS);
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Hello' };
+            })();
+            mockTurnRunFn.mockReturnValue(mockStream);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            // Act & Assert
+            // Run up to the limit
+            for (let i = 0; i < MAX_SESSION_TURNS; i++) {
+                const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-4');
+                // consume stream
+                for await (const _event of stream) {
+                    // do nothing
+                }
+            }
+            // This call should exceed the limit
+            const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-5');
+            const events = [];
+            for await (const event of stream) {
+                events.push(event);
+            }
+            expect(events).toEqual([{ type: LlmEventType.MaxSessionTurns }]);
+            expect(mockTurnRunFn).toHaveBeenCalledTimes(MAX_SESSION_TURNS);
+        });
+        it('should respect MAX_TURNS limit even when turns parameter is set to a large value', async () => {
+            // This test verifies that the infinite loop protection works even when
+            // someone tries to bypass it by calling with a very large turns value
+            // Get the mocked checkNextSpeaker function and configure it to trigger infinite loop
+            const { checkNextSpeaker } = await import('../utils/nextSpeakerChecker.js');
+            const mockCheckNextSpeaker = vi.mocked(checkNextSpeaker);
+            mockCheckNextSpeaker.mockResolvedValue({
+                next_speaker: 'model',
+                reasoning: 'Test case - always continue',
+            });
+            // Mock Turn to have no pending tool calls (which would allow nextSpeaker check)
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Continue...' };
+            })();
+            mockTurnRunFn.mockReturnValue(mockStream);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            // Use a signal that never gets aborted
+            const abortController = new AbortController();
+            const signal = abortController.signal;
+            // Act - Start the stream with an extremely high turns value
+            // This simulates a case where the turns protection is bypassed
+            const stream = client.sendMessageStream([{ text: 'Start conversation' }], signal, 'prompt-id-3', Number.MAX_SAFE_INTEGER);
+            // Count how many stream events we get
+            let eventCount = 0;
+            const maxTestIterations = 1000; // Higher limit to show the loop continues
+            // Consume the stream and count iterations
+            try {
+                while (true) {
+                    const result = await stream.next();
+                    if (result.done) {
+                        break;
+                    }
+                    eventCount++;
+                    // This test should hit this limit, demonstrating the infinite loop
+                    if (eventCount > maxTestIterations) {
+                        abortController.abort();
+                        // This is the expected behavior - we hit the infinite loop
+                        break;
+                    }
+                }
+            }
+            catch (_) {
+                // If the test framework times out, that also demonstrates the infinite loop
+            }
+            // Assert that the fix works - the loop should stop at MAX_TURNS
+            const callCount = mockCheckNextSpeaker.mock.calls.length;
+            // With the fix: even when turns is set to a very high value,
+            // 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
+        });
+        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.
+            // We need a request > 100 tokens.
+            // A string of length 404 is roughly 101 tokens.
+            const longText = 'a'.repeat(404);
+            const request = [{ text: longText }];
+            // estimateTextOnlyLength counts only text content (400 chars), not JSON structure
+            const estimatedRequestTokenCount = Math.floor(longText.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: LlmEventType.ContextWindowOverflow,
+                currentTokens: estimatedRequestTokenCount,
+                maxTokens: 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.
+            // We need a request > 100 tokens.
+            const longText = 'a'.repeat(404);
+            const request = [{ text: longText }];
+            // estimateTextOnlyLength counts only text content (400 chars), not JSON structure
+            const estimatedRequestTokenCount = Math.floor(longText.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: LlmEventType.ContextWindowOverflow,
+                currentTokens: estimatedRequestTokenCount,
+                maxTokens: remainingTokenCount,
+            });
+            expect(tokenLimit).toHaveBeenCalledWith(STICKY_MODEL);
+            expect(mockTurnRunFn).not.toHaveBeenCalled();
+        });
+        it('should attempt compression before overflow check and proceed if compression frees space', async () => {
+            // Arrange
+            const MOCKED_TOKEN_LIMIT = 1000;
+            vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
+            // Initial state: 950 tokens used, 50 remaining.
+            const initialTokenCount = 950;
+            // Request: 60 tokens. (950 + 60 = 1010 > 1000) -> Would overflow without compression.
+            const longText = 'a'.repeat(240); // 240 / 4 = 60 tokens
+            const request = [{ text: longText }];
+            // Use the real GeminiChat to manage state and token counts more realistically
+            const mockChatCompressed = {
+                getLastPromptTokenCount: vi.fn().mockReturnValue(400),
+                getHistory: vi
+                    .fn()
+                    .mockReturnValue([{ role: 'user', parts: [{ text: 'old' }] }]),
+                addHistory: vi.fn(),
+                getChatRecordingService: vi.fn().mockReturnValue({
+                    getConversation: vi.fn(),
+                    getConversationFilePath: vi.fn(),
+                }),
+            };
+            const mockChatInitial = {
+                getLastPromptTokenCount: vi.fn().mockReturnValue(initialTokenCount),
+                getHistory: vi
+                    .fn()
+                    .mockReturnValue([{ role: 'user', parts: [{ text: 'old' }] }]),
+                addHistory: vi.fn(),
+                getChatRecordingService: vi.fn().mockReturnValue({
+                    getConversation: vi.fn(),
+                    getConversationFilePath: vi.fn(),
+                }),
+            };
+            client['chat'] = mockChatInitial;
+            // Mock tryCompressChat to simulate successful compression
+            const tryCompressSpy = vi
+                .spyOn(client, 'tryCompressChat')
+                .mockImplementation(async () => {
+                // In reality, tryCompressChat replaces this.chat
+                client['chat'] = mockChatCompressed;
+                return {
+                    originalTokenCount: initialTokenCount,
+                    newTokenCount: 400,
+                    compressionStatus: CompressionStatus.COMPRESSED,
+                };
+            });
+            // Use a manual spy on Turn.prototype.run since Turn is a real class in this test context
+            // but mocked at the top of the file
+            mockTurnRunFn.mockImplementation(async function* () {
+                yield { type: 'content', value: 'Success after compression' };
+            });
+            // Act
+            const stream = client.sendMessageStream(request, new AbortController().signal, 'prompt-id-compression-test');
+            const events = await fromAsync(stream);
+            // Assert
+            // 1. Should NOT contain overflow warning
+            expect(events).not.toContainEqual(expect.objectContaining({
+                type: LlmEventType.ContextWindowOverflow,
+            }));
+            // 2. Should contain compression event
+            expect(events).toContainEqual(expect.objectContaining({
+                type: LlmEventType.ChatCompressed,
+            }));
+            // 3. Should have called tryCompressChat
+            expect(tryCompressSpy).toHaveBeenCalled();
+            // 4. Should have called Turn.run (proceeded with the request)
+            expect(mockTurnRunFn).toHaveBeenCalled();
+        });
+        it('should handle massive function responses by truncating them and then yielding overflow warning', async () => {
+            // Arrange
+            const MOCKED_TOKEN_LIMIT = 1000;
+            vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
+            // History has a large compressible part and a massive function response at the end.
+            const massiveText = 'a'.repeat(200000);
+            const history = [
+                { role: 'user', parts: [{ text: 'a'.repeat(100000) }] }, // compressible part
+                { role: 'model', parts: [{ text: 'ok' }] },
+                {
+                    role: 'model',
+                    parts: [{ functionCall: { name: 'huge_tool', args: {} } }],
+                },
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            functionResponse: {
+                                name: 'huge_tool',
+                                response: { data: massiveText },
+                            },
+                        },
+                    ],
+                },
+            ];
+            const realChat = new GeminiChat(mockConfig, '', [], history);
+            client['chat'] = realChat;
+            // Use a realistic mock for compression that simulates the 40k truncation effect.
+            // We spy on the instance directly to ensure it intercepts correctly.
+            const compressSpy = vi
+                .spyOn(client['compressionService'], 'compress')
+                .mockResolvedValue({
+                newHistory: history, // Keep history large for the overflow check
+                info: {
+                    originalTokenCount: 50000,
+                    newTokenCount: 10000, // Reduced from 50k but still > 1000 limit
+                    compressionStatus: CompressionStatus.COMPRESSED,
+                },
+            });
+            // The new request
+            const request = [{ text: 'next question' }];
+            // Act
+            const stream = client.sendMessageStream(request, new AbortController().signal, 'prompt-id-massive-test');
+            const events = await fromAsync(stream);
+            // Assert
+            // 1. Should have attempted compression
+            expect(compressSpy).toHaveBeenCalled();
+            // 2. Should yield overflow warning because 10000 > 1000 limit.
+            expect(events).toContainEqual(expect.objectContaining({
+                type: LlmEventType.ContextWindowOverflow,
+                currentTokens: expect.any(Number),
+                maxTokens: expect.any(Number),
+            }));
+        });
+        it('should not trigger overflow warning for requests with large binary data (PDFs/images)', async () => {
+            // Arrange
+            const MOCKED_TOKEN_LIMIT = 1000000; // 1M tokens
+            vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
+            const lastPromptTokenCount = 10000;
+            const mockChat = {
+                getLastPromptTokenCount: vi.fn().mockReturnValue(lastPromptTokenCount),
+                getHistory: vi.fn().mockReturnValue([]),
+            };
+            client['chat'] = mockChat;
+            // Simulate a PDF file with large base64 data (11MB when encoded)
+            // In the old implementation, this would incorrectly estimate ~2.7M tokens
+            // In the new implementation, only the text part is counted
+            const largePdfBase64 = 'A'.repeat(11 * 1024 * 1024);
+            const request = [
+                { text: 'Please analyze this PDF document' }, // ~35 chars = ~8 tokens
+                {
+                    inlineData: {
+                        mimeType: 'application/pdf',
+                        data: largePdfBase64, // This should be ignored in token estimation
+                    },
+                },
+            ];
+            // Mock tryCompressChat to not compress
+            vi.spyOn(client, 'tryCompressChat').mockResolvedValue({
+                originalTokenCount: lastPromptTokenCount,
+                newTokenCount: lastPromptTokenCount,
+                compressionStatus: CompressionStatus.NOOP,
+            });
+            // Mock Turn.run to simulate successful processing
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Analysis complete' };
+            })();
+            mockTurnRunFn.mockReturnValue(mockStream);
+            // Act
+            const stream = client.sendMessageStream(request, new AbortController().signal, 'prompt-id-pdf-test');
+            const events = await fromAsync(stream);
+            // Assert
+            // Should NOT contain overflow warning
+            expect(events).not.toContainEqual(expect.objectContaining({
+                type: LlmEventType.ContextWindowOverflow,
+            }));
+            // Turn.run should be called (processing should continue)
+            expect(mockTurnRunFn).toHaveBeenCalled();
+        });
+        describe('Model Routing', () => {
+            let mockRouterService;
+            beforeEach(() => {
+                mockRouterService = {
+                    route: vi
+                        .fn()
+                        .mockResolvedValue({ model: 'routed-model', reason: 'test' }),
+                };
+                vi.mocked(mockConfig.getModelRouterService).mockReturnValue(mockRouterService);
+                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({ 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({ 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({ 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({ model: 'routed-model' }, [{ text: 'Hi' }], expect.any(AbortSignal));
+                // New prompt
+                mockRouterService.route.mockResolvedValue({
+                    model: 'new-routed-model',
+                    reason: 'test',
+                });
+                stream = client.sendMessageStream([{ text: 'A new topic' }], new AbortController().signal, 'prompt-2');
+                await fromAsync(stream);
+                // Router should be called again for the new prompt
+                expect(mockRouterService.route).toHaveBeenCalledTimes(2);
+                // Should use the newly routed model
+                expect(mockTurnRunFn).toHaveBeenCalledWith({ model: 'new-routed-model' }, [{ text: 'A new topic' }], expect.any(AbortSignal));
+            });
+            it('should re-route within the same prompt when the configured model changes', async () => {
+                mockTurnRunFn.mockClear();
+                mockTurnRunFn.mockImplementation(async function* () {
+                    yield { type: 'content', value: 'Hello' };
+                });
+                mockRouterService.route.mockResolvedValueOnce({
+                    model: 'original-model',
+                    reason: 'test',
+                });
+                let stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-1');
+                await fromAsync(stream);
+                expect(mockRouterService.route).toHaveBeenCalledTimes(1);
+                expect(mockTurnRunFn).toHaveBeenNthCalledWith(1, { model: 'original-model' }, [{ text: 'Hi' }], expect.any(AbortSignal));
+                mockRouterService.route.mockResolvedValue({
+                    model: 'fallback-model',
+                    reason: 'test',
+                });
+                vi.mocked(mockConfig.getModel).mockReturnValue('gemini-2.5-flash');
+                coreEvents.emitModelChanged('gemini-2.5-flash');
+                stream = client.sendMessageStream([{ text: 'Continue' }], new AbortController().signal, 'prompt-1');
+                await fromAsync(stream);
+                expect(mockRouterService.route).toHaveBeenCalledTimes(2);
+                expect(mockTurnRunFn).toHaveBeenNthCalledWith(2, { model: 'fallback-model' }, [{ text: 'Continue' }], expect.any(AbortSignal));
+            });
+        });
+        it('should use getGlobalMemory for system instruction when JIT is enabled', async () => {
+            vi.mocked(mockConfig.isJitContextEnabled).mockReturnValue(true);
+            vi.mocked(mockConfig.getGlobalMemory).mockReturnValue('Global JIT Memory');
+            vi.mocked(mockConfig.getUserMemory).mockReturnValue('Full JIT Memory');
+            const { getCoreSystemPrompt } = await import('./prompts.js');
+            const mockGetCoreSystemPrompt = vi.mocked(getCoreSystemPrompt);
+            client.updateSystemInstruction();
+            expect(mockGetCoreSystemPrompt).toHaveBeenCalledWith(mockConfig, 'Global JIT Memory');
+        });
+        it('should use getUserMemory for system instruction when JIT is disabled', async () => {
+            vi.mocked(mockConfig.isJitContextEnabled).mockReturnValue(false);
+            vi.mocked(mockConfig.getUserMemory).mockReturnValue('Legacy Memory');
+            const { getCoreSystemPrompt } = await import('./prompts.js');
+            const mockGetCoreSystemPrompt = vi.mocked(getCoreSystemPrompt);
+            client.updateSystemInstruction();
+            expect(mockGetCoreSystemPrompt).toHaveBeenCalledWith(mockConfig, 'Legacy Memory');
+        });
+        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: LlmEventType.InvalidStream };
+            })();
+            const mockStream2 = (async function* () {
+                yield { type: LlmEventType.TextDelta, text: '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: LlmEventType.ModelInfo, modelName: 'default-routed-model' },
+                { type: LlmEventType.InvalidStream },
+                { type: LlmEventType.TextDelta, text: '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: LlmEventType.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: LlmEventType.ModelInfo, modelName: 'default-routed-model' },
+                { type: LlmEventType.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: LlmEventType.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 === LlmEventType.ModelInfo)
+                .map((e) => e.modelName)).toEqual(['default-routed-model']);
+            // Verify that turn.run was called twice
+            expect(mockTurnRunFn).toHaveBeenCalledTimes(2);
+        });
+        describe('Editor context delta', () => {
+            const mockStream = (async function* () {
+                yield { type: 'content', value: 'Hello' };
+            })();
+            beforeEach(() => {
+                client['forceFullIdeContext'] = false; // Reset before each delta test
+                vi.spyOn(client, 'tryCompressChat').mockResolvedValue({
+                    originalTokenCount: 0,
+                    newTokenCount: 0,
+                    compressionStatus: CompressionStatus.COMPRESSED,
+                });
+                vi.spyOn(client['config'], 'getIdeMode').mockReturnValue(true);
+                mockTurnRunFn.mockReturnValue(mockStream);
+                const mockChat = {
+                    addHistory: vi.fn(),
+                    setHistory: vi.fn(),
+                    // Assume history is not empty for delta checks
+                    getHistory: vi
+                        .fn()
+                        .mockReturnValue([
+                        { role: 'user', parts: [{ text: 'previous message' }] },
+                    ]),
+                    getLastPromptTokenCount: vi.fn(),
+                };
+                client['chat'] = mockChat;
+            });
+            const testCases = [
+                {
+                    description: 'sends delta when active file changes',
+                    previousActiveFile: {
+                        path: '/path/to/old/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    shouldSendContext: true,
+                },
+                {
+                    description: 'sends delta when cursor line changes',
+                    previousActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 1, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    shouldSendContext: true,
+                },
+                {
+                    description: 'sends delta when cursor character changes',
+                    previousActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 1 },
+                        selectedText: 'hello',
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    shouldSendContext: true,
+                },
+                {
+                    description: 'sends delta when selected text changes',
+                    previousActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'world',
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    shouldSendContext: true,
+                },
+                {
+                    description: 'sends delta when selected text is added',
+                    previousActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    shouldSendContext: true,
+                },
+                {
+                    description: 'sends delta when selected text is removed',
+                    previousActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                    },
+                    shouldSendContext: true,
+                },
+                {
+                    description: 'does not send context when nothing changes',
+                    previousActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    currentActiveFile: {
+                        path: '/path/to/active/file.ts',
+                        cursor: { line: 5, character: 10 },
+                        selectedText: 'hello',
+                    },
+                    shouldSendContext: false,
+                },
+            ];
+            it.each(testCases)('$description', async ({ previousActiveFile, currentActiveFile, shouldSendContext, }) => {
+                // Setup previous context
+                client['lastSentIdeContext'] = {
+                    workspaceState: {
+                        openFiles: [
+                            {
+                                path: previousActiveFile.path,
+                                cursor: previousActiveFile.cursor,
+                                selectedText: previousActiveFile.selectedText,
+                                isActive: true,
+                                timestamp: Date.now() - 1000,
+                            },
+                        ],
+                    },
+                };
+                // Setup current context
+                vi.mocked(ideContextStore.get).mockReturnValue({
+                    workspaceState: {
+                        openFiles: [
+                            {
+                                ...currentActiveFile,
+                                isActive: true,
+                                timestamp: Date.now(),
+                            },
+                        ],
+                    },
+                });
+                const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-delta');
+                for await (const _ of stream) {
+                    // consume stream
+                }
+                const mockChat = client['chat'];
+                if (shouldSendContext) {
+                    expect(mockChat.addHistory).toHaveBeenCalledWith(expect.objectContaining({
+                        parts: expect.arrayContaining([
+                            expect.objectContaining({
+                                text: expect.stringContaining("Here is a summary of changes in the user's editor context"),
+                            }),
+                        ]),
+                    }));
+                }
+                else {
+                    expect(mockChat.addHistory).not.toHaveBeenCalled();
+                }
+            });
+            it('sends full context when history is cleared, even if editor state is unchanged', async () => {
+                const activeFile = {
+                    path: '/path/to/active/file.ts',
+                    cursor: { line: 5, character: 10 },
+                    selectedText: 'hello',
+                };
+                // Setup previous context
+                client['lastSentIdeContext'] = {
+                    workspaceState: {
+                        openFiles: [
+                            {
+                                path: activeFile.path,
+                                cursor: activeFile.cursor,
+                                selectedText: activeFile.selectedText,
+                                isActive: true,
+                                timestamp: Date.now() - 1000,
+                            },
+                        ],
+                    },
+                };
+                // Setup current context (same as previous)
+                vi.mocked(ideContextStore.get).mockReturnValue({
+                    workspaceState: {
+                        openFiles: [
+                            { ...activeFile, isActive: true, timestamp: Date.now() },
+                        ],
+                    },
+                });
+                // Make history empty
+                const mockChat = client['chat'];
+                mockChat.getHistory.mockReturnValue([]);
+                const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-history-cleared');
+                for await (const _ of stream) {
+                    // consume stream
+                }
+                expect(mockChat.addHistory).toHaveBeenCalledWith(expect.objectContaining({
+                    parts: expect.arrayContaining([
+                        expect.objectContaining({
+                            text: expect.stringContaining("Here is the user's editor context"),
+                        }),
+                    ]),
+                }));
+                // Also verify it's the full context, not a delta.
+                const call = mockChat.addHistory.mock.calls[0][0];
+                const contextText = call.parts[0].text;
+                const contextJson = JSON.parse(contextText.match(/```json\n(.*)\n```/s)[1]);
+                expect(contextJson).toHaveProperty('activeFile');
+                expect(contextJson.activeFile.path).toBe('/path/to/active/file.ts');
+            });
+        });
+        describe('Availability Service Integration', () => {
+            let mockAvailabilityService;
+            beforeEach(() => {
+                mockAvailabilityService = createAvailabilityServiceMock();
+                vi.mocked(mockConfig.getModelAvailabilityService).mockReturnValue(mockAvailabilityService);
+                vi.mocked(mockConfig.setActiveModel).mockClear();
+                mockRouterService.route.mockResolvedValue({
+                    model: 'model-a',
+                    reason: 'test',
+                });
+                vi.mocked(mockConfig.getModelRouterService).mockReturnValue(mockRouterService);
+                vi.spyOn(policyCatalog, 'getModelPolicyChain').mockReturnValue([
+                    {
+                        model: 'model-a',
+                        isLastResort: false,
+                        actions: {},
+                        stateTransitions: {},
+                    },
+                    {
+                        model: 'model-b',
+                        isLastResort: true,
+                        actions: {},
+                        stateTransitions: {},
+                    },
+                ]);
+                mockTurnRunFn.mockReturnValue((async function* () {
+                    yield { type: 'content', value: 'Hello' };
+                })());
+            });
+            it('should select first available model, set active, and not consume sticky attempt (done lower in chain)', async () => {
+                vi.mocked(mockAvailabilityService.selectFirstAvailable).mockReturnValue({
+                    selectedModel: 'model-a',
+                    attempts: 1,
+                    skipped: [],
+                });
+                vi.mocked(mockConfig.getModel).mockReturnValue(DEFAULT_GEMINI_MODEL_AUTO);
+                const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-avail');
+                await fromAsync(stream);
+                expect(mockAvailabilityService.selectFirstAvailable).toHaveBeenCalledWith(['model-a', 'model-b']);
+                expect(mockConfig.setActiveModel).toHaveBeenCalledWith('model-a');
+                expect(mockAvailabilityService.consumeStickyAttempt).not.toHaveBeenCalled();
+                // Ensure turn.run used the selected model
+                expect(mockTurnRunFn).toHaveBeenCalledWith(expect.objectContaining({ model: 'model-a' }), expect.anything(), expect.anything());
+            });
+            it('should default to last resort model if selection returns null', async () => {
+                vi.mocked(mockAvailabilityService.selectFirstAvailable).mockReturnValue({
+                    selectedModel: null,
+                    skipped: [],
+                });
+                vi.mocked(mockConfig.getModel).mockReturnValue(DEFAULT_GEMINI_MODEL_AUTO);
+                const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-avail-fallback');
+                await fromAsync(stream);
+                expect(mockConfig.setActiveModel).toHaveBeenCalledWith('model-b'); // Last resort
+                expect(mockAvailabilityService.consumeStickyAttempt).not.toHaveBeenCalled();
+            });
+            it('should reset turn on new message stream', async () => {
+                vi.mocked(mockAvailabilityService.selectFirstAvailable).mockReturnValue({
+                    selectedModel: 'model-a',
+                    skipped: [],
+                });
+                const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-reset');
+                await fromAsync(stream);
+                expect(mockConfig.resetTurn).toHaveBeenCalled();
+            });
+            it('should NOT reset turn on invalid stream retry', async () => {
+                vi.mocked(mockAvailabilityService.selectFirstAvailable).mockReturnValue({
+                    selectedModel: 'model-a',
+                    skipped: [],
+                });
+                // We simulate a retry by calling sendMessageStream with isInvalidStreamRetry=true
+                // But the public API doesn't expose that argument directly unless we use the private method or simulate the recursion.
+                // We can simulate recursion by mocking turn run to return invalid stream once.
+                vi.spyOn(client['config'], 'getContinueOnFailedApiCall').mockReturnValue(true);
+                const mockStream1 = (async function* () {
+                    yield { type: LlmEventType.InvalidStream };
+                })();
+                const mockStream2 = (async function* () {
+                    yield { type: 'content', value: 'ok' };
+                })();
+                mockTurnRunFn
+                    .mockReturnValueOnce(mockStream1)
+                    .mockReturnValueOnce(mockStream2);
+                const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-retry');
+                await fromAsync(stream);
+                // resetTurn should be called once (for the initial call) but NOT for the recursive call
+                expect(mockConfig.resetTurn).toHaveBeenCalledTimes(1);
+            });
+        });
+        describe('IDE context with pending tool calls', () => {
+            let mockChat;
+            beforeEach(() => {
+                vi.spyOn(client, 'tryCompressChat').mockResolvedValue({
+                    originalTokenCount: 0,
+                    newTokenCount: 0,
+                    compressionStatus: CompressionStatus.COMPRESSED,
+                });
+                const mockStream = (async function* () {
+                    yield { type: 'content', value: 'response' };
+                })();
+                mockTurnRunFn.mockReturnValue(mockStream);
+                mockChat = {
+                    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);
+                vi.mocked(ideContextStore.get).mockReturnValue({
+                    workspaceState: {
+                        openFiles: [{ path: '/path/to/file.ts', timestamp: Date.now() }],
+                    },
+                });
+            });
+            it('should NOT add IDE context when a tool call is pending', async () => {
+                // Arrange: History ends with a functionCall from the model
+                const historyWithPendingCall = [
+                    { role: 'user', parts: [{ text: 'Please use a tool.' }] },
+                    {
+                        role: 'model',
+                        parts: [{ functionCall: { name: 'some_tool', args: {} } }],
+                    },
+                ];
+                vi.mocked(mockChat.getHistory).mockReturnValue(historyWithPendingCall);
+                // Act: Simulate sending the tool's response back
+                const stream = client.sendMessageStream([
+                    {
+                        functionResponse: {
+                            name: 'some_tool',
+                            response: { success: true },
+                        },
+                    },
+                ], new AbortController().signal, 'prompt-id-tool-response');
+                for await (const _ of stream) {
+                    // consume stream to complete the call
+                }
+                // Assert: The IDE context message should NOT have been added to the history.
+                expect(mockChat.addHistory).not.toHaveBeenCalledWith(expect.objectContaining({
+                    parts: expect.arrayContaining([
+                        expect.objectContaining({
+                            text: expect.stringContaining("user's editor context"),
+                        }),
+                    ]),
+                }));
+            });
+            it('should add IDE context when no tool call is pending', async () => {
+                // Arrange: History is normal, no pending calls
+                const normalHistory = [
+                    { role: 'user', parts: [{ text: 'A normal message.' }] },
+                    { role: 'model', parts: [{ text: 'A normal response.' }] },
+                ];
+                vi.mocked(mockChat.getHistory).mockReturnValue(normalHistory);
+                // Act
+                const stream = client.sendMessageStream([{ text: 'Another normal message' }], new AbortController().signal, 'prompt-id-normal');
+                for await (const _ of stream) {
+                    // consume stream
+                }
+                // Assert: The IDE context message SHOULD have been added.
+                expect(mockChat.addHistory).toHaveBeenCalledWith(expect.objectContaining({
+                    role: 'user',
+                    parts: expect.arrayContaining([
+                        expect.objectContaining({
+                            text: expect.stringContaining("user's editor context"),
+                        }),
+                    ]),
+                }));
+            });
+            it('should send the latest IDE context on the next message after a skipped context', async () => {
+                // --- Step 1: A tool call is pending, context should be skipped ---
+                // Arrange: History ends with a functionCall
+                const historyWithPendingCall = [
+                    { role: 'user', parts: [{ text: 'Please use a tool.' }] },
+                    {
+                        role: 'model',
+                        parts: [{ functionCall: { name: 'some_tool', args: {} } }],
+                    },
+                ];
+                vi.mocked(mockChat.getHistory).mockReturnValue(historyWithPendingCall);
+                // Arrange: Set the initial IDE context
+                const initialIdeContext = {
+                    workspaceState: {
+                        openFiles: [{ path: '/path/to/fileA.ts', timestamp: Date.now() }],
+                    },
+                };
+                vi.mocked(ideContextStore.get).mockReturnValue(initialIdeContext);
+                // Act: Send the tool response
+                let stream = client.sendMessageStream([
+                    {
+                        functionResponse: {
+                            name: 'some_tool',
+                            response: { success: true },
+                        },
+                    },
+                ], new AbortController().signal, 'prompt-id-tool-response');
+                for await (const _ of stream) {
+                    /* consume */
+                }
+                // Assert: The initial context was NOT sent
+                expect(mockChat.addHistory).not.toHaveBeenCalledWith(expect.objectContaining({
+                    parts: expect.arrayContaining([
+                        expect.objectContaining({
+                            text: expect.stringContaining("user's editor context"),
+                        }),
+                    ]),
+                }));
+                // --- Step 2: A new message is sent, latest context should be included ---
+                // Arrange: The model has responded to the tool, and the user is sending a new message.
+                const historyAfterToolResponse = [
+                    ...historyWithPendingCall,
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    name: 'some_tool',
+                                    response: { success: true },
+                                },
+                            },
+                        ],
+                    },
+                    { role: 'model', parts: [{ text: 'The tool ran successfully.' }] },
+                ];
+                vi.mocked(mockChat.getHistory).mockReturnValue(historyAfterToolResponse);
+                vi.mocked(mockChat.addHistory).mockClear(); // Clear previous calls for the next assertion
+                // Arrange: The IDE context has now changed
+                const newIdeContext = {
+                    workspaceState: {
+                        openFiles: [{ path: '/path/to/fileB.ts', timestamp: Date.now() }],
+                    },
+                };
+                vi.mocked(ideContextStore.get).mockReturnValue(newIdeContext);
+                // Act: Send a new, regular user message
+                stream = client.sendMessageStream([{ text: 'Thanks!' }], new AbortController().signal, 'prompt-id-final');
+                for await (const _ of stream) {
+                    /* consume */
+                }
+                // Assert: The NEW context was sent as a FULL context because there was no previously sent context.
+                const addHistoryCalls = vi.mocked(mockChat.addHistory).mock.calls;
+                const contextCall = addHistoryCalls.find((call) => JSON.stringify(call[0]).includes("user's editor context"));
+                expect(contextCall).toBeDefined();
+                expect(JSON.stringify(contextCall[0])).toContain("Here is the user's editor context as a JSON object");
+                // Check that the sent context is the new one (fileB.ts)
+                expect(JSON.stringify(contextCall[0])).toContain('fileB.ts');
+                // Check that the sent context is NOT the old one (fileA.ts)
+                expect(JSON.stringify(contextCall[0])).not.toContain('fileA.ts');
+            });
+            it('should send a context DELTA on the next message after a skipped context', async () => {
+                // --- Step 0: Establish an initial context ---
+                vi.mocked(mockChat.getHistory).mockReturnValue([]); // Start with empty history
+                const contextA = {
+                    workspaceState: {
+                        openFiles: [
+                            {
+                                path: '/path/to/fileA.ts',
+                                isActive: true,
+                                timestamp: Date.now(),
+                            },
+                        ],
+                    },
+                };
+                vi.mocked(ideContextStore.get).mockReturnValue(contextA);
+                // Act: Send a regular message to establish the initial context
+                let stream = client.sendMessageStream([{ text: 'Initial message' }], new AbortController().signal, 'prompt-id-initial');
+                for await (const _ of stream) {
+                    /* consume */
+                }
+                // Assert: Full context for fileA.ts was sent and stored.
+                const initialCall = vi.mocked(mockChat.addHistory).mock.calls[0][0];
+                expect(JSON.stringify(initialCall)).toContain("user's editor context as a JSON object");
+                expect(JSON.stringify(initialCall)).toContain('fileA.ts');
+                // This implicitly tests that `lastSentIdeContext` is now set internally by the client.
+                vi.mocked(mockChat.addHistory).mockClear();
+                // --- Step 1: A tool call is pending, context should be skipped ---
+                const historyWithPendingCall = [
+                    { role: 'user', parts: [{ text: 'Please use a tool.' }] },
+                    {
+                        role: 'model',
+                        parts: [{ functionCall: { name: 'some_tool', args: {} } }],
+                    },
+                ];
+                vi.mocked(mockChat.getHistory).mockReturnValue(historyWithPendingCall);
+                // Arrange: IDE context changes, but this should be skipped
+                const contextB = {
+                    workspaceState: {
+                        openFiles: [
+                            {
+                                path: '/path/to/fileB.ts',
+                                isActive: true,
+                                timestamp: Date.now(),
+                            },
+                        ],
+                    },
+                };
+                vi.mocked(ideContextStore.get).mockReturnValue(contextB);
+                // Act: Send the tool response
+                stream = client.sendMessageStream([
+                    {
+                        functionResponse: {
+                            name: 'some_tool',
+                            response: { success: true },
+                        },
+                    },
+                ], new AbortController().signal, 'prompt-id-tool-response');
+                for await (const _ of stream) {
+                    /* consume */
+                }
+                // Assert: No context was sent
+                expect(mockChat.addHistory).not.toHaveBeenCalled();
+                // --- Step 2: A new message is sent, latest context DELTA should be included ---
+                const historyAfterToolResponse = [
+                    ...historyWithPendingCall,
+                    {
+                        role: 'user',
+                        parts: [
+                            {
+                                functionResponse: {
+                                    name: 'some_tool',
+                                    response: { success: true },
+                                },
+                            },
+                        ],
+                    },
+                    { role: 'model', parts: [{ text: 'The tool ran successfully.' }] },
+                ];
+                vi.mocked(mockChat.getHistory).mockReturnValue(historyAfterToolResponse);
+                // Arrange: The IDE context has changed again
+                const contextC = {
+                    workspaceState: {
+                        openFiles: [
+                            // fileA is now closed, fileC is open
+                            {
+                                path: '/path/to/fileC.ts',
+                                isActive: true,
+                                timestamp: Date.now(),
+                            },
+                        ],
+                    },
+                };
+                vi.mocked(ideContextStore.get).mockReturnValue(contextC);
+                // Act: Send a new, regular user message
+                stream = client.sendMessageStream([{ text: 'Thanks!' }], new AbortController().signal, 'prompt-id-final');
+                for await (const _ of stream) {
+                    /* consume */
+                }
+                // Assert: The DELTA context was sent
+                const finalCall = vi.mocked(mockChat.addHistory).mock.calls[0][0];
+                expect(JSON.stringify(finalCall)).toContain('summary of changes');
+                // The delta should reflect fileA being closed and fileC being opened.
+                expect(JSON.stringify(finalCall)).toContain('filesClosed');
+                expect(JSON.stringify(finalCall)).toContain('fileA.ts');
+                expect(JSON.stringify(finalCall)).toContain('activeFileChanged');
+                expect(JSON.stringify(finalCall)).toContain('fileC.ts');
+            });
+        });
+        it('should not call checkNextSpeaker when turn.run() yields an error', async () => {
+            // Arrange
+            const { checkNextSpeaker } = await import('../utils/nextSpeakerChecker.js');
+            const mockCheckNextSpeaker = vi.mocked(checkNextSpeaker);
+            const mockStream = (async function* () {
+                yield {
+                    type: LlmEventType.Error,
+                    error: 'test error',
+                };
+            })();
+            mockTurnRunFn.mockReturnValue(mockStream);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            // Act
+            const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-error');
+            for await (const _ of stream) {
+                // consume stream
+            }
+            // Assert
+            expect(mockCheckNextSpeaker).not.toHaveBeenCalled();
+        });
+        it('should not call checkNextSpeaker when turn.run() yields a value then an error', async () => {
+            // Arrange
+            const { checkNextSpeaker } = await import('../utils/nextSpeakerChecker.js');
+            const mockCheckNextSpeaker = vi.mocked(checkNextSpeaker);
+            const mockStream = (async function* () {
+                yield { type: LlmEventType.TextDelta, text: 'some content' };
+                yield {
+                    type: LlmEventType.Error,
+                    error: 'test error',
+                };
+            })();
+            mockTurnRunFn.mockReturnValue(mockStream);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            // Act
+            const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-error');
+            for await (const _ of stream) {
+                // consume stream
+            }
+            // Assert
+            expect(mockCheckNextSpeaker).not.toHaveBeenCalled();
+        });
+        it('should abort linked signal when loop is detected', async () => {
+            // Arrange
+            vi.spyOn(client['loopDetector'], 'turnStarted').mockResolvedValue(false);
+            vi.spyOn(client['loopDetector'], 'addAndCheck')
+                .mockReturnValueOnce(false)
+                .mockReturnValueOnce(true);
+            let capturedSignal;
+            mockTurnRunFn.mockImplementation((_modelConfigKey, _request, signal) => {
+                capturedSignal = signal;
+                return (async function* () {
+                    yield { type: LlmEventType.TextDelta, text: 'First event' };
+                    yield { type: LlmEventType.TextDelta, text: 'Second event' };
+                })();
+            });
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn(),
+            };
+            client['chat'] = mockChat;
+            // Act
+            const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-id-loop');
+            const events = [];
+            for await (const event of stream) {
+                events.push(event);
+            }
+            // Assert
+            expect(events).toContainEqual({ type: LlmEventType.LoopDetected });
+            expect(capturedSignal.aborted).toBe(true);
+        });
+    });
+    describe('generateContent', () => {
+        it('should call generateContent with the correct parameters', async () => {
+            const contents = [{ role: 'user', parts: [{ text: 'hello' }] }];
+            const abortSignal = new AbortController().signal;
+            await client.generateContent({ model: 'test-model' }, contents, abortSignal);
+            expect(mockContentGenerator.generateContent).toHaveBeenCalledWith({
+                model: 'test-model',
+                config: {
+                    abortSignal,
+                    systemInstruction: getCoreSystemPrompt({}, ''),
+                    temperature: 0,
+                    topP: 1,
+                },
+                contents,
+            }, 'test-session-id');
+        });
+        it('should use current model from config for content generation', async () => {
+            const initialModel = 'test-model';
+            const contents = [{ role: 'user', parts: [{ text: 'test' }] }];
+            await client.generateContent({ model: initialModel }, contents, new AbortController().signal);
+            expect(mockContentGenerator.generateContent).toHaveBeenCalledWith(expect.objectContaining({
+                model: initialModel,
+            }), 'test-session-id');
+        });
+        describe('Hook System', () => {
+            let mockMessageBus;
+            beforeEach(() => {
+                vi.clearAllMocks();
+                mockMessageBus = { publish: vi.fn(), subscribe: vi.fn() };
+                // Force override config methods on the client instance
+                client['config'].getEnableHooks = vi.fn().mockReturnValue(true);
+                client['config'].getMessageBus = vi
+                    .fn()
+                    .mockReturnValue(mockMessageBus);
+            });
+            it('should fire BeforeAgent and AfterAgent exactly once for a simple turn', async () => {
+                const promptId = 'test-prompt-hook-1';
+                const request = { text: 'Hello Hooks' };
+                const signal = new AbortController().signal;
+                mockTurnRunFn.mockImplementation(async function* () {
+                    this.getResponseText.mockReturnValue('Hook Response');
+                    yield { type: LlmEventType.TextDelta, text: 'Hook Response' };
+                });
+                const stream = client.sendMessageStream(request, signal, promptId);
+                while (!(await stream.next()).done)
+                    ;
+                expect(mockHookSystem.fireBeforeAgentEvent).toHaveBeenCalledTimes(1);
+                expect(mockHookSystem.fireAfterAgentEvent).toHaveBeenCalledTimes(1);
+                expect(mockHookSystem.fireAfterAgentEvent).toHaveBeenCalledWith(partToString(request), 'Hook Response');
+                // Map should be empty
+                expect(client['hookStateMap'].size).toBe(0);
+            });
+            it('should fire BeforeAgent once and AfterAgent once even with recursion', async () => {
+                const { checkNextSpeaker } = await import('../utils/nextSpeakerChecker.js');
+                vi.mocked(checkNextSpeaker)
+                    .mockResolvedValueOnce({ next_speaker: 'model', reasoning: 'more' })
+                    .mockResolvedValueOnce(null);
+                const promptId = 'test-prompt-hook-recursive';
+                const request = { text: 'Recursion Test' };
+                const signal = new AbortController().signal;
+                let callCount = 0;
+                mockTurnRunFn.mockImplementation(async function* () {
+                    callCount++;
+                    const response = `Response ${callCount}`;
+                    this.getResponseText.mockReturnValue(response);
+                    yield { type: LlmEventType.TextDelta, text: response };
+                });
+                const stream = client.sendMessageStream(request, signal, promptId);
+                while (!(await stream.next()).done)
+                    ;
+                // BeforeAgent should fire ONLY once despite multiple internal turns
+                expect(mockHookSystem.fireBeforeAgentEvent).toHaveBeenCalledTimes(1);
+                // AfterAgent should fire ONLY when the stack unwinds
+                expect(mockHookSystem.fireAfterAgentEvent).toHaveBeenCalledTimes(1);
+                // Check cumulative response (separated by newline)
+                expect(mockHookSystem.fireAfterAgentEvent).toHaveBeenCalledWith(partToString(request), 'Response 1\nResponse 2');
+                expect(client['hookStateMap'].size).toBe(0);
+            });
+            it('should use original request in AfterAgent hook even when continuation happened', async () => {
+                const { checkNextSpeaker } = await import('../utils/nextSpeakerChecker.js');
+                vi.mocked(checkNextSpeaker)
+                    .mockResolvedValueOnce({ next_speaker: 'model', reasoning: 'more' })
+                    .mockResolvedValueOnce(null);
+                const promptId = 'test-prompt-hook-original-req';
+                const request = { text: 'Do something' };
+                const signal = new AbortController().signal;
+                mockTurnRunFn.mockImplementation(async function* () {
+                    this.getResponseText.mockReturnValue('Ok');
+                    yield { type: LlmEventType.TextDelta, text: 'Ok' };
+                });
+                const stream = client.sendMessageStream(request, signal, promptId);
+                while (!(await stream.next()).done)
+                    ;
+                expect(mockHookSystem.fireAfterAgentEvent).toHaveBeenCalledWith(partToString(request), // Should be 'Do something'
+                expect.stringContaining('Ok'));
+            });
+            it('should cleanup state when prompt_id changes', async () => {
+                const signal = new AbortController().signal;
+                mockTurnRunFn.mockImplementation(async function* () {
+                    this.getResponseText.mockReturnValue('Ok');
+                    yield { type: LlmEventType.TextDelta, text: 'Ok' };
+                });
+                client['hookStateMap'].set('old-id', {
+                    hasFiredBeforeAgent: true,
+                    cumulativeResponse: 'Old',
+                    activeCalls: 0,
+                    originalRequest: { text: 'Old' },
+                });
+                client['lastPromptId'] = 'old-id';
+                const stream = client.sendMessageStream({ text: 'New' }, signal, 'new-id');
+                await stream.next();
+                expect(client['hookStateMap'].has('old-id')).toBe(false);
+                expect(client['hookStateMap'].has('new-id')).toBe(true);
+            });
+            it('should stop execution in BeforeAgent when hook returns continue: false', async () => {
+                mockHookSystem.fireBeforeAgentEvent.mockResolvedValue({
+                    shouldStopExecution: () => true,
+                    getEffectiveReason: () => 'Stopped by hook',
+                    systemMessage: undefined,
+                });
+                const mockChat = {
+                    addHistory: vi.fn(),
+                    getHistory: vi.fn().mockReturnValue([]),
+                    getLastPromptTokenCount: vi.fn(),
+                };
+                client['chat'] = mockChat;
+                const request = [{ text: 'Hello' }];
+                const stream = client.sendMessageStream(request, new AbortController().signal, 'test-prompt');
+                const events = await fromAsync(stream);
+                expect(events).toContainEqual({
+                    type: LlmEventType.AgentStopped,
+                    reason: 'Stopped by hook',
+                });
+                expect(mockChat.addHistory).toHaveBeenCalledWith({
+                    role: 'user',
+                    parts: request,
+                });
+                expect(mockTurnRunFn).not.toHaveBeenCalled();
+            });
+            it('should block execution in BeforeAgent when hook returns decision: block', async () => {
+                mockHookSystem.fireBeforeAgentEvent.mockResolvedValue({
+                    shouldStopExecution: () => false,
+                    isBlockingDecision: () => true,
+                    getEffectiveReason: () => 'Blocked by hook',
+                    systemMessage: undefined,
+                });
+                const mockChat = {
+                    addHistory: vi.fn(),
+                    getHistory: vi.fn().mockReturnValue([]),
+                    getLastPromptTokenCount: vi.fn(),
+                };
+                client['chat'] = mockChat;
+                const request = [{ text: 'Hello' }];
+                const stream = client.sendMessageStream(request, new AbortController().signal, 'test-prompt');
+                const events = await fromAsync(stream);
+                expect(events).toContainEqual({
+                    type: LlmEventType.AgentBlocked,
+                    reason: 'Blocked by hook',
+                });
+                expect(mockChat.addHistory).not.toHaveBeenCalled();
+                expect(mockTurnRunFn).not.toHaveBeenCalled();
+            });
+            it('should stop execution in AfterAgent when hook returns continue: false', async () => {
+                mockHookSystem.fireAfterAgentEvent.mockResolvedValue({
+                    shouldStopExecution: () => true,
+                    getEffectiveReason: () => 'Stopped after agent',
+                    shouldClearContext: () => false,
+                    systemMessage: undefined,
+                });
+                mockTurnRunFn.mockImplementation(async function* () {
+                    yield { type: LlmEventType.TextDelta, text: 'Hello' };
+                });
+                const stream = client.sendMessageStream({ text: 'Hi' }, new AbortController().signal, 'test-prompt');
+                const events = await fromAsync(stream);
+                expect(events).toContainEqual(expect.objectContaining({
+                    type: LlmEventType.AgentStopped,
+                    reason: 'Stopped after agent',
+                }));
+                // sendMessageStream should not recurse
+                expect(mockTurnRunFn).toHaveBeenCalledTimes(1);
+            });
+            it('should yield AgentExecutionBlocked and recurse in AfterAgent when hook returns decision: block', async () => {
+                mockHookSystem.fireAfterAgentEvent
+                    .mockResolvedValueOnce({
+                    shouldStopExecution: () => false,
+                    isBlockingDecision: () => true,
+                    getEffectiveReason: () => 'Please explain',
+                    shouldClearContext: () => false,
+                    systemMessage: undefined,
+                })
+                    .mockResolvedValueOnce({
+                    shouldStopExecution: () => false,
+                    isBlockingDecision: () => false,
+                    shouldClearContext: () => false,
+                    systemMessage: undefined,
+                });
+                mockTurnRunFn.mockImplementation(async function* () {
+                    yield { type: LlmEventType.TextDelta, text: 'Response' };
+                });
+                const stream = client.sendMessageStream({ text: 'Hi' }, new AbortController().signal, 'test-prompt');
+                const events = await fromAsync(stream);
+                expect(events).toContainEqual(expect.objectContaining({
+                    type: LlmEventType.AgentBlocked,
+                    reason: 'Please explain',
+                }));
+                // Should have called turn run twice (original + re-prompt)
+                expect(mockTurnRunFn).toHaveBeenCalledTimes(2);
+                expect(mockTurnRunFn).toHaveBeenNthCalledWith(2, expect.anything(), [{ text: 'Please explain' }], expect.anything());
+            });
+            it('should call resetChat when AfterAgent hook returns shouldClearContext: true', async () => {
+                const resetChatSpy = vi
+                    .spyOn(client, 'resetChat')
+                    .mockResolvedValue(undefined);
+                mockHookSystem.fireAfterAgentEvent
+                    .mockResolvedValueOnce({
+                    shouldStopExecution: () => false,
+                    isBlockingDecision: () => true,
+                    getEffectiveReason: () => 'Blocked and clearing context',
+                    shouldClearContext: () => true,
+                    systemMessage: undefined,
+                })
+                    .mockResolvedValueOnce({
+                    shouldStopExecution: () => false,
+                    isBlockingDecision: () => false,
+                    shouldClearContext: () => false,
+                    systemMessage: undefined,
+                });
+                mockTurnRunFn.mockImplementation(async function* () {
+                    yield { type: LlmEventType.TextDelta, text: 'Response' };
+                });
+                const stream = client.sendMessageStream({ text: 'Hi' }, new AbortController().signal, 'test-prompt');
+                const events = await fromAsync(stream);
+                expect(events).toContainEqual({
+                    type: LlmEventType.AgentBlocked,
+                    reason: 'Blocked and clearing context',
+                    systemMessage: undefined,
+                    contextCleared: true,
+                });
+                expect(resetChatSpy).toHaveBeenCalledTimes(1);
+                resetChatSpy.mockRestore();
+            });
+        });
+    });
+    // ============================================================================
+    // processLlmTurn — Non-Gemini provider path
+    // ============================================================================
+    describe('processLlmTurn — non-Gemini provider path', () => {
+        function createNonGeminiGenerator(streamEvents) {
+            return {
+                providerName: 'claude',
+                generateContent: () => {
+                    throw new Error('Legacy Gemini API not supported');
+                },
+                generateContentStream: () => {
+                    throw new Error('Legacy Gemini API not supported');
+                },
+                countTokens: () => {
+                    throw new Error('Legacy Gemini API not supported');
+                },
+                embedContent: () => {
+                    throw new Error('Legacy Gemini API not supported');
+                },
+                llmGenerateContent: vi.fn(),
+                llmGenerateContentStream: vi.fn().mockReturnValue((async function* () {
+                    for (const event of streamEvents) {
+                        yield event;
+                    }
+                })()),
+                llmCountTokens: vi.fn(),
+            };
+        }
+        function setupNonGeminiClient(streamEvents) {
+            const generator = createNonGeminiGenerator(streamEvents);
+            vi.mocked(mockConfig.getContentGenerator).mockReturnValue(generator);
+            const mockRecordingService = {
+                recordMessage: vi.fn(),
+                recordMessageTokens: vi.fn(),
+                recordToolCalls: vi.fn(),
+                recordThought: vi.fn(),
+                initialize: vi.fn(),
+            };
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn().mockReturnValue(0),
+                getChatRecordingService: vi.fn().mockReturnValue(mockRecordingService),
+                getSystemInstruction: vi.fn().mockReturnValue('You are helpful.'),
+                getConfiguredTools: vi.fn().mockReturnValue([]),
+            };
+            client['chat'] = mockChat;
+            return { generator, mockChat, mockRecordingService };
+        }
+        it('should yield LlmEvents from non-Gemini provider stream', async () => {
+            const events = [
+                { type: LlmEventType.TextDelta, text: 'Hello ' },
+                { type: LlmEventType.TextDelta, text: 'world' },
+                { type: LlmEventType.Finished, finishReason: 'end_turn' },
+            ];
+            setupNonGeminiClient(events);
+            const stream = client.sendMessageStream([{ text: 'Hi' }], new AbortController().signal, 'prompt-llm-1');
+            const yielded = await fromAsync(stream);
+            // Should contain ModelInfo + the 3 LlmEvents
+            // Note: routing is skipped for non-Gemini, model comes from
+            // resolveProviderModel(config.getModel(), 'claude')
+            expect(yielded).toContainEqual({
+                type: LlmEventType.ModelInfo,
+                modelName: 'test-model',
+            });
+            expect(yielded).toContainEqual({
+                type: LlmEventType.TextDelta,
+                text: 'Hello ',
+            });
+            expect(yielded).toContainEqual({
+                type: LlmEventType.TextDelta,
+                text: 'world',
+            });
+            expect(yielded).toContainEqual({
+                type: LlmEventType.Finished,
+                finishReason: 'end_turn',
+            });
+        });
+        it('should NOT call Turn.run for non-Gemini providers', async () => {
+            setupNonGeminiClient([
+                { type: LlmEventType.TextDelta, text: 'Hi' },
+                { type: LlmEventType.Finished, finishReason: 'end_turn' },
+            ]);
+            const stream = client.sendMessageStream([{ text: 'test' }], new AbortController().signal, 'prompt-llm-2');
+            await fromAsync(stream);
+            expect(mockTurnRunFn).not.toHaveBeenCalled();
+        });
+        it('should add user request and model response to history', async () => {
+            const { mockChat } = setupNonGeminiClient([
+                { type: LlmEventType.TextDelta, text: 'Response text' },
+                { type: LlmEventType.Finished, finishReason: 'end_turn' },
+            ]);
+            const stream = client.sendMessageStream([{ text: 'User message' }], new AbortController().signal, 'prompt-llm-3');
+            await fromAsync(stream);
+            // User request added to history
+            expect(mockChat.addHistory).toHaveBeenCalledWith(expect.objectContaining({ role: 'user' }));
+            // Model response added to history
+            expect(mockChat.addHistory).toHaveBeenCalledWith(expect.objectContaining({
+                role: 'model',
+                parts: expect.arrayContaining([{ text: 'Response text' }]),
+            }));
+        });
+        it('should record user and model messages via chat recording service', async () => {
+            const { mockRecordingService } = setupNonGeminiClient([
+                { type: LlmEventType.TextDelta, text: 'Bot reply' },
+                { type: LlmEventType.Finished, finishReason: 'end_turn' },
+            ]);
+            const stream = client.sendMessageStream([{ text: 'User msg' }], new AbortController().signal, 'prompt-llm-4');
+            await fromAsync(stream);
+            // User message recorded
+            expect(mockRecordingService.recordMessage).toHaveBeenCalledWith(expect.objectContaining({ type: 'user' }));
+            // Model response recorded
+            expect(mockRecordingService.recordMessage).toHaveBeenCalledWith(expect.objectContaining({ type: 'gemini', content: 'Bot reply' }));
+        });
+        it('should handle tool call requests in non-Gemini stream', async () => {
+            setupNonGeminiClient([
+                { type: LlmEventType.TextDelta, text: 'Let me search.' },
+                {
+                    type: LlmEventType.ToolCallRequest,
+                    callId: 'call-1',
+                    name: 'search',
+                    args: { query: 'cats' },
+                },
+                { type: LlmEventType.Finished, finishReason: 'tool_use' },
+            ]);
+            const stream = client.sendMessageStream([{ text: 'Find cats' }], new AbortController().signal, 'prompt-llm-5');
+            const yielded = await fromAsync(stream);
+            expect(yielded).toContainEqual(expect.objectContaining({
+                type: LlmEventType.ToolCallRequest,
+                name: 'search',
+            }));
+        });
+        it('should not add model response to history on error', async () => {
+            const { mockChat } = setupNonGeminiClient([
+                { type: LlmEventType.TextDelta, text: 'partial...' },
+                {
+                    type: LlmEventType.Error,
+                    error: 'Something went wrong',
+                },
+            ]);
+            const stream = client.sendMessageStream([{ text: 'test' }], new AbortController().signal, 'prompt-llm-6');
+            await fromAsync(stream);
+            // User request IS added
+            expect(mockChat.addHistory).toHaveBeenCalledWith(expect.objectContaining({ role: 'user' }));
+            // Model response should NOT be added (error occurred)
+            expect(mockChat.addHistory).not.toHaveBeenCalledWith(expect.objectContaining({ role: 'model' }));
+        });
+        it('should call llmGenerateContentStream with correct request', async () => {
+            const { generator } = setupNonGeminiClient([
+                { type: LlmEventType.Finished, finishReason: 'end_turn' },
+            ]);
+            const stream = client.sendMessageStream([{ text: 'Hello' }], new AbortController().signal, 'prompt-llm-7');
+            await fromAsync(stream);
+            const llmStream = generator.llmGenerateContentStream;
+            expect(llmStream).toHaveBeenCalledWith(expect.objectContaining({
+                model: 'test-model',
+                messages: expect.any(Array),
+            }), 'prompt-llm-7', expect.objectContaining({ signal: expect.any(AbortSignal) }));
+        });
+        it('should skip routing for non-Gemini providers', async () => {
+            setupNonGeminiClient([
+                { type: LlmEventType.Finished, finishReason: 'end_turn' },
+            ]);
+            const stream = client.sendMessageStream([{ text: 'test' }], new AbortController().signal, 'prompt-llm-8');
+            await fromAsync(stream);
+            // Routing should NOT be called — it uses legacy Gemini API
+            expect(mockRouterService.route).not.toHaveBeenCalled();
+        });
+        it('should update config model for status bar display', async () => {
+            setupNonGeminiClient([
+                { type: LlmEventType.Finished, finishReason: 'end_turn' },
+            ]);
+            const stream = client.sendMessageStream([{ text: 'test' }], new AbortController().signal, 'prompt-llm-9');
+            await fromAsync(stream);
+            // config.setModel should be called with resolved provider model
+            expect(mockConfig.setModel).toHaveBeenCalledWith('test-model', true);
+        });
+        it('should yield explicit error when providerName is non-gemini but llm* methods are missing', async () => {
+            const brokenGenerator = {
+                providerName: 'claude',
+                generateContent: () => {
+                    throw new Error('legacy path');
+                },
+                generateContentStream: () => {
+                    throw new Error('legacy path');
+                },
+                countTokens: () => {
+                    throw new Error('legacy path');
+                },
+                embedContent: () => {
+                    throw new Error('legacy path');
+                },
+            };
+            vi.mocked(mockConfig.getContentGenerator).mockReturnValue(brokenGenerator);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn().mockReturnValue(0),
+                getChatRecordingService: vi.fn().mockReturnValue({
+                    recordMessage: vi.fn(),
+                    recordMessageTokens: vi.fn(),
+                    recordToolCalls: vi.fn(),
+                    recordThought: vi.fn(),
+                    initialize: vi.fn(),
+                }),
+                getSystemInstruction: vi.fn().mockReturnValue('You are helpful.'),
+                getConfiguredTools: vi.fn().mockReturnValue([]),
+            };
+            client['chat'] = mockChat;
+            const stream = client.sendMessageStream([{ text: 'test' }], new AbortController().signal, 'prompt-llm-mismatch');
+            const yielded = await fromAsync(stream);
+            expect(yielded).toContainEqual(expect.objectContaining({
+                type: LlmEventType.Error,
+                code: 'PROVIDER_METHOD_MISMATCH',
+                isRetryable: false,
+            }));
+            expect(mockRouterService.route).not.toHaveBeenCalled();
+        });
+        it('should convert thrown llm stream exception into Error event', async () => {
+            const generator = createNonGeminiGenerator([]);
+            generator.llmGenerateContentStream = vi.fn().mockReturnValue(
+            // eslint-disable-next-line require-yield
+            (async function* () {
+                throw new Error('stream exploded');
+            })());
+            vi.mocked(mockConfig.getContentGenerator).mockReturnValue(generator);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn().mockReturnValue(0),
+                getChatRecordingService: vi.fn().mockReturnValue({
+                    recordMessage: vi.fn(),
+                    recordMessageTokens: vi.fn(),
+                    recordToolCalls: vi.fn(),
+                    recordThought: vi.fn(),
+                    initialize: vi.fn(),
+                }),
+                getSystemInstruction: vi.fn().mockReturnValue('You are helpful.'),
+                getConfiguredTools: vi.fn().mockReturnValue([]),
+            };
+            client['chat'] = mockChat;
+            const stream = client.sendMessageStream([{ text: 'test' }], new AbortController().signal, 'prompt-llm-throw');
+            const yielded = await fromAsync(stream);
+            expect(yielded).toContainEqual(expect.objectContaining({
+                type: LlmEventType.ModelInfo,
+                modelName: 'test-model',
+            }));
+            expect(yielded).toContainEqual(expect.objectContaining({
+                type: LlmEventType.Error,
+                code: 'LLM_STREAM_FAILURE',
+                isRetryable: false,
+            }));
+            // Error path should not append model response history.
+            expect(mockChat.addHistory).not.toHaveBeenCalledWith(expect.objectContaining({ role: 'model' }));
+        });
+        it('should yield UserCancelled (not Error) when abort signal triggers stream throw', async () => {
+            const controller = new AbortController();
+            const generator = createNonGeminiGenerator([]);
+            generator.llmGenerateContentStream = vi.fn().mockReturnValue(
+            // eslint-disable-next-line require-yield
+            (async function* () {
+                // Simulate: stream throws after abort signal fires
+                controller.abort();
+                throw new Error('The operation was aborted');
+            })());
+            vi.mocked(mockConfig.getContentGenerator).mockReturnValue(generator);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn().mockReturnValue(0),
+                getChatRecordingService: vi.fn().mockReturnValue({
+                    recordMessage: vi.fn(),
+                    recordMessageTokens: vi.fn(),
+                    recordToolCalls: vi.fn(),
+                    recordThought: vi.fn(),
+                    initialize: vi.fn(),
+                }),
+                getSystemInstruction: vi.fn().mockReturnValue('You are helpful.'),
+                getConfiguredTools: vi.fn().mockReturnValue([]),
+            };
+            client['chat'] = mockChat;
+            const stream = client.sendMessageStream([{ text: 'test' }], controller.signal, 'prompt-abort-stream');
+            const yielded = await fromAsync(stream);
+            // Should emit UserCancelled, NOT LLM_STREAM_FAILURE
+            expect(yielded).toContainEqual({
+                type: LlmEventType.UserCancelled,
+            });
+            expect(yielded).not.toContainEqual(expect.objectContaining({ code: 'LLM_STREAM_FAILURE' }));
+        });
+        it('should yield UserCancelled when stream throws AbortError by name', async () => {
+            const generator = createNonGeminiGenerator([]);
+            const abortError = new Error('Aborted');
+            abortError.name = 'AbortError';
+            generator.llmGenerateContentStream = vi.fn().mockReturnValue(
+            // eslint-disable-next-line require-yield
+            (async function* () {
+                throw abortError;
+            })());
+            vi.mocked(mockConfig.getContentGenerator).mockReturnValue(generator);
+            const mockChat = {
+                addHistory: vi.fn(),
+                getHistory: vi.fn().mockReturnValue([]),
+                getLastPromptTokenCount: vi.fn().mockReturnValue(0),
+                getChatRecordingService: vi.fn().mockReturnValue({
+                    recordMessage: vi.fn(),
+                    recordMessageTokens: vi.fn(),
+                    recordToolCalls: vi.fn(),
+                    recordThought: vi.fn(),
+                    initialize: vi.fn(),
+                }),
+                getSystemInstruction: vi.fn().mockReturnValue('You are helpful.'),
+                getConfiguredTools: vi.fn().mockReturnValue([]),
+            };
+            client['chat'] = mockChat;
+            const stream = client.sendMessageStream([{ text: 'test' }], new AbortController().signal, 'prompt-abort-error');
+            const yielded = await fromAsync(stream);
+            // AbortError by name should also be classified as user cancellation
+            expect(yielded).toContainEqual({
+                type: LlmEventType.UserCancelled,
+            });
+            expect(yielded).not.toContainEqual(expect.objectContaining({ code: 'LLM_STREAM_FAILURE' }));
+        });
+    });
+});
+//# sourceMappingURL=client.test.js.map