@vybestack/llxprt-code-core 0.1.18-nightly.250811.b0db22c6 → 0.1.18-nightly.250812.12fa8ad2

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

@@ -1,1323 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-// Mock prompts module before imports
-vi.mock('./prompts.js', () => ({
-    getCoreSystemPromptAsync: vi
-        .fn()
-        .mockResolvedValue('Test system instruction'),
-    getCompressionPrompt: vi.fn().mockReturnValue('Test compression prompt'),
-    initializePromptSystem: vi.fn().mockResolvedValue(undefined),
-}));
-import { GoogleGenAI, } from '@google/genai';
-import { findIndexAfterFraction, GeminiClient } from './client.js';
-import { getCoreSystemPromptAsync } from './prompts.js';
-import { AuthType, } from './contentGenerator.js';
-import { Config } from '../config/config.js';
-import { GeminiEventType, Turn } from './turn.js';
-import { DEFAULT_GEMINI_FLASH_MODEL } from '../config/models.js';
-import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
-import { setSimulate429 } from '../utils/testUtils.js';
-import { tokenLimit } from './tokenLimits.js';
-import { ideContext } from '../ide/ideContext.js';
-import { ComplexityAnalyzer } from '../services/complexity-analyzer.js';
-import { TodoReminderService } from '../services/todo-reminder-service.js';
-// --- Mocks ---
-const mockChatCreateFn = vi.fn();
-const mockGenerateContentFn = vi.fn();
-const mockEmbedContentFn = vi.fn();
-const mockTurnRunFn = vi.fn();
-vi.mock('@google/genai');
-vi.mock('../services/complexity-analyzer.js', () => ({
-    ComplexityAnalyzer: vi.fn().mockImplementation(() => ({
-        analyzeComplexity: vi.fn().mockReturnValue({
-            complexityScore: 0.2,
-            isComplex: false,
-            detectedTasks: [],
-            sequentialIndicators: [],
-            questionCount: 0,
-            shouldSuggestTodos: false,
-        }),
-    })),
-}));
-vi.mock('../services/todo-reminder-service.js', () => ({
-    TodoReminderService: vi.fn().mockImplementation(() => ({
-        getComplexTaskSuggestion: vi.fn(),
-    })),
-}));
-vi.mock('./turn', () => {
-    // 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
-        }
-    }
-    // Export the mock class as 'Turn'
-    return {
-        Turn: MockTurn,
-        GeminiEventType: {
-            MaxSessionTurns: 'MaxSessionTurns',
-            ChatCompressed: 'ChatCompressed',
-        },
-    };
-});
-vi.mock('../config/config.js');
-vi.mock('../utils/getFolderStructure', () => ({
-    getFolderStructure: vi.fn().mockResolvedValue('Mock Folder Structure'),
-}));
-vi.mock('../utils/errorReporting', () => ({ reportError: vi.fn() }));
-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('../utils/retry.js', () => ({
-    retryWithBackoff: vi.fn((apiCall) => apiCall()),
-}));
-vi.mock('../ide/ideContext.js');
-describe('findIndexAfterFraction', () => {
-    const history = [
-        { role: 'user', parts: [{ text: 'This is the first message.' }] }, // JSON length: 66
-        { role: 'model', parts: [{ text: 'This is the second message.' }] }, // JSON length: 68
-        { role: 'user', parts: [{ text: 'This is the third message.' }] }, // JSON length: 66
-        { role: 'model', parts: [{ text: 'This is the fourth message.' }] }, // JSON length: 68
-        { role: 'user', parts: [{ text: 'This is the fifth message.' }] }, // JSON length: 65
-    ];
-    // Total length: 333
-    it('should throw an error for non-positive numbers', () => {
-        expect(() => findIndexAfterFraction(history, 0)).toThrow('Fraction must be between 0 and 1');
-    });
-    it('should throw an error for a fraction greater than or equal to 1', () => {
-        expect(() => findIndexAfterFraction(history, 1)).toThrow('Fraction must be between 0 and 1');
-    });
-    it('should handle a fraction in the middle', () => {
-        // 333 * 0.5 = 166.5
-        // 0: 66
-        // 1: 66 + 68 = 134
-        // 2: 134 + 66 = 200
-        // 200 >= 166.5, so index is 2
-        expect(findIndexAfterFraction(history, 0.5)).toBe(2);
-    });
-    it('should handle a fraction that results in the last index', () => {
-        // 333 * 0.9 = 299.7
-        // ...
-        // 3: 200 + 68 = 268
-        // 4: 268 + 65 = 333
-        // 333 >= 299.7, so index is 4
-        expect(findIndexAfterFraction(history, 0.9)).toBe(4);
-    });
-    it('should handle an empty history', () => {
-        expect(findIndexAfterFraction([], 0.5)).toBe(0);
-    });
-    it('should handle a history with only one item', () => {
-        expect(findIndexAfterFraction(history.slice(0, 1), 0.5)).toBe(0);
-    });
-    it('should handle history with weird parts', () => {
-        const historyWithEmptyParts = [
-            { role: 'user', parts: [{ text: 'Message 1' }] },
-            { role: 'model', parts: [{ fileData: { fileUri: 'derp' } }] },
-            { role: 'user', parts: [{ text: 'Message 2' }] },
-        ];
-        expect(findIndexAfterFraction(historyWithEmptyParts, 0.5)).toBe(1);
-    });
-});
-describe('Gemini Client (client.ts)', () => {
-    let client;
-    beforeEach(async () => {
-        vi.resetAllMocks();
-        // Re-setup prompts mocks after reset
-        vi.mocked(getCoreSystemPromptAsync).mockResolvedValue('Test system instruction');
-        // Re-setup mocks after reset
-        vi.mocked(ComplexityAnalyzer).mockImplementation(() => ({
-            analyzeComplexity: vi.fn().mockReturnValue({
-                complexityScore: 0.2,
-                isComplex: false,
-                detectedTasks: [],
-                sequentialIndicators: [],
-                questionCount: 0,
-                shouldSuggestTodos: false,
-            }),
-        }));
-        vi.mocked(TodoReminderService).mockImplementation(() => ({
-            getComplexTaskSuggestion: vi.fn(),
-        }));
-        // Disable 429 simulation for tests
-        setSimulate429(false);
-        // Set up the mock for GoogleGenAI constructor and its methods
-        const MockedGoogleGenAI = vi.mocked(GoogleGenAI);
-        MockedGoogleGenAI.mockImplementation((..._args) => {
-            const mockInstance = {
-                chats: { create: mockChatCreateFn },
-                models: {
-                    generateContent: mockGenerateContentFn,
-                    embedContent: mockEmbedContentFn,
-                },
-            };
-            return mockInstance;
-        });
-        mockChatCreateFn.mockResolvedValue({});
-        mockGenerateContentFn.mockResolvedValue({
-            candidates: [
-                {
-                    content: {
-                        parts: [{ text: '{"key": "value"}' }],
-                    },
-                },
-            ],
-        });
-        // 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 MockedConfig = vi.mocked(Config, true);
-        const contentGeneratorConfig = {
-            model: 'test-model',
-            apiKey: 'test-key',
-            vertexai: false,
-            authType: AuthType.USE_GEMINI,
-        };
-        const mockConfigObject = {
-            getContentGeneratorConfig: vi
-                .fn()
-                .mockReturnValue(contentGeneratorConfig),
-            getToolRegistry: vi.fn().mockResolvedValue(mockToolRegistry),
-            getModel: vi.fn().mockReturnValue('test-model'),
-            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(''),
-            getFullContext: 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),
-            getWorkspaceContext: vi.fn().mockReturnValue({
-                getDirectories: vi.fn().mockReturnValue(['/test/dir']),
-            }),
-            getGeminiClient: vi.fn(),
-            getDebugMode: vi.fn().mockReturnValue(false),
-            setFallbackMode: vi.fn(),
-            getComplexityAnalyzerSettings: vi.fn().mockReturnValue({
-                complexityThreshold: 0.6,
-                minTasksForSuggestion: 3,
-                suggestionCooldownMs: 300000,
-            }),
-            getChatCompression: vi.fn().mockReturnValue(undefined),
-        };
-        MockedConfig.mockImplementation(() => mockConfigObject);
-        // We can instantiate the client here since Config is mocked
-        // and the constructor will use the mocked GoogleGenAI
-        const mockConfig = new Config({
-            sessionId: 'test-session-id',
-        });
-        client = new GeminiClient(mockConfig);
-        await client.initialize(contentGeneratorConfig);
-        // Update the mock to return the client
-        mockConfigObject.getGeminiClient.mockReturnValue(client);
-        // Add missing methods to the client instance for tests
-        client.getHistory = vi.fn().mockReturnValue([]);
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    // NOTE: The following tests for startChat were removed due to persistent issues with
-    // the @google/genai mock. Specifically, the mockChatCreateFn (representing instance.chats.create)
-    // was not being detected as called by the GeminiClient instance.
-    // This likely points to a subtle issue in how the GoogleGenerativeAI class constructor
-    // and its instance methods are mocked and then used by the class under test.
-    // For future debugging, ensure that the `this.client` in `GeminiClient` (which is an
-    // instance of the mocked GoogleGenerativeAI) correctly has its `chats.create` method
-    // pointing to `mockChatCreateFn`.
-    // it('startChat should call getCoreSystemPrompt with userMemory and pass to chats.create', async () => { ... });
-    // it('startChat should call getCoreSystemPrompt with empty string if userMemory is empty', async () => { ... });
-    // NOTE: The following tests for generateJson were removed due to persistent issues with
-    // the @google/genai mock, similar to the startChat tests. The mockGenerateContentFn
-    // (representing instance.models.generateContent) was not being detected as called, or the mock
-    // was not preventing an actual API call (leading to API key errors).
-    // For future debugging, ensure `this.client.models.generateContent` in `GeminiClient` correctly
-    // uses the `mockGenerateContentFn`.
-    // it('generateJson should call getCoreSystemPrompt with userMemory and pass to generateContent', async () => { ... });
-    // it('generateJson should call getCoreSystemPrompt with empty string if userMemory is empty', async () => { ... });
-    describe('generateEmbedding', () => {
-        const texts = ['hello world', 'goodbye world'];
-        const testEmbeddingModel = 'test-embedding-model';
-        it('should call embedContent with correct parameters and return embeddings', async () => {
-            const mockEmbeddings = [
-                [0.1, 0.2, 0.3],
-                [0.4, 0.5, 0.6],
-            ];
-            const mockResponse = {
-                embeddings: [
-                    { values: mockEmbeddings[0] },
-                    { values: mockEmbeddings[1] },
-                ],
-            };
-            mockEmbedContentFn.mockResolvedValue(mockResponse);
-            const result = await client.generateEmbedding(texts);
-            expect(mockEmbedContentFn).toHaveBeenCalledTimes(1);
-            expect(mockEmbedContentFn).toHaveBeenCalledWith({
-                model: testEmbeddingModel,
-                contents: texts,
-            });
-            expect(result).toEqual(mockEmbeddings);
-        });
-        it('should return an empty array if an empty array is passed', async () => {
-            const result = await client.generateEmbedding([]);
-            expect(result).toEqual([]);
-            expect(mockEmbedContentFn).not.toHaveBeenCalled();
-        });
-        it('should throw an error if API response has no embeddings array', async () => {
-            mockEmbedContentFn.mockResolvedValue({}); // No `embeddings` key
-            await expect(client.generateEmbedding(texts)).rejects.toThrow('No embeddings found in API response.');
-        });
-        it('should throw an error if API response has an empty embeddings array', async () => {
-            const mockResponse = {
-                embeddings: [],
-            };
-            mockEmbedContentFn.mockResolvedValue(mockResponse);
-            await expect(client.generateEmbedding(texts)).rejects.toThrow('No embeddings found in API response.');
-        });
-        it('should throw an error if API returns a mismatched number of embeddings', async () => {
-            const mockResponse = {
-                embeddings: [{ values: [1, 2, 3] }], // Only one for two texts
-            };
-            mockEmbedContentFn.mockResolvedValue(mockResponse);
-            await expect(client.generateEmbedding(texts)).rejects.toThrow('API returned a mismatched number of embeddings. Expected 2, got 1.');
-        });
-        it('should throw an error if any embedding has nullish values', async () => {
-            const mockResponse = {
-                embeddings: [{ values: [1, 2, 3] }, { values: undefined }], // Second one is bad
-            };
-            mockEmbedContentFn.mockResolvedValue(mockResponse);
-            await expect(client.generateEmbedding(texts)).rejects.toThrow('API returned an empty embedding for input text at index 1: "goodbye world"');
-        });
-        it('should throw an error if any embedding has an empty values array', async () => {
-            const mockResponse = {
-                embeddings: [{ values: [] }, { values: [1, 2, 3] }], // First one is bad
-            };
-            mockEmbedContentFn.mockResolvedValue(mockResponse);
-            await expect(client.generateEmbedding(texts)).rejects.toThrow('API returned an empty embedding for input text at index 0: "hello world"');
-        });
-        it('should propagate errors from the API call', async () => {
-            const apiError = new Error('API Failure');
-            mockEmbedContentFn.mockRejectedValue(apiError);
-            await expect(client.generateEmbedding(texts)).rejects.toThrow('API Failure');
-        });
-    });
-    describe('generateContent', () => {
-        it('should call generateContent with the correct parameters', async () => {
-            const contents = [{ role: 'user', parts: [{ text: 'hello' }] }];
-            const generationConfig = { temperature: 0.5 };
-            const abortSignal = new AbortController().signal;
-            // Mock the retryWithBackoff to directly call the apiCall function
-            vi.mock('../utils/retry.js', () => ({
-                retryWithBackoff: vi.fn((apiCall) => apiCall()),
-            }));
-            // Mock countTokens with a fresh mock function
-            const mockContentGeneratorGenerateContent = vi.fn().mockResolvedValue({
-                candidates: [
-                    {
-                        content: {
-                            parts: [{ text: 'response' }],
-                        },
-                    },
-                ],
-            });
-            const mockGenerator = {
-                countTokens: vi.fn().mockResolvedValue({ totalTokens: 1 }),
-                generateContent: mockContentGeneratorGenerateContent,
-                generateContentStream: vi.fn(),
-                embedContent: vi.fn(),
-            };
-            client['contentGenerator'] = mockGenerator;
-            client['isInitialized'] = vi.fn().mockReturnValue(true);
-            const { retryWithBackoff } = await import('../utils/retry.js');
-            vi.mocked(retryWithBackoff).mockImplementation(async (apiCall) => await apiCall());
-            await client.generateContent(contents, generationConfig, abortSignal);
-            expect(mockContentGeneratorGenerateContent).toHaveBeenCalledWith({
-                model: 'test-model',
-                config: {
-                    abortSignal,
-                    systemInstruction: 'Test system instruction',
-                    temperature: 0.5,
-                    topP: 1,
-                },
-                contents,
-            }, 'test-session-id');
-        });
-    });
-    describe('generateJson', () => {
-        it('should call generateContent with the correct parameters', async () => {
-            const contents = [{ role: 'user', parts: [{ text: 'hello' }] }];
-            const schema = { type: 'string' };
-            const abortSignal = new AbortController().signal;
-            // Mock lazyInitialize to prevent it from overriding our mock
-            client['lazyInitialize'] = vi.fn().mockResolvedValue(undefined);
-            // Track the arguments manually
-            let capturedRequest;
-            let capturedPromptId;
-            const mockGenerator = {
-                countTokens: vi.fn().mockResolvedValue({ totalTokens: 1 }),
-                generateContent: vi.fn(async (request, promptId) => {
-                    capturedRequest = request;
-                    capturedPromptId = promptId;
-                    return {
-                        candidates: [
-                            {
-                                content: {
-                                    parts: [{ text: '{"key": "value"}' }],
-                                },
-                            },
-                        ],
-                    };
-                }),
-                generateContentStream: vi.fn(),
-                embedContent: vi.fn(),
-            };
-            client['contentGenerator'] = mockGenerator;
-            try {
-                await client.generateJson(contents, schema, abortSignal);
-            }
-            catch (error) {
-                console.error('Error in generateJson:', error);
-                throw error;
-            }
-            // Check the captured arguments
-            expect(capturedRequest).toBeDefined();
-            expect(capturedPromptId).toBe('test-session-id');
-            expect(capturedRequest).toMatchObject({
-                model: 'test-model', // Should use current model from config
-                config: {
-                    abortSignal,
-                    systemInstruction: 'Test system instruction',
-                    temperature: 0,
-                    topP: 1,
-                    responseSchema: schema,
-                    responseMimeType: 'application/json',
-                },
-                contents,
-            });
-        });
-        it('should allow overriding model and config', async () => {
-            const contents = [{ role: 'user', parts: [{ text: 'hello' }] }];
-            const schema = { type: 'string' };
-            const abortSignal = new AbortController().signal;
-            const customModel = 'custom-json-model';
-            const customConfig = { temperature: 0.9, topK: 20 };
-            // Mock lazyInitialize to prevent it from overriding our mock
-            client['lazyInitialize'] = vi.fn().mockResolvedValue(undefined);
-            // Track the arguments manually
-            let capturedRequest;
-            let capturedPromptId;
-            const mockGenerator = {
-                countTokens: vi.fn().mockResolvedValue({ totalTokens: 1 }),
-                generateContent: vi.fn(async (request, promptId) => {
-                    capturedRequest = request;
-                    capturedPromptId = promptId;
-                    return {
-                        candidates: [
-                            {
-                                content: {
-                                    parts: [{ text: '{"key": "value"}' }],
-                                },
-                            },
-                        ],
-                    };
-                }),
-            };
-            client['contentGenerator'] = mockGenerator;
-            await client.generateJson(contents, schema, abortSignal, customModel, customConfig);
-            // Check the captured arguments
-            expect(capturedRequest).toBeDefined();
-            expect(capturedPromptId).toBe('test-session-id');
-            expect(capturedRequest).toMatchObject({
-                model: customModel,
-                config: {
-                    abortSignal,
-                    systemInstruction: 'Test system instruction',
-                    temperature: 0.9,
-                    topP: 1, // from default
-                    topK: 20,
-                    responseSchema: schema,
-                    responseMimeType: 'application/json',
-                },
-                contents,
-            });
-        });
-    });
-    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('resetChat', () => {
-        it('should create a new chat session, clearing the old history', async () => {
-            // Create mock chats with distinct histories
-            const initialChatHistory = [
-                { role: 'user', parts: [{ text: 'initial context' }] },
-                { role: 'model', parts: [{ text: 'acknowledged' }] },
-            ];
-            const mockInitialChat = {
-                getHistory: vi.fn().mockReturnValue(initialChatHistory),
-                addHistory: vi.fn().mockImplementation((content) => {
-                    // Update the history when addHistory is called
-                    initialChatHistory.push(content);
-                }),
-                setHistory: vi.fn(),
-            };
-            const mockNewChat = {
-                getHistory: vi.fn().mockReturnValue([
-                    { role: 'user', parts: [{ text: 'fresh start' }] },
-                    { role: 'model', parts: [{ text: 'ready' }] },
-                ]),
-                addHistory: vi.fn(),
-                setHistory: vi.fn(),
-            };
-            // Mock startChat to return the new chat when called
-            const mockStartChat = vi.fn().mockResolvedValue(mockNewChat);
-            client['startChat'] = mockStartChat;
-            client['chat'] = mockInitialChat;
-            // Mock that client is initialized
-            client['contentGenerator'] = {};
-            client['isInitialized'] = vi.fn().mockReturnValue(true);
-            // Override the global getHistory mock for this test
-            const getHistoryMock = vi.mocked(client.getHistory);
-            getHistoryMock.mockImplementation(async () => client.getChat().getHistory());
-            // 1. Get the initial chat instance and verify initial state
-            const initialChat = client.getChat();
-            expect(initialChat).toBe(mockInitialChat);
-            const initialHistory = await client.getHistory();
-            expect(initialHistory).toHaveLength(2); // initial context + acknowledged
-            // Add a message to the initial chat
-            await client.addHistory({
-                role: 'user',
-                parts: [{ text: 'some old message' }],
-            });
-            const historyWithOldMessage = await client.getHistory();
-            expect(historyWithOldMessage).toHaveLength(3);
-            expect(JSON.stringify(historyWithOldMessage)).toContain('some old message');
-            // 2. Call resetChat
-            await client.resetChat();
-            // 3. Verify the chat was replaced
-            const newChat = client.getChat();
-            expect(mockStartChat).toHaveBeenCalledTimes(1);
-            expect(client['chat']).toBe(mockNewChat);
-            expect(newChat).toBe(mockNewChat);
-            expect(newChat).not.toBe(initialChat);
-            // 4. Verify the history is from the new chat
-            const newHistory = await client.getHistory();
-            expect(newHistory).toHaveLength(2); // fresh start + ready
-            expect(JSON.stringify(newHistory)).not.toContain('some old message');
-            expect(JSON.stringify(newHistory)).toContain('fresh start');
-        });
-    });
-    describe('tryCompressChat', () => {
-        const mockCountTokens = vi.fn();
-        const mockSendMessage = vi.fn();
-        const mockGetHistory = vi.fn();
-        beforeEach(() => {
-            vi.mock('./tokenLimits', () => ({
-                tokenLimit: vi.fn(),
-            }));
-            client['contentGenerator'] = {
-                countTokens: mockCountTokens,
-            };
-            client['chat'] = {
-                getHistory: mockGetHistory,
-                addHistory: vi.fn(),
-                setHistory: vi.fn(),
-                sendMessage: mockSendMessage,
-            };
-        });
-        it('should not trigger summarization if token count is below threshold', async () => {
-            const MOCKED_TOKEN_LIMIT = 1000;
-            vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
-            mockGetHistory.mockReturnValue([
-                { role: 'user', parts: [{ text: '...history...' }] },
-            ]);
-            mockCountTokens.mockResolvedValue({
-                totalTokens: MOCKED_TOKEN_LIMIT * 0.699, // TOKEN_THRESHOLD_FOR_SUMMARIZATION = 0.7
-            });
-            const initialChat = client.getChat();
-            const result = await client.tryCompressChat('prompt-id-2');
-            const newChat = client.getChat();
-            expect(tokenLimit).toHaveBeenCalled();
-            expect(result).toBeNull();
-            expect(newChat).toBe(initialChat);
-        });
-        it('should trigger summarization if token count is at threshold with contextPercentageThreshold setting', async () => {
-            const MOCKED_TOKEN_LIMIT = 1000;
-            const MOCKED_CONTEXT_PERCENTAGE_THRESHOLD = 0.5;
-            vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
-            vi.spyOn(client['config'], 'getChatCompression').mockReturnValue({
-                contextPercentageThreshold: MOCKED_CONTEXT_PERCENTAGE_THRESHOLD,
-            });
-            mockGetHistory.mockReturnValue([
-                { role: 'user', parts: [{ text: '...history...' }] },
-            ]);
-            const originalTokenCount = MOCKED_TOKEN_LIMIT * MOCKED_CONTEXT_PERCENTAGE_THRESHOLD;
-            const newTokenCount = 100;
-            mockCountTokens
-                .mockResolvedValueOnce({ totalTokens: originalTokenCount }) // First call for the check
-                .mockResolvedValueOnce({ totalTokens: newTokenCount }); // Second call for the new history
-            // Mock the summary response from the chat
-            mockSendMessage.mockResolvedValue({
-                role: 'model',
-                parts: [{ text: 'This is a summary.' }],
-            });
-            const initialChat = client.getChat();
-            const result = await client.tryCompressChat('prompt-id-3');
-            const newChat = client.getChat();
-            expect(tokenLimit).toHaveBeenCalled();
-            expect(mockSendMessage).toHaveBeenCalled();
-            // Assert that summarization happened and returned the correct stats
-            expect(result).toEqual({
-                originalTokenCount,
-                newTokenCount,
-            });
-            // Assert that the chat was reset
-            expect(newChat).not.toBe(initialChat);
-        });
-        it('should not compress across a function call response', async () => {
-            const MOCKED_TOKEN_LIMIT = 1000;
-            vi.mocked(tokenLimit).mockReturnValue(MOCKED_TOKEN_LIMIT);
-            mockGetHistory.mockReturnValue([
-                { role: 'user', parts: [{ text: '...history 1...' }] },
-                { role: 'model', parts: [{ text: '...history 2...' }] },
-                { role: 'user', parts: [{ text: '...history 3...' }] },
-                { role: 'model', parts: [{ text: '...history 4...' }] },
-                { role: 'user', parts: [{ text: '...history 5...' }] },
-                { role: 'model', parts: [{ text: '...history 6...' }] },
-                { role: 'user', parts: [{ text: '...history 7...' }] },
-                { role: 'model', parts: [{ text: '...history 8...' }] },
-                // Normally we would break here, but we have a function response.
-                {
-                    role: 'user',
-                    parts: [{ functionResponse: { name: '...history 8...' } }],
-                },
-                { role: 'model', parts: [{ text: '...history 10...' }] },
-                // Instead we will break here.
-                { role: 'user', parts: [{ text: '...history 10...' }] },
-            ]);
-            const originalTokenCount = 1000 * 0.7;
-            const newTokenCount = 100;
-            mockCountTokens
-                .mockResolvedValueOnce({ totalTokens: originalTokenCount }) // First call for the check
-                .mockResolvedValueOnce({ totalTokens: newTokenCount }); // Second call for the new history
-            // Mock the summary response from the chat
-            mockSendMessage.mockResolvedValue({
-                role: 'model',
-                parts: [{ text: 'This is a summary.' }],
-            });
-            const initialChat = client.getChat();
-            const result = await client.tryCompressChat('prompt-id-3');
-            const newChat = client.getChat();
-            expect(tokenLimit).toHaveBeenCalled();
-            expect(mockSendMessage).toHaveBeenCalled();
-            // Assert that summarization happened and returned the correct stats
-            expect(result).toEqual({
-                originalTokenCount,
-                newTokenCount,
-            });
-            // Assert that the chat was reset
-            expect(newChat).not.toBe(initialChat);
-            // 1. standard start context message
-            // After compression, we should have:
-            // 1. compressed summary message
-            // 2. standard canned user summary message
-            // 3. The last user message (not the last 3 because that would start with a function response)
-            // (No more environment context messages since they're in system instruction now)
-            expect(newChat.getHistory().length).toEqual(3);
-        });
-        it('should always trigger summarization when force is true, regardless of token count', async () => {
-            mockGetHistory.mockReturnValue([
-                { role: 'user', parts: [{ text: '...history...' }] },
-            ]);
-            const originalTokenCount = 10; // Well below threshold
-            const newTokenCount = 5;
-            mockCountTokens
-                .mockResolvedValueOnce({ totalTokens: originalTokenCount })
-                .mockResolvedValueOnce({ totalTokens: newTokenCount });
-            // Mock the summary response from the chat
-            mockSendMessage.mockResolvedValue({
-                role: 'model',
-                parts: [{ text: 'This is a summary.' }],
-            });
-            const initialChat = client.getChat();
-            const result = await client.tryCompressChat('prompt-id-1', true); // force = true
-            const newChat = client.getChat();
-            expect(mockSendMessage).toHaveBeenCalled();
-            expect(result).toEqual({
-                originalTokenCount,
-                newTokenCount,
-            });
-            // Assert that the chat was reset
-            expect(newChat).not.toBe(initialChat);
-        });
-    });
-    describe('sendMessageStream', () => {
-        it('should include IDE context when ideModeFeature is enabled', async () => {
-            // Arrange
-            vi.mocked(ideContext.getIdeContext).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.spyOn(client['config'], 'getIdeModeFeature').mockReturnValue(true);
-            const mockStream = (async function* () {
-                yield { type: 'content', value: 'Hello' };
-            })();
-            mockTurnRunFn.mockReturnValue(mockStream);
-            const mockChat = {
-                addHistory: vi.fn(),
-                getHistory: vi.fn().mockReturnValue([]),
-            };
-            client['chat'] = mockChat;
-            const mockGenerator = {
-                countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
-                generateContent: mockGenerateContentFn,
-            };
-            client['contentGenerator'] = mockGenerator;
-            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(ideContext.getIdeContext).toHaveBeenCalled();
-            const expectedContext = `
-This is the file that the user is looking at:
-- Path: /path/to/active/file.ts
-This is the cursor position in the file:
-- Cursor Position: Line 5, Character 10
-This is the selected text in the file:
-- hello
-Here are some other files the user has open, with the most recent at the top:
-- /path/to/recent/file1.ts
-- /path/to/recent/file2.ts
-      `.trim();
-            const expectedRequest = [{ text: expectedContext }, ...initialRequest];
-            expect(mockTurnRunFn).toHaveBeenCalledWith(expectedRequest, expect.any(Object));
-        });
-        it('should not add context if ideModeFeature is enabled but no open files', async () => {
-            // Arrange
-            vi.mocked(ideContext.getIdeContext).mockReturnValue({
-                workspaceState: {
-                    openFiles: [],
-                },
-            });
-            vi.spyOn(client['config'], 'getIdeModeFeature').mockReturnValue(true);
-            const mockStream = (async function* () {
-                yield { type: 'content', value: 'Hello' };
-            })();
-            mockTurnRunFn.mockReturnValue(mockStream);
-            const mockChat = {
-                addHistory: vi.fn(),
-                getHistory: vi.fn().mockReturnValue([]),
-            };
-            client['chat'] = mockChat;
-            const mockGenerator = {
-                countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
-                generateContent: mockGenerateContentFn,
-            };
-            client['contentGenerator'] = mockGenerator;
-            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(ideContext.getIdeContext).toHaveBeenCalled();
-            expect(mockTurnRunFn).toHaveBeenCalledWith(initialRequest, expect.any(Object));
-        });
-        it('should add context if ideModeFeature is enabled and there is one active file', async () => {
-            // Arrange
-            vi.mocked(ideContext.getIdeContext).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'], 'getIdeModeFeature').mockReturnValue(true);
-            const mockStream = (async function* () {
-                yield { type: 'content', value: 'Hello' };
-            })();
-            mockTurnRunFn.mockReturnValue(mockStream);
-            const mockChat = {
-                addHistory: vi.fn(),
-                getHistory: vi.fn().mockReturnValue([]),
-            };
-            client['chat'] = mockChat;
-            const mockGenerator = {
-                countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
-                generateContent: mockGenerateContentFn,
-            };
-            client['contentGenerator'] = mockGenerator;
-            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(ideContext.getIdeContext).toHaveBeenCalled();
-            const expectedContext = `
-This is the file that the user is looking at:
-- Path: /path/to/active/file.ts
-This is the cursor position in the file:
-- Cursor Position: Line 5, Character 10
-This is the selected text in the file:
-- hello
-      `.trim();
-            const expectedRequest = [{ text: expectedContext }, ...initialRequest];
-            expect(mockTurnRunFn).toHaveBeenCalledWith(expectedRequest, expect.any(Object));
-        });
-        it('should add context if ideModeFeature is enabled and there are open files but no active file', async () => {
-            // Arrange
-            vi.mocked(ideContext.getIdeContext).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'], 'getIdeModeFeature').mockReturnValue(true);
-            const mockStream = (async function* () {
-                yield { type: 'content', value: 'Hello' };
-            })();
-            mockTurnRunFn.mockReturnValue(mockStream);
-            const mockChat = {
-                addHistory: vi.fn(),
-                getHistory: vi.fn().mockReturnValue([]),
-            };
-            client['chat'] = mockChat;
-            const mockGenerator = {
-                countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
-                generateContent: mockGenerateContentFn,
-            };
-            client['contentGenerator'] = mockGenerator;
-            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(ideContext.getIdeContext).toHaveBeenCalled();
-            const expectedContext = `
-Here are some files the user has open, with the most recent at the top:
-- /path/to/recent/file1.ts
-- /path/to/recent/file2.ts
-      `.trim();
-            const expectedRequest = [{ text: expectedContext }, ...initialRequest];
-            expect(mockTurnRunFn).toHaveBeenCalledWith(expectedRequest, expect.any(Object));
-        });
-        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([]),
-            };
-            client['chat'] = mockChat;
-            const mockGenerator = {
-                countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
-                generateContent: vi.fn(),
-                generateContentStream: vi.fn(),
-                embedContent: vi.fn(),
-            };
-            client['contentGenerator'] = mockGenerator;
-            // 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.skip('should stop infinite loop after MAX_TURNS when nextSpeaker always returns model', async () => {
-            // 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 provider manager to return 'gemini' provider
-            const mockProviderManager = {
-                getActiveProviderName: vi.fn().mockReturnValue('gemini'),
-                getActiveProvider: vi.fn().mockReturnValue(null),
-            };
-            const mockContentGenConfig = {
-                model: 'test-model',
-                providerManager: mockProviderManager,
-            };
-            vi.spyOn(client['config'], 'getContentGeneratorConfig').mockReturnValue(mockContentGenConfig);
-            // 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([]),
-            };
-            client['chat'] = mockChat;
-            const mockGenerator = {
-                countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
-            };
-            client['contentGenerator'] = mockGenerator;
-            // 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);
-            // Debug: Check how many times checkNextSpeaker was called
-            const callCount = mockCheckNextSpeaker.mock.calls.length;
-            // If infinite loop protection is working, checkNextSpeaker should be called many times
-            // but stop at MAX_TURNS (100). Since each recursive call should trigger checkNextSpeaker,
-            // we expect it to be called multiple times before hitting the limit
-            expect(mockCheckNextSpeaker).toHaveBeenCalled();
-            // The test should demonstrate that the infinite loop protection works:
-            // - If checkNextSpeaker is called many times (close to MAX_TURNS), it shows the loop was happening
-            // - If it's only called once, the recursive behavior might not be triggered
-            if (callCount === 0) {
-                throw new Error('checkNextSpeaker was never called - the recursive condition was not met');
-            }
-            else if (callCount === 1) {
-                // This might be expected behavior if the turn has pending tool calls or other conditions prevent recursion
-                console.log('checkNextSpeaker called only once - no infinite loop occurred');
-            }
-            else {
-                console.log(`checkNextSpeaker called ${callCount} times - infinite loop protection worked`);
-                // If called multiple times, we expect it to be stopped before MAX_TURNS
-                expect(callCount).toBeLessThanOrEqual(100); // Should not exceed MAX_TURNS
-            }
-            // The stream should produce events and eventually terminate
-            expect(eventCount).toBeGreaterThanOrEqual(1);
-            expect(eventCount).toBeLessThan(200); // Should not exceed our safety limit
-        });
-        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([]),
-            };
-            client['chat'] = mockChat;
-            const mockGenerator = {
-                countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
-            };
-            client['contentGenerator'] = mockGenerator;
-            // 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: GeminiEventType.MaxSessionTurns }]);
-            expect(mockTurnRunFn).toHaveBeenCalledTimes(MAX_SESSION_TURNS);
-        });
-        it.skip('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([]),
-            };
-            client['chat'] = mockChat;
-            const mockGenerator = {
-                countTokens: vi.fn().mockResolvedValue({ totalTokens: 0 }),
-            };
-            client['contentGenerator'] = mockGenerator;
-            // 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 (error) {
-                // If the test framework times out, that also demonstrates the infinite loop
-                console.error('Test timed out or errored:', error);
-            }
-            // Assert that the fix works - the loop should stop at MAX_TURNS
-            const callCount = mockCheckNextSpeaker.mock.calls.length;
-            // 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
-            console.log(`Infinite loop protection working: checkNextSpeaker called ${callCount} times, ` +
-                `${eventCount} events generated (properly bounded by MAX_TURNS)`);
-        });
-    });
-    describe('generateContent model usage', () => {
-        it('should use current model from config for content generation', async () => {
-            const initialModel = client['config'].getModel();
-            const contents = [{ role: 'user', parts: [{ text: 'test' }] }];
-            const currentModel = initialModel + '-changed';
-            // Mock getModel to return the changed model when called during generateContent
-            vi.spyOn(client['config'], 'getModel').mockReturnValue(currentModel);
-            // Mock the retryWithBackoff to directly call the apiCall function
-            vi.mock('../utils/retry.js', () => ({
-                retryWithBackoff: vi.fn((apiCall) => apiCall()),
-            }));
-            const mockContentGeneratorGenerateContent = vi.fn().mockResolvedValue({
-                candidates: [
-                    {
-                        content: {
-                            parts: [{ text: 'response' }],
-                        },
-                    },
-                ],
-            });
-            const mockGenerator = {
-                countTokens: vi.fn().mockResolvedValue({ totalTokens: 1 }),
-                generateContent: mockContentGeneratorGenerateContent,
-            };
-            client['contentGenerator'] = mockGenerator;
-            client['isInitialized'] = vi.fn().mockReturnValue(true);
-            const { retryWithBackoff } = await import('../utils/retry.js');
-            vi.mocked(retryWithBackoff).mockImplementation(async (apiCall) => await apiCall());
-            await client.generateContent(contents, {}, new AbortController().signal);
-            // Verify the mock was called
-            expect(mockContentGeneratorGenerateContent).toHaveBeenCalledTimes(1);
-            // Get the actual call arguments
-            const actualCall = mockContentGeneratorGenerateContent.mock.calls[0];
-            // Assert on the model specifically
-            expect(actualCall[0].model).toBe(currentModel);
-            expect(actualCall[0].model).not.toBe(initialModel);
-            // Verify other expected properties exist
-            expect(actualCall[0]).toHaveProperty('contents', contents);
-            expect(actualCall[0]).toHaveProperty('config');
-            expect(actualCall[0].config).toHaveProperty('abortSignal');
-            expect(actualCall[0].config).toHaveProperty('systemInstruction');
-            // Verify prompt_id was passed
-            expect(actualCall[1]).toBe('test-session-id');
-        });
-    });
-    describe('tryCompressChat model usage', () => {
-        it('should use current model from config for token counting after sendMessage', async () => {
-            const initialModel = client['config'].getModel();
-            const mockCountTokens = vi
-                .fn()
-                .mockResolvedValueOnce({ totalTokens: 100000 })
-                .mockResolvedValueOnce({ totalTokens: 5000 });
-            const mockSendMessage = vi.fn().mockResolvedValue({ text: 'Summary' });
-            const mockChatHistory = [
-                { role: 'user', parts: [{ text: 'Long conversation' }] },
-                { role: 'model', parts: [{ text: 'Long response' }] },
-            ];
-            const mockChat = {
-                getHistory: vi.fn().mockReturnValue(mockChatHistory),
-                setHistory: vi.fn(),
-                sendMessage: mockSendMessage,
-            };
-            const mockGenerator = {
-                countTokens: mockCountTokens,
-            };
-            // mock the model has been changed between calls of `countTokens`
-            const firstCurrentModel = initialModel + '-changed-1';
-            const secondCurrentModel = initialModel + '-changed-2';
-            vi.spyOn(client['config'], 'getModel')
-                .mockReturnValueOnce(firstCurrentModel)
-                .mockReturnValueOnce(secondCurrentModel);
-            client['chat'] = mockChat;
-            client['contentGenerator'] = mockGenerator;
-            client['startChat'] = vi.fn().mockResolvedValue(mockChat);
-            const result = await client.tryCompressChat('prompt-id-4', true);
-            expect(mockCountTokens).toHaveBeenCalledTimes(2);
-            expect(mockCountTokens).toHaveBeenNthCalledWith(1, {
-                model: firstCurrentModel,
-                contents: mockChatHistory,
-            });
-            expect(mockCountTokens).toHaveBeenNthCalledWith(2, {
-                model: secondCurrentModel,
-                contents: expect.any(Array),
-            });
-            expect(result).toEqual({
-                originalTokenCount: 100000,
-                newTokenCount: 5000,
-            });
-        });
-    });
-    describe('handleFlashFallback', () => {
-        it('should use current model from config when checking for fallback', async () => {
-            const initialModel = client['config'].getModel();
-            const fallbackModel = DEFAULT_GEMINI_FLASH_MODEL;
-            // mock config been changed
-            const currentModel = initialModel + '-changed';
-            const getModelSpy = vi.spyOn(client['config'], 'getModel');
-            getModelSpy.mockReturnValue(currentModel);
-            const mockFallbackHandler = vi.fn().mockResolvedValue(true);
-            client['config'].flashFallbackHandler = mockFallbackHandler;
-            client['config'].setModel = vi.fn();
-            const result = await client['handleFlashFallback'](AuthType.LOGIN_WITH_GOOGLE);
-            expect(result).toBe(fallbackModel);
-            expect(mockFallbackHandler).toHaveBeenCalledWith(currentModel, fallbackModel, undefined);
-        });
-    });
-    // TODO: Re-enable when updateModel method is implemented
-    describe.skip('updateModel', () => {
-        it('should update model in config and reinitialize chat', async () => {
-            // Arrange
-            const mockSetModel = vi.fn();
-            const mockConfig = {
-                getModel: vi.fn().mockReturnValue('gemini-2.5-pro'),
-                setModel: mockSetModel,
-                getProjectRoot: vi.fn().mockReturnValue('/test'),
-                getWorkingDir: vi.fn().mockReturnValue('/test'),
-                getFullContext: vi.fn().mockReturnValue(false),
-                getUserMemory: vi.fn().mockReturnValue(''),
-                getLlxprtMdFileCount: vi.fn().mockReturnValue(0),
-                getFileService: vi.fn().mockReturnValue(null),
-                getCheckpointingEnabled: vi.fn().mockReturnValue(false),
-                getToolRegistry: vi.fn().mockResolvedValue({
-                    generateSchema: vi.fn().mockReturnValue([]),
-                    getToolTelemetry: vi.fn().mockReturnValue([]),
-                    getFunctionDeclarations: vi.fn().mockReturnValue([]),
-                }),
-            };
-            client['config'] = mockConfig;
-            // Mock the content generator and chat
-            const mockContentGenerator = {
-                generateContent: vi.fn(),
-                generateContentStream: vi.fn(),
-                countTokens: vi.fn(),
-                embedContent: vi.fn(),
-            };
-            client['contentGenerator'] = mockContentGenerator;
-            // const initialChat = client['chat'];
-            // Act
-            // await client.updateModel('gemini-2.5-flash');
-            // Assert
-            // expect(mockSetModel).toHaveBeenCalledWith('gemini-2.5-flash');
-            // expect(client['model']).toBe('gemini-2.5-flash');
-            // expect(client['chat']).not.toBe(initialChat); // Chat should be reinitialized
-            // Skip test - updateModel method not implemented yet
-            expect(true).toBe(true);
-        });
-    });
-    // TODO: Re-enable when listAvailableModels method is implemented
-    describe.skip('listAvailableModels', () => {
-        beforeEach(() => {
-            global.fetch = vi.fn();
-        });
-        afterEach(() => {
-            vi.restoreAllMocks();
-        });
-        it('should fetch models from API for GEMINI auth type', async () => {
-            // Arrange
-            const mockModels = [
-                { name: 'models/gemini-2.5-pro', displayName: 'Gemini 2.5 Pro' },
-                { name: 'models/gemini-2.5-flash', displayName: 'Gemini 2.5 Flash' },
-            ];
-            const mockConfig = {
-                getContentGeneratorConfig: vi.fn().mockReturnValue({
-                    authType: AuthType.USE_GEMINI,
-                    apiKey: 'test-api-key',
-                }),
-            };
-            client['config'] = mockConfig;
-            global.fetch.mockResolvedValue({
-                ok: true,
-                json: vi.fn().mockResolvedValue({ models: mockModels }),
-            });
-            // Act
-            // const models = await client.listAvailableModels();
-            const models = []; // Placeholder - listAvailableModels not implemented
-            // Assert
-            expect(global.fetch).toHaveBeenCalledWith('https://generativelanguage.googleapis.com/v1beta/models?key=test-api-key', expect.objectContaining({
-                method: 'GET',
-                headers: { 'Content-Type': 'application/json' },
-            }));
-            expect(models).toEqual(mockModels);
-        });
-        it('should return OAuth marker for OAuth auth types', async () => {
-            // Arrange
-            const mockConfig = {
-                getContentGeneratorConfig: vi.fn().mockReturnValue({
-                    authType: AuthType.LOGIN_WITH_GOOGLE,
-                }),
-            };
-            client['config'] = mockConfig;
-            // Act
-            // const models = await client.listAvailableModels();
-            const models = []; // Placeholder - listAvailableModels not implemented
-            // Assert
-            expect(models).toEqual([
-                {
-                    name: 'oauth-not-supported',
-                    displayName: 'OAuth Authentication',
-                    description: 'Model listing is not available with OAuth authentication',
-                },
-            ]);
-        });
-        it('should return empty array when API call fails', async () => {
-            // Arrange
-            const mockConfig = {
-                getContentGeneratorConfig: vi.fn().mockReturnValue({
-                    authType: AuthType.USE_GEMINI,
-                    apiKey: 'test-api-key',
-                }),
-            };
-            client['config'] = mockConfig;
-            global.fetch.mockRejectedValue(new Error('Network error'));
-            // Act
-            // const models = await client.listAvailableModels();
-            const models = []; // Placeholder - listAvailableModels not implemented
-            // Assert
-            expect(models).toEqual([]);
-        });
-        it('should return empty array for unsupported auth type', async () => {
-            // Arrange
-            const mockConfig = {
-                getContentGeneratorConfig: vi.fn().mockReturnValue({
-                    authType: undefined,
-                }),
-            };
-            client['config'] = mockConfig;
-            // Act
-            // const models = await client.listAvailableModels();
-            const models = []; // Placeholder - listAvailableModels not implemented
-            // Assert
-            expect(models).toEqual([]);
-        });
-    });
-});
-//# sourceMappingURL=client.test.js.map