@google/gemini-cli-core 0.30.0-preview.6 → 0.31.0-preview.0

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

@@ -5,6 +5,7 @@
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { Config, DEFAULT_FILE_FILTERING_OPTIONS } from './config.js';
+import { DEFAULT_MAX_ATTEMPTS } from '../utils/retry.js';
 import { ExperimentFlags } from '../code_assist/experiments/flagNames.js';
 import { debugLogger } from '../utils/debugLogger.js';
 import { ApprovalMode } from '../policy/types.js';
@@ -13,7 +14,7 @@ import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { setGeminiMdFilename as mockSetGeminiMdFilename } from '../tools/memoryTool.js';
-import { DEFAULT_TELEMETRY_TARGET, DEFAULT_OTLP_ENDPOINT, } from '../telemetry/index.js';
+import { DEFAULT_TELEMETRY_TARGET, DEFAULT_OTLP_ENDPOINT, uiTelemetryService, } from '../telemetry/index.js';
 import { AuthType, createContentGenerator, createContentGeneratorConfig, } from '../core/contentGenerator.js';
 import { GeminiClient } from '../core/client.js';
 import { GitService } from '../services/gitService.js';
@@ -21,12 +22,12 @@ 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 { logRipgrepFallback, logApprovalModeDuration, } from '../telemetry/loggers.js';
 import { RipgrepFallbackEvent } from '../telemetry/types.js';
 import { ToolRegistry } from '../tools/tool-registry.js';
 import { ACTIVATE_SKILL_TOOL_NAME } from '../tools/tool-names.js';
 import { DEFAULT_MODEL_CONFIGS } from './defaultModelConfigs.js';
-import { DEFAULT_GEMINI_MODEL } from './models.js';
+import { DEFAULT_GEMINI_MODEL, PREVIEW_GEMINI_3_1_MODEL, DEFAULT_GEMINI_MODEL_AUTO, } from './models.js';
 import { Storage } from './storage.js';
 vi.mock('fs', async (importOriginal) => {
     const actual = await importOriginal();
@@ -107,6 +108,7 @@ vi.mock('../telemetry/loggers.js', async (importOriginal) => {
     return {
         ...actual,
         logRipgrepFallback: vi.fn(),
+        logApprovalModeDuration: vi.fn(),
     };
 });
 vi.mock('../services/gitService.js', () => {
@@ -166,7 +168,6 @@ vi.mock('../services/contextManager.js', () => ({
 }));
 import { BaseLlmClient } from '../core/baseLlmClient.js';
 import { tokenLimit } from '../core/tokenLimits.js';
-import { uiTelemetryService } from '../telemetry/index.js';
 import { getCodeAssistServer } from '../code_assist/codeAssist.js';
 import { getExperiments } from '../code_assist/experiments/experiments.js';
 import { ContextManager } from '../services/contextManager.js';
@@ -205,6 +206,26 @@ describe('Server Config (config.ts)', () => {
         model: MODEL,
         usageStatisticsEnabled: false,
     };
+    describe('maxAttempts', () => {
+        it('should default to DEFAULT_MAX_ATTEMPTS', () => {
+            const config = new Config(baseParams);
+            expect(config.getMaxAttempts()).toBe(DEFAULT_MAX_ATTEMPTS);
+        });
+        it('should use provided maxAttempts if <= DEFAULT_MAX_ATTEMPTS', () => {
+            const config = new Config({
+                ...baseParams,
+                maxAttempts: 5,
+            });
+            expect(config.getMaxAttempts()).toBe(5);
+        });
+        it('should cap maxAttempts at DEFAULT_MAX_ATTEMPTS', () => {
+            const config = new Config({
+                ...baseParams,
+                maxAttempts: 20,
+            });
+            expect(config.getMaxAttempts()).toBe(DEFAULT_MAX_ATTEMPTS);
+        });
+    });
     beforeEach(() => {
         // Reset mocks if necessary
         vi.clearAllMocks();
@@ -577,6 +598,36 @@ describe('Server Config (config.ts)', () => {
             expect(config.getUsageStatisticsEnabled()).toBe(enabled);
         });
     });
+    describe('Plan Settings', () => {
+        const testCases = [
+            {
+                name: 'should pass custom plan directory to storage',
+                planSettings: { directory: 'custom-plans' },
+                expected: 'custom-plans',
+            },
+            {
+                name: 'should call setCustomPlansDir with undefined if directory is not provided',
+                planSettings: {},
+                expected: undefined,
+            },
+            {
+                name: 'should call setCustomPlansDir with undefined if planSettings is not provided',
+                planSettings: undefined,
+                expected: undefined,
+            },
+        ];
+        testCases.forEach(({ name, planSettings, expected }) => {
+            it(`${name}`, () => {
+                const setCustomPlansDirSpy = vi.spyOn(Storage.prototype, 'setCustomPlansDir');
+                new Config({
+                    ...baseParams,
+                    planSettings,
+                });
+                expect(setCustomPlansDirSpy).toHaveBeenCalledWith(expected);
+                setCustomPlansDirSpy.mockRestore();
+            });
+        });
+    });
     describe('Telemetry Settings', () => {
         it('should return default telemetry target if not provided', () => {
             const params = {
@@ -970,6 +1021,66 @@ describe('Server Config (config.ts)', () => {
             expect(mockCoreEvents.emitFeedback).not.toHaveBeenCalled();
         });
     });
+    describe('BrowserAgentConfig', () => {
+        it('should return default browser agent config when not provided', () => {
+            const config = new Config(baseParams);
+            const browserConfig = config.getBrowserAgentConfig();
+            expect(browserConfig.enabled).toBe(false);
+            expect(browserConfig.model).toBeUndefined();
+            expect(browserConfig.customConfig.sessionMode).toBe('persistent');
+            expect(browserConfig.customConfig.headless).toBe(false);
+            expect(browserConfig.customConfig.profilePath).toBeUndefined();
+            expect(browserConfig.customConfig.visualModel).toBeUndefined();
+        });
+        it('should return custom browser agent config from agents.overrides', () => {
+            const params = {
+                ...baseParams,
+                agents: {
+                    overrides: {
+                        browser_agent: {
+                            enabled: true,
+                            modelConfig: { model: 'custom-model' },
+                        },
+                    },
+                    browser: {
+                        sessionMode: 'existing',
+                        headless: true,
+                        profilePath: '/path/to/profile',
+                        visualModel: 'custom-visual-model',
+                    },
+                },
+            };
+            const config = new Config(params);
+            const browserConfig = config.getBrowserAgentConfig();
+            expect(browserConfig.enabled).toBe(true);
+            expect(browserConfig.model).toBe('custom-model');
+            expect(browserConfig.customConfig.sessionMode).toBe('existing');
+            expect(browserConfig.customConfig.headless).toBe(true);
+            expect(browserConfig.customConfig.profilePath).toBe('/path/to/profile');
+            expect(browserConfig.customConfig.visualModel).toBe('custom-visual-model');
+        });
+        it('should apply defaults for partial custom config', () => {
+            const params = {
+                ...baseParams,
+                agents: {
+                    overrides: {
+                        browser_agent: {
+                            enabled: true,
+                        },
+                    },
+                    browser: {
+                        headless: true,
+                    },
+                },
+            };
+            const config = new Config(params);
+            const browserConfig = config.getBrowserAgentConfig();
+            expect(browserConfig.enabled).toBe(true);
+            expect(browserConfig.customConfig.headless).toBe(true);
+            // Defaults for unspecified fields
+            expect(browserConfig.customConfig.sessionMode).toBe('persistent');
+        });
+    });
 });
 describe('setApprovalMode with folder trust', () => {
     const baseParams = {
@@ -1035,13 +1146,80 @@ describe('setApprovalMode with folder trust', () => {
         config.setApprovalMode(ApprovalMode.DEFAULT);
         expect(updateSpy).toHaveBeenCalled();
     });
-    it('should not update system instruction when switching between non-Plan modes', () => {
+    it('should update system instruction when entering YOLO mode', () => {
+        const config = new Config(baseParams);
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
+        vi.spyOn(config, 'getToolRegistry').mockReturnValue({
+            getTool: vi.fn().mockReturnValue(undefined),
+            unregisterTool: vi.fn(),
+            registerTool: vi.fn(),
+        });
+        const updateSpy = vi.spyOn(config, 'updateSystemInstructionIfInitialized');
+        config.setApprovalMode(ApprovalMode.YOLO);
+        expect(updateSpy).toHaveBeenCalled();
+    });
+    it('should not update system instruction when switching between non-Plan/non-YOLO modes', () => {
         const config = new Config(baseParams);
         vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
         const updateSpy = vi.spyOn(config, 'updateSystemInstructionIfInitialized');
         config.setApprovalMode(ApprovalMode.AUTO_EDIT);
         expect(updateSpy).not.toHaveBeenCalled();
     });
+    describe('approval mode duration logging', () => {
+        beforeEach(() => {
+            vi.mocked(logApprovalModeDuration).mockClear();
+        });
+        it('should initialize lastModeSwitchTime with performance.now() and log positive duration', () => {
+            const startTime = 1000;
+            const endTime = 5000;
+            const performanceSpy = vi.spyOn(performance, 'now');
+            performanceSpy.mockReturnValueOnce(startTime);
+            const config = new Config(baseParams);
+            vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
+            performanceSpy.mockReturnValueOnce(endTime);
+            config.setApprovalMode(ApprovalMode.PLAN);
+            expect(logApprovalModeDuration).toHaveBeenCalledWith(config, expect.objectContaining({
+                mode: ApprovalMode.DEFAULT,
+                duration_ms: endTime - startTime,
+            }));
+            performanceSpy.mockRestore();
+        });
+        it('should skip logging if duration is zero or negative', () => {
+            const startTime = 5000;
+            const endTime = 4000;
+            const performanceSpy = vi.spyOn(performance, 'now');
+            performanceSpy.mockReturnValueOnce(startTime);
+            const config = new Config(baseParams);
+            vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
+            performanceSpy.mockReturnValueOnce(endTime);
+            config.setApprovalMode(ApprovalMode.PLAN);
+            expect(logApprovalModeDuration).not.toHaveBeenCalled();
+            performanceSpy.mockRestore();
+        });
+        it('should update lastModeSwitchTime after logging to prevent double counting', () => {
+            const time1 = 1000;
+            const time2 = 3000;
+            const time3 = 6000;
+            const performanceSpy = vi.spyOn(performance, 'now');
+            performanceSpy.mockReturnValueOnce(time1);
+            const config = new Config(baseParams);
+            vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
+            performanceSpy.mockReturnValueOnce(time2);
+            config.setApprovalMode(ApprovalMode.PLAN);
+            expect(logApprovalModeDuration).toHaveBeenCalledWith(config, expect.objectContaining({
+                mode: ApprovalMode.DEFAULT,
+                duration_ms: time2 - time1,
+            }));
+            vi.mocked(logApprovalModeDuration).mockClear();
+            performanceSpy.mockReturnValueOnce(time3);
+            config.setApprovalMode(ApprovalMode.YOLO);
+            expect(logApprovalModeDuration).toHaveBeenCalledWith(config, expect.objectContaining({
+                mode: ApprovalMode.PLAN,
+                duration_ms: time3 - time2,
+            }));
+            performanceSpy.mockRestore();
+        });
+    });
     describe('registerCoreTools', () => {
         beforeEach(() => {
             vi.clearAllMocks();
@@ -1665,14 +1843,15 @@ describe('Config Quota & Preview Model Access', () => {
             vi.mocked(getCodeAssistServer).mockReturnValue(undefined);
             const result = await config.refreshUserQuota();
             expect(result).toBeUndefined();
-            expect(config.getHasAccessToPreviewModel()).toBe(false);
+            // Never set => stays null (unknown); getter returns true so UI shows preview
+            expect(config.getHasAccessToPreviewModel()).toBe(true);
         });
         it('should return undefined if retrieveUserQuota fails', async () => {
             mockCodeAssistServer.retrieveUserQuota.mockRejectedValue(new Error('Network error'));
             const result = await config.refreshUserQuota();
             expect(result).toBeUndefined();
-            // Should remain default (false)
-            expect(config.getHasAccessToPreviewModel()).toBe(false);
+            // Never set => stays null (unknown); getter returns true so UI shows preview
+            expect(config.getHasAccessToPreviewModel()).toBe(true);
         });
     });
     describe('refreshUserQuotaIfStale', () => {
@@ -1768,6 +1947,26 @@ describe('Config Quota & Preview Model Access', () => {
             expect(config.isPlanEnabled()).toBe(false);
         });
     });
+    describe('getPlanModeRoutingEnabled', () => {
+        it('should default to true when not provided', async () => {
+            const config = new Config(baseParams);
+            expect(await config.getPlanModeRoutingEnabled()).toBe(true);
+        });
+        it('should return true when explicitly enabled in planSettings', async () => {
+            const config = new Config({
+                ...baseParams,
+                planSettings: { modelRouting: true },
+            });
+            expect(await config.getPlanModeRoutingEnabled()).toBe(true);
+        });
+        it('should return false when explicitly disabled in planSettings', async () => {
+            const config = new Config({
+                ...baseParams,
+                planSettings: { modelRouting: false },
+            });
+            expect(await config.getPlanModeRoutingEnabled()).toBe(false);
+        });
+    });
 });
 describe('Config JIT Initialization', () => {
     let config;
@@ -1939,7 +2138,7 @@ describe('Plans Directory Initialization', () => {
             plan: true,
         });
         await config.initialize();
-        const plansDir = config.storage.getProjectTempPlansDir();
+        const plansDir = config.storage.getPlansDir();
         expect(fs.promises.mkdir).toHaveBeenCalledWith(plansDir, {
             recursive: true,
         });
@@ -1952,7 +2151,7 @@ describe('Plans Directory Initialization', () => {
             plan: false,
         });
         await config.initialize();
-        const plansDir = config.storage.getProjectTempPlansDir();
+        const plansDir = config.storage.getPlansDir();
         expect(fs.promises.mkdir).not.toHaveBeenCalledWith(plansDir, {
             recursive: true,
         });
@@ -2028,6 +2227,21 @@ describe('syncPlanModeTools', () => {
         const registeredTool = registerSpy.mock.calls.find((call) => call[0] instanceof EnterPlanModeTool);
         expect(registeredTool).toBeUndefined();
     });
+    it('should NOT register EnterPlanModeTool when in YOLO mode, even if plan is enabled', async () => {
+        const config = new Config({
+            ...baseParams,
+            approvalMode: ApprovalMode.YOLO,
+            plan: true,
+        });
+        const registry = new ToolRegistry(config, config.getMessageBus());
+        vi.spyOn(config, 'getToolRegistry').mockReturnValue(registry);
+        const registerSpy = vi.spyOn(registry, 'registerTool');
+        vi.spyOn(registry, 'getTool').mockReturnValue(undefined);
+        config.syncPlanModeTools();
+        const { EnterPlanModeTool } = await import('../tools/enter-plan-mode.js');
+        const registeredTool = registerSpy.mock.calls.find((call) => call[0] instanceof EnterPlanModeTool);
+        expect(registeredTool).toBeUndefined();
+    });
     it('should call geminiClient.setTools if initialized', async () => {
         const config = new Config(baseParams);
         const registry = new ToolRegistry(config, config.getMessageBus());
@@ -2041,4 +2255,65 @@ describe('syncPlanModeTools', () => {
         expect(setToolsSpy).toHaveBeenCalled();
     });
 });
+describe('Model Persistence Bug Fix (#19864)', () => {
+    const baseParams = {
+        sessionId: 'test-session',
+        cwd: '/tmp',
+        targetDir: '/path/to/target',
+        debugMode: false,
+        model: PREVIEW_GEMINI_3_1_MODEL, // User saved preview model
+    };
+    it('should NOT reset preview model for CodeAssist auth when refreshUserQuota is not called (no projectId)', async () => {
+        const mockContentConfig = {
+            authType: AuthType.LOGIN_WITH_GOOGLE,
+        };
+        const mockContentGenerator = {
+            generateContent: vi.fn(),
+        };
+        vi.mocked(createContentGeneratorConfig).mockResolvedValue(mockContentConfig);
+        vi.mocked(createContentGenerator).mockResolvedValue(mockContentGenerator);
+        // getCodeAssistServer returns undefined by default, so refreshUserQuota() isn't called;
+        // hasAccessToPreviewModel stays null; reset only when === false, so we don't reset.
+        const config = new Config(baseParams);
+        // Verify initial model is the preview model
+        expect(config.getModel()).toBe(PREVIEW_GEMINI_3_1_MODEL);
+        // Call refreshAuth to simulate restart (CodeAssist auth, no projectId)
+        await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+        // Verify the model was NOT reset (bug fix)
+        expect(config.getModel()).toBe(PREVIEW_GEMINI_3_1_MODEL);
+        expect(config.getModel()).not.toBe(DEFAULT_GEMINI_MODEL_AUTO);
+    });
+    it('should NOT reset preview model for USE_GEMINI (hasAccessToPreviewModel is set to true)', async () => {
+        const mockContentConfig = {
+            authType: AuthType.USE_GEMINI,
+        };
+        const mockContentGenerator = {
+            generateContent: vi.fn(),
+        };
+        vi.mocked(createContentGeneratorConfig).mockResolvedValue(mockContentConfig);
+        vi.mocked(createContentGenerator).mockResolvedValue(mockContentGenerator);
+        const config = new Config(baseParams);
+        // Verify initial model is the preview model
+        expect(config.getModel()).toBe(PREVIEW_GEMINI_3_1_MODEL);
+        // Call refreshAuth
+        await config.refreshAuth(AuthType.USE_GEMINI);
+        // For USE_GEMINI, hasAccessToPreviewModel should be set to true
+        // So the model should NOT be reset
+        expect(config.getModel()).toBe(PREVIEW_GEMINI_3_1_MODEL);
+        expect(config.getHasAccessToPreviewModel()).toBe(true);
+    });
+    it('should persist model when user selects it with persistMode=true', () => {
+        const onModelChange = vi.fn();
+        const config = new Config({
+            ...baseParams,
+            model: DEFAULT_GEMINI_MODEL_AUTO, // Initial model
+            onModelChange,
+        });
+        // User selects preview model with persist mode enabled
+        config.setModel(PREVIEW_GEMINI_3_1_MODEL, false); // isTemporary = false
+        // Verify onModelChange was called to persist the model
+        expect(onModelChange).toHaveBeenCalledWith(PREVIEW_GEMINI_3_1_MODEL);
+        expect(config.getModel()).toBe(PREVIEW_GEMINI_3_1_MODEL);
+    });
+});
 //# sourceMappingURL=config.test.js.map