@google/gemini-cli-core 0.0.3-preview.4 → 0.0.4

package/dist/src/config/config.test.js

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { Config, ApprovalMode } from './config.js';
 import * as path from 'node:path';
 import { setGeminiMdFilename as mockSetGeminiMdFilename } from '../tools/memoryTool.js';
@@ -14,6 +14,11 @@ import { GitService } from '../services/gitService.js';
 import { ClearcutLogger } from '../telemetry/clearcut-logger/clearcut-logger.js';
 import { ShellTool } from '../tools/shell.js';
 import { ReadFileTool } from '../tools/read-file.js';
+import { GrepTool } from '../tools/grep.js';
+import { RipGrepTool, canUseRipgrep } from '../tools/ripGrep.js';
+import { logRipgrepFallback } from '../telemetry/loggers.js';
+import { RipgrepFallbackEvent } from '../telemetry/types.js';
+import { ToolRegistry } from '../tools/tool-registry.js';
 vi.mock('fs', async (importOriginal) => {
     const actual = await importOriginal();
     return {
@@ -41,7 +46,12 @@ vi.mock('../utils/memoryDiscovery.js', () => ({
 // Mock individual tools if their constructors are complex or have side effects
 vi.mock('../tools/ls');
 vi.mock('../tools/read-file');
-vi.mock('../tools/grep');
+vi.mock('../tools/grep.js');
+vi.mock('../tools/ripGrep.js', () => ({
+    canUseRipgrep: vi.fn(),
+    RipGrepTool: class MockRipGrepTool {
+    },
+}));
 vi.mock('../tools/glob');
 vi.mock('../tools/edit');
 vi.mock('../tools/shell');
@@ -55,16 +65,11 @@ vi.mock('../tools/memoryTool', () => ({
     DEFAULT_CONTEXT_FILENAME: 'GEMINI.md',
     GEMINI_CONFIG_DIR: '.gemini',
 }));
-vi.mock('../core/contentGenerator.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        createContentGeneratorConfig: vi.fn(),
-    };
-});
+vi.mock('../core/contentGenerator.js');
 vi.mock('../core/client.js', () => ({
     GeminiClient: vi.fn().mockImplementation(() => ({
         initialize: vi.fn().mockResolvedValue(undefined),
+        stripThoughtsFromHistory: vi.fn(),
     })),
 }));
 vi.mock('../telemetry/index.js', async (importOriginal) => {
@@ -72,6 +77,16 @@ vi.mock('../telemetry/index.js', async (importOriginal) => {
     return {
         ...actual,
         initializeTelemetry: vi.fn(),
+        uiTelemetryService: {
+            getLastPromptTokenCount: vi.fn(),
+        },
+    };
+});
+vi.mock('../telemetry/loggers.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        logRipgrepFallback: vi.fn(),
     };
 });
 vi.mock('../services/gitService.js', () => {
@@ -79,6 +94,22 @@ vi.mock('../services/gitService.js', () => {
     GitServiceMock.prototype.initialize = vi.fn();
     return { GitService: GitServiceMock };
 });
+vi.mock('../ide/ide-client.js', () => ({
+    IdeClient: {
+        getInstance: vi.fn().mockResolvedValue({
+            getConnectionStatus: vi.fn(),
+            initialize: vi.fn(),
+            shutdown: vi.fn(),
+        }),
+    },
+}));
+import { BaseLlmClient } from '../core/baseLlmClient.js';
+import { tokenLimit } from '../core/tokenLimits.js';
+import { uiTelemetryService } from '../telemetry/index.js';
+vi.mock('../core/baseLlmClient.js');
+vi.mock('../core/tokenLimits.js', () => ({
+    tokenLimit: vi.fn(),
+}));
 describe('Server Config (config.ts)', () => {
     const MODEL = 'gemini-pro';
     const SANDBOX = {
@@ -144,144 +175,34 @@ describe('Server Config (config.ts)', () => {
         it('should refresh auth and update config', async () => {
             const config = new Config(baseParams);
             const authType = AuthType.USE_GEMINI;
-            const newModel = 'gemini-flash';
             const mockContentConfig = {
-                model: newModel,
                 apiKey: 'test-key',
             };
-            createContentGeneratorConfig.mockReturnValue(mockContentConfig);
+            vi.mocked(createContentGeneratorConfig).mockReturnValue(mockContentConfig);
             // Set fallback mode to true to ensure it gets reset
             config.setFallbackMode(true);
             expect(config.isInFallbackMode()).toBe(true);
             await config.refreshAuth(authType);
             expect(createContentGeneratorConfig).toHaveBeenCalledWith(config, authType);
-            // Verify that contentGeneratorConfig is updated with the new model
+            // Verify that contentGeneratorConfig is updated
             expect(config.getContentGeneratorConfig()).toEqual(mockContentConfig);
-            expect(config.getContentGeneratorConfig().model).toBe(newModel);
-            expect(config.getModel()).toBe(newModel); // getModel() should return the updated model
             expect(GeminiClient).toHaveBeenCalledWith(config);
             // Verify that fallback mode is reset
             expect(config.isInFallbackMode()).toBe(false);
         });
-        it('should preserve conversation history when refreshing auth', async () => {
-            const config = new Config(baseParams);
-            const authType = AuthType.USE_GEMINI;
-            const mockContentConfig = {
-                model: 'gemini-pro',
-                apiKey: 'test-key',
-            };
-            createContentGeneratorConfig.mockReturnValue(mockContentConfig);
-            // Mock the existing client with some history
-            const mockExistingHistory = [
-                { role: 'user', parts: [{ text: 'Hello' }] },
-                { role: 'model', parts: [{ text: 'Hi there!' }] },
-                { role: 'user', parts: [{ text: 'How are you?' }] },
-            ];
-            const mockExistingClient = {
-                isInitialized: vi.fn().mockReturnValue(true),
-                getHistory: vi.fn().mockReturnValue(mockExistingHistory),
-            };
-            const mockNewClient = {
-                isInitialized: vi.fn().mockReturnValue(true),
-                getHistory: vi.fn().mockReturnValue([]),
-                setHistory: vi.fn(),
-                initialize: vi.fn().mockResolvedValue(undefined),
-            };
-            // Set the existing client
-            config.geminiClient = mockExistingClient;
-            GeminiClient.mockImplementation(() => mockNewClient);
-            await config.refreshAuth(authType);
-            // Verify that existing history was retrieved
-            expect(mockExistingClient.getHistory).toHaveBeenCalled();
-            // Verify that new client was created and initialized
-            expect(GeminiClient).toHaveBeenCalledWith(config);
-            expect(mockNewClient.initialize).toHaveBeenCalledWith(mockContentConfig);
-            // Verify that history was restored to the new client
-            expect(mockNewClient.setHistory).toHaveBeenCalledWith(mockExistingHistory, { stripThoughts: false });
-        });
-        it('should handle case when no existing client is initialized', async () => {
-            const config = new Config(baseParams);
-            const authType = AuthType.USE_GEMINI;
-            const mockContentConfig = {
-                model: 'gemini-pro',
-                apiKey: 'test-key',
-            };
-            createContentGeneratorConfig.mockReturnValue(mockContentConfig);
-            const mockNewClient = {
-                isInitialized: vi.fn().mockReturnValue(true),
-                getHistory: vi.fn().mockReturnValue([]),
-                setHistory: vi.fn(),
-                initialize: vi.fn().mockResolvedValue(undefined),
-            };
-            // No existing client
-            config.geminiClient = null;
-            GeminiClient.mockImplementation(() => mockNewClient);
-            await config.refreshAuth(authType);
-            // Verify that new client was created and initialized
-            expect(GeminiClient).toHaveBeenCalledWith(config);
-            expect(mockNewClient.initialize).toHaveBeenCalledWith(mockContentConfig);
-            // Verify that setHistory was not called since there was no existing history
-            expect(mockNewClient.setHistory).not.toHaveBeenCalled();
-        });
         it('should strip thoughts when switching from GenAI to Vertex', async () => {
             const config = new Config(baseParams);
-            const mockContentConfig = {
-                model: 'gemini-pro',
-                apiKey: 'test-key',
-                authType: AuthType.USE_GEMINI,
-            };
-            config.contentGeneratorConfig = mockContentConfig;
-            createContentGeneratorConfig.mockReturnValue({
-                ...mockContentConfig,
-                authType: AuthType.LOGIN_WITH_GOOGLE,
-            });
-            const mockExistingHistory = [
-                { role: 'user', parts: [{ text: 'Hello' }] },
-            ];
-            const mockExistingClient = {
-                isInitialized: vi.fn().mockReturnValue(true),
-                getHistory: vi.fn().mockReturnValue(mockExistingHistory),
-            };
-            const mockNewClient = {
-                isInitialized: vi.fn().mockReturnValue(true),
-                getHistory: vi.fn().mockReturnValue([]),
-                setHistory: vi.fn(),
-                initialize: vi.fn().mockResolvedValue(undefined),
-            };
-            config.geminiClient = mockExistingClient;
-            GeminiClient.mockImplementation(() => mockNewClient);
+            vi.mocked(createContentGeneratorConfig).mockImplementation((_, authType) => ({ authType }));
+            await config.refreshAuth(AuthType.USE_GEMINI);
             await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
-            expect(mockNewClient.setHistory).toHaveBeenCalledWith(mockExistingHistory, { stripThoughts: true });
+            expect(config.getGeminiClient().stripThoughtsFromHistory).toHaveBeenCalledWith();
         });
         it('should not strip thoughts when switching from Vertex to GenAI', async () => {
             const config = new Config(baseParams);
-            const mockContentConfig = {
-                model: 'gemini-pro',
-                apiKey: 'test-key',
-                authType: AuthType.LOGIN_WITH_GOOGLE,
-            };
-            config.contentGeneratorConfig = mockContentConfig;
-            createContentGeneratorConfig.mockReturnValue({
-                ...mockContentConfig,
-                authType: AuthType.USE_GEMINI,
-            });
-            const mockExistingHistory = [
-                { role: 'user', parts: [{ text: 'Hello' }] },
-            ];
-            const mockExistingClient = {
-                isInitialized: vi.fn().mockReturnValue(true),
-                getHistory: vi.fn().mockReturnValue(mockExistingHistory),
-            };
-            const mockNewClient = {
-                isInitialized: vi.fn().mockReturnValue(true),
-                getHistory: vi.fn().mockReturnValue([]),
-                setHistory: vi.fn(),
-                initialize: vi.fn().mockResolvedValue(undefined),
-            };
-            config.geminiClient = mockExistingClient;
-            GeminiClient.mockImplementation(() => mockNewClient);
+            vi.mocked(createContentGeneratorConfig).mockImplementation((_, authType) => ({ authType }));
+            await config.refreshAuth(AuthType.USE_VERTEX_AI);
             await config.refreshAuth(AuthType.USE_GEMINI);
-            expect(mockNewClient.setHistory).toHaveBeenCalledWith(mockExistingHistory, { stripThoughts: false });
+            expect(config.getGeminiClient().stripThoughtsFromHistory).not.toHaveBeenCalledWith();
         });
     });
     it('Config constructor should store userMemory correctly', () => {
@@ -360,6 +281,30 @@ describe('Server Config (config.ts)', () => {
         const config = new Config(paramsWithoutTelemetry);
         expect(config.getTelemetryEnabled()).toBe(TELEMETRY_SETTINGS.enabled);
     });
+    it('Config constructor should set telemetry useCollector to true when provided', () => {
+        const paramsWithTelemetry = {
+            ...baseParams,
+            telemetry: { enabled: true, useCollector: true },
+        };
+        const config = new Config(paramsWithTelemetry);
+        expect(config.getTelemetryUseCollector()).toBe(true);
+    });
+    it('Config constructor should set telemetry useCollector to false when provided', () => {
+        const paramsWithTelemetry = {
+            ...baseParams,
+            telemetry: { enabled: true, useCollector: false },
+        };
+        const config = new Config(paramsWithTelemetry);
+        expect(config.getTelemetryUseCollector()).toBe(false);
+    });
+    it('Config constructor should default telemetry useCollector to false if not provided', () => {
+        const paramsWithTelemetry = {
+            ...baseParams,
+            telemetry: { enabled: true },
+        };
+        const config = new Config(paramsWithTelemetry);
+        expect(config.getTelemetryUseCollector()).toBe(false);
+    });
     it('should have a getFileService method that returns FileDiscoveryService', () => {
         const config = new Config(baseParams);
         const fileService = config.getFileService();
@@ -385,7 +330,7 @@ describe('Server Config (config.ts)', () => {
                 ...baseParams,
                 usageStatisticsEnabled: true,
             });
-            await config.initialize();
+            await config.refreshAuth(AuthType.USE_GEMINI);
             expect(ClearcutLogger.prototype.logStartSessionEvent).toHaveBeenCalledOnce();
         });
     });
@@ -473,33 +418,55 @@ describe('Server Config (config.ts)', () => {
         });
     });
     describe('UseRipgrep Configuration', () => {
-        it('should default useRipgrep to false when not provided', () => {
+        it('should default useRipgrep to true when not provided', () => {
             const config = new Config(baseParams);
-            expect(config.getUseRipgrep()).toBe(false);
+            expect(config.getUseRipgrep()).toBe(true);
         });
-        it('should set useRipgrep to true when provided as true', () => {
+        it('should set useRipgrep to false when provided as false', () => {
             const paramsWithRipgrep = {
                 ...baseParams,
-                useRipgrep: true,
+                useRipgrep: false,
             };
             const config = new Config(paramsWithRipgrep);
-            expect(config.getUseRipgrep()).toBe(true);
+            expect(config.getUseRipgrep()).toBe(false);
         });
-        it('should set useRipgrep to false when explicitly provided as false', () => {
+        it('should set useRipgrep to true when explicitly provided as true', () => {
             const paramsWithRipgrep = {
                 ...baseParams,
-                useRipgrep: false,
+                useRipgrep: true,
             };
             const config = new Config(paramsWithRipgrep);
-            expect(config.getUseRipgrep()).toBe(false);
+            expect(config.getUseRipgrep()).toBe(true);
         });
-        it('should default useRipgrep to false when undefined', () => {
+        it('should default useRipgrep to true when undefined', () => {
             const paramsWithUndefinedRipgrep = {
                 ...baseParams,
                 useRipgrep: undefined,
             };
             const config = new Config(paramsWithUndefinedRipgrep);
-            expect(config.getUseRipgrep()).toBe(false);
+            expect(config.getUseRipgrep()).toBe(true);
+        });
+    });
+    describe('UseModelRouter Configuration', () => {
+        it('should default useModelRouter to false when not provided', () => {
+            const config = new Config(baseParams);
+            expect(config.getUseModelRouter()).toBe(false);
+        });
+        it('should set useModelRouter to true when provided as true', () => {
+            const paramsWithModelRouter = {
+                ...baseParams,
+                useModelRouter: true,
+            };
+            const config = new Config(paramsWithModelRouter);
+            expect(config.getUseModelRouter()).toBe(true);
+        });
+        it('should set useModelRouter to false when explicitly provided as false', () => {
+            const paramsWithModelRouter = {
+                ...baseParams,
+                useModelRouter: false,
+            };
+            const config = new Config(paramsWithModelRouter);
+            expect(config.getUseModelRouter()).toBe(false);
         });
     });
     describe('createToolRegistry', () => {
@@ -519,67 +486,227 @@ describe('Server Config (config.ts)', () => {
             const wasReadFileToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ReadFileTool));
             expect(wasReadFileToolRegistered).toBe(false);
         });
+        describe('with minified tool class names', () => {
+            beforeEach(() => {
+                Object.defineProperty(vi.mocked(ShellTool).prototype.constructor, 'name', {
+                    value: '_ShellTool',
+                    configurable: true,
+                });
+            });
+            afterEach(() => {
+                Object.defineProperty(vi.mocked(ShellTool).prototype.constructor, 'name', {
+                    value: 'ShellTool',
+                });
+            });
+            it('should register a tool if coreTools contains the non-minified class name', async () => {
+                const params = {
+                    ...baseParams,
+                    coreTools: ['ShellTool'],
+                };
+                const config = new Config(params);
+                await config.initialize();
+                const registerToolMock = (await vi.importMock('../tools/tool-registry')).ToolRegistry.prototype.registerTool;
+                const wasShellToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ShellTool));
+                expect(wasShellToolRegistered).toBe(true);
+            });
+            it('should not register a tool if excludeTools contains the non-minified class name', async () => {
+                const params = {
+                    ...baseParams,
+                    coreTools: undefined, // all tools enabled by default
+                    excludeTools: ['ShellTool'],
+                };
+                const config = new Config(params);
+                await config.initialize();
+                const registerToolMock = (await vi.importMock('../tools/tool-registry')).ToolRegistry.prototype.registerTool;
+                const wasShellToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ShellTool));
+                expect(wasShellToolRegistered).toBe(false);
+            });
+            it('should register a tool if coreTools contains an argument-specific pattern with the non-minified class name', async () => {
+                const params = {
+                    ...baseParams,
+                    coreTools: ['ShellTool(git status)'],
+                };
+                const config = new Config(params);
+                await config.initialize();
+                const registerToolMock = (await vi.importMock('../tools/tool-registry')).ToolRegistry.prototype.registerTool;
+                const wasShellToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ShellTool));
+                expect(wasShellToolRegistered).toBe(true);
+            });
+        });
+    });
+    describe('getTruncateToolOutputThreshold', () => {
+        beforeEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should return the calculated threshold when it is smaller than the default', () => {
+            const config = new Config(baseParams);
+            vi.mocked(tokenLimit).mockReturnValue(32000);
+            vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(1000);
+            // 4 * (32000 - 1000) = 4 * 31000 = 124000
+            // default is 4_000_000
+            expect(config.getTruncateToolOutputThreshold()).toBe(124000);
+        });
+        it('should return the default threshold when the calculated value is larger', () => {
+            const config = new Config(baseParams);
+            vi.mocked(tokenLimit).mockReturnValue(2_000_000);
+            vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(500_000);
+            // 4 * (2_000_000 - 500_000) = 4 * 1_500_000 = 6_000_000
+            // default is 4_000_000
+            expect(config.getTruncateToolOutputThreshold()).toBe(4_000_000);
+        });
+        it('should use a custom truncateToolOutputThreshold if provided', () => {
+            const customParams = {
+                ...baseParams,
+                truncateToolOutputThreshold: 50000,
+            };
+            const config = new Config(customParams);
+            vi.mocked(tokenLimit).mockReturnValue(8000);
+            vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(2000);
+            // 4 * (8000 - 2000) = 4 * 6000 = 24000
+            // custom threshold is 50000
+            expect(config.getTruncateToolOutputThreshold()).toBe(24000);
+            vi.mocked(tokenLimit).mockReturnValue(32000);
+            vi.mocked(uiTelemetryService.getLastPromptTokenCount).mockReturnValue(1000);
+            // 4 * (32000 - 1000) = 124000
+            // custom threshold is 50000
+            expect(config.getTruncateToolOutputThreshold()).toBe(50000);
+        });
     });
 });
 describe('setApprovalMode with folder trust', () => {
+    const baseParams = {
+        sessionId: 'test',
+        targetDir: '.',
+        debugMode: false,
+        model: 'test-model',
+        cwd: '.',
+    };
     it('should throw an error when setting YOLO mode in an untrusted folder', () => {
-        const config = new Config({
-            sessionId: 'test',
-            targetDir: '.',
-            debugMode: false,
-            model: 'test-model',
-            cwd: '.',
-            trustedFolder: false, // Untrusted
-        });
+        const config = new Config(baseParams);
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(false);
         expect(() => config.setApprovalMode(ApprovalMode.YOLO)).toThrow('Cannot enable privileged approval modes in an untrusted folder.');
     });
     it('should throw an error when setting AUTO_EDIT mode in an untrusted folder', () => {
-        const config = new Config({
-            sessionId: 'test',
-            targetDir: '.',
-            debugMode: false,
-            model: 'test-model',
-            cwd: '.',
-            trustedFolder: false, // Untrusted
-        });
+        const config = new Config(baseParams);
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(false);
         expect(() => config.setApprovalMode(ApprovalMode.AUTO_EDIT)).toThrow('Cannot enable privileged approval modes in an untrusted folder.');
     });
     it('should NOT throw an error when setting DEFAULT mode in an untrusted folder', () => {
-        const config = new Config({
-            sessionId: 'test',
-            targetDir: '.',
-            debugMode: false,
-            model: 'test-model',
-            cwd: '.',
-            trustedFolder: false, // Untrusted
-        });
+        const config = new Config(baseParams);
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(false);
         expect(() => config.setApprovalMode(ApprovalMode.DEFAULT)).not.toThrow();
     });
     it('should NOT throw an error when setting any mode in a trusted folder', () => {
-        const config = new Config({
-            sessionId: 'test',
-            targetDir: '.',
-            debugMode: false,
-            model: 'test-model',
-            cwd: '.',
-            trustedFolder: true, // Trusted
-        });
+        const config = new Config(baseParams);
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
         expect(() => config.setApprovalMode(ApprovalMode.YOLO)).not.toThrow();
         expect(() => config.setApprovalMode(ApprovalMode.AUTO_EDIT)).not.toThrow();
         expect(() => config.setApprovalMode(ApprovalMode.DEFAULT)).not.toThrow();
     });
     it('should NOT throw an error when setting any mode if trustedFolder is undefined', () => {
-        const config = new Config({
-            sessionId: 'test',
-            targetDir: '.',
-            debugMode: false,
-            model: 'test-model',
-            cwd: '.',
-            trustedFolder: undefined, // Undefined
-        });
+        const config = new Config(baseParams);
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true); // isTrustedFolder defaults to true
         expect(() => config.setApprovalMode(ApprovalMode.YOLO)).not.toThrow();
         expect(() => config.setApprovalMode(ApprovalMode.AUTO_EDIT)).not.toThrow();
         expect(() => config.setApprovalMode(ApprovalMode.DEFAULT)).not.toThrow();
     });
+    describe('registerCoreTools', () => {
+        beforeEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should register RipGrepTool when useRipgrep is true and it is available', async () => {
+            canUseRipgrep.mockResolvedValue(true);
+            const config = new Config({ ...baseParams, useRipgrep: true });
+            await config.initialize();
+            const calls = ToolRegistry.prototype.registerTool.mock.calls;
+            const wasRipGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(RipGrepTool));
+            const wasGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(GrepTool));
+            expect(wasRipGrepRegistered).toBe(true);
+            expect(wasGrepRegistered).toBe(false);
+            expect(logRipgrepFallback).not.toHaveBeenCalled();
+        });
+        it('should register GrepTool as a fallback when useRipgrep is true but it is not available', async () => {
+            canUseRipgrep.mockResolvedValue(false);
+            const config = new Config({ ...baseParams, useRipgrep: true });
+            await config.initialize();
+            const calls = ToolRegistry.prototype.registerTool.mock.calls;
+            const wasRipGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(RipGrepTool));
+            const wasGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(GrepTool));
+            expect(wasRipGrepRegistered).toBe(false);
+            expect(wasGrepRegistered).toBe(true);
+            expect(logRipgrepFallback).toHaveBeenCalledWith(config, expect.any(RipgrepFallbackEvent));
+            const event = logRipgrepFallback.mock.calls[0][1];
+            expect(event.error).toBeUndefined();
+        });
+        it('should register GrepTool as a fallback when canUseRipgrep throws an error', async () => {
+            const error = new Error('ripGrep check failed');
+            canUseRipgrep.mockRejectedValue(error);
+            const config = new Config({ ...baseParams, useRipgrep: true });
+            await config.initialize();
+            const calls = ToolRegistry.prototype.registerTool.mock.calls;
+            const wasRipGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(RipGrepTool));
+            const wasGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(GrepTool));
+            expect(wasRipGrepRegistered).toBe(false);
+            expect(wasGrepRegistered).toBe(true);
+            expect(logRipgrepFallback).toHaveBeenCalledWith(config, expect.any(RipgrepFallbackEvent));
+            const event = logRipgrepFallback.mock.calls[0][1];
+            expect(event.error).toBe(String(error));
+        });
+        it('should register GrepTool when useRipgrep is false', async () => {
+            const config = new Config({ ...baseParams, useRipgrep: false });
+            await config.initialize();
+            const calls = ToolRegistry.prototype.registerTool.mock.calls;
+            const wasRipGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(RipGrepTool));
+            const wasGrepRegistered = calls.some((call) => call[0] instanceof vi.mocked(GrepTool));
+            expect(wasRipGrepRegistered).toBe(false);
+            expect(wasGrepRegistered).toBe(true);
+            expect(canUseRipgrep).not.toHaveBeenCalled();
+            expect(logRipgrepFallback).not.toHaveBeenCalled();
+        });
+    });
+});
+describe('BaseLlmClient Lifecycle', () => {
+    const MODEL = 'gemini-pro';
+    const SANDBOX = {
+        command: 'docker',
+        image: 'gemini-cli-sandbox',
+    };
+    const TARGET_DIR = '/path/to/target';
+    const DEBUG_MODE = false;
+    const QUESTION = 'test question';
+    const FULL_CONTEXT = false;
+    const USER_MEMORY = 'Test User Memory';
+    const TELEMETRY_SETTINGS = { enabled: false };
+    const EMBEDDING_MODEL = 'gemini-embedding';
+    const SESSION_ID = 'test-session-id';
+    const baseParams = {
+        cwd: '/tmp',
+        embeddingModel: EMBEDDING_MODEL,
+        sandbox: SANDBOX,
+        targetDir: TARGET_DIR,
+        debugMode: DEBUG_MODE,
+        question: QUESTION,
+        fullContext: FULL_CONTEXT,
+        userMemory: USER_MEMORY,
+        telemetry: TELEMETRY_SETTINGS,
+        sessionId: SESSION_ID,
+        model: MODEL,
+        usageStatisticsEnabled: false,
+    };
+    it('should throw an error if getBaseLlmClient is called before refreshAuth', () => {
+        const config = new Config(baseParams);
+        expect(() => config.getBaseLlmClient()).toThrow('BaseLlmClient not initialized. Ensure authentication has occurred and ContentGenerator is ready.');
+    });
+    it('should successfully initialize BaseLlmClient after refreshAuth is called', async () => {
+        const config = new Config(baseParams);
+        const authType = AuthType.USE_GEMINI;
+        const mockContentConfig = { model: 'gemini-flash', apiKey: 'test-key' };
+        vi.mocked(createContentGeneratorConfig).mockReturnValue(mockContentConfig);
+        await config.refreshAuth(authType);
+        // Should not throw
+        const llmService = config.getBaseLlmClient();
+        expect(llmService).toBeDefined();
+        expect(BaseLlmClient).toHaveBeenCalledWith(config.getContentGenerator(), config);
+    });
 });
 //# sourceMappingURL=config.test.js.map