@office-ai/aioncli-core 0.8.1 → 0.18.4

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

@@ -4,14 +4,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { Config, ApprovalMode } from './config.js';
+import { Config, DEFAULT_FILE_FILTERING_OPTIONS } from './config.js';
+import { ExperimentFlags } from '../code_assist/experiments/flagNames.js';
+import { debugLogger } from '../utils/debugLogger.js';
+import { ApprovalMode } from '../policy/types.js';
+import { HookType, HookEventName } from '../hooks/types.js';
 import * as path from 'node:path';
 import { setGeminiMdFilename as mockSetGeminiMdFilename } from '../tools/memoryTool.js';
 import { DEFAULT_TELEMETRY_TARGET, DEFAULT_OTLP_ENDPOINT, } from '../telemetry/index.js';
 import { AuthType, createContentGeneratorConfig, } from '../core/contentGenerator.js';
 import { GeminiClient } from '../core/client.js';
 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';
@@ -19,6 +22,7 @@ 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';
+import { DEFAULT_MODEL_CONFIGS } from './defaultModelConfigs.js';
 vi.mock('fs', async (importOriginal) => {
     const actual = await importOriginal();
     return {
@@ -35,6 +39,7 @@ vi.mock('../tools/tool-registry', () => {
     const ToolRegistryMock = vi.fn();
     ToolRegistryMock.prototype.registerTool = vi.fn();
     ToolRegistryMock.prototype.discoverAllTools = vi.fn();
+    ToolRegistryMock.prototype.sortTools = vi.fn();
     ToolRegistryMock.prototype.getAllTools = vi.fn(() => []); // Mock methods if needed
     ToolRegistryMock.prototype.getTool = vi.fn();
     ToolRegistryMock.prototype.getFunctionDeclarations = vi.fn(() => []);
@@ -63,7 +68,7 @@ vi.mock('../tools/memoryTool', () => ({
     setGeminiMdFilename: vi.fn(),
     getCurrentGeminiMdFilename: vi.fn(() => 'GEMINI.md'), // Mock the original filename
     DEFAULT_CONTEXT_FILENAME: 'GEMINI.md',
-    GEMINI_CONFIG_DIR: '.gemini',
+    GEMINI_DIR: '.gemini',
 }));
 vi.mock('../core/contentGenerator.js');
 vi.mock('../core/client.js', () => ({
@@ -103,13 +108,39 @@ vi.mock('../ide/ide-client.js', () => ({
         }),
     },
 }));
+vi.mock('../agents/registry.js', () => {
+    const AgentRegistryMock = vi.fn();
+    AgentRegistryMock.prototype.initialize = vi.fn();
+    AgentRegistryMock.prototype.getAllDefinitions = vi.fn(() => []);
+    AgentRegistryMock.prototype.getDefinition = vi.fn();
+    return { AgentRegistry: AgentRegistryMock };
+});
+vi.mock('../agents/subagent-tool-wrapper.js', () => ({
+    SubagentToolWrapper: vi.fn(),
+}));
+const mockCoreEvents = vi.hoisted(() => ({
+    emitFeedback: vi.fn(),
+    emitModelChanged: vi.fn(),
+    emitConsoleLog: vi.fn(),
+}));
+const mockSetGlobalProxy = vi.hoisted(() => vi.fn());
+vi.mock('../utils/events.js', () => ({
+    coreEvents: mockCoreEvents,
+}));
+vi.mock('../utils/fetch.js', () => ({
+    setGlobalProxy: mockSetGlobalProxy,
+}));
 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';
 vi.mock('../core/baseLlmClient.js');
 vi.mock('../core/tokenLimits.js', () => ({
     tokenLimit: vi.fn(),
 }));
+vi.mock('../code_assist/codeAssist.js');
+vi.mock('../code_assist/experiments/experiments.js');
 describe('Server Config (config.ts)', () => {
     const MODEL = 'gemini-pro';
     const SANDBOX = {
@@ -119,7 +150,6 @@ describe('Server Config (config.ts)', () => {
     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';
@@ -131,7 +161,6 @@ describe('Server Config (config.ts)', () => {
         targetDir: TARGET_DIR,
         debugMode: DEBUG_MODE,
         question: QUESTION,
-        fullContext: FULL_CONTEXT,
         userMemory: USER_MEMORY,
         telemetry: TELEMETRY_SETTINGS,
         sessionId: SESSION_ID,
@@ -141,7 +170,6 @@ describe('Server Config (config.ts)', () => {
     beforeEach(() => {
         // Reset mocks if necessary
         vi.clearAllMocks();
-        vi.spyOn(ClearcutLogger.prototype, 'logStartSessionEvent').mockImplementation(() => undefined);
     });
     describe('initialize', () => {
         it('should throw an error if checkpointing is enabled and GitService fails', async () => {
@@ -170,6 +198,79 @@ describe('Server Config (config.ts)', () => {
             await expect(config.initialize()).resolves.toBeUndefined();
             await expect(config.initialize()).rejects.toThrow('Config was already initialized');
         });
+        describe('getCompressionThreshold', () => {
+            it('should return the local compression threshold if it is set', async () => {
+                const config = new Config({
+                    ...baseParams,
+                    compressionThreshold: 0.5,
+                });
+                expect(await config.getCompressionThreshold()).toBe(0.5);
+            });
+            it('should return the remote experiment threshold if it is a positive number', async () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.CONTEXT_COMPRESSION_THRESHOLD]: {
+                                floatValue: 0.8,
+                            },
+                        },
+                    },
+                });
+                expect(await config.getCompressionThreshold()).toBe(0.8);
+            });
+            it('should return undefined if the remote experiment threshold is 0', async () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.CONTEXT_COMPRESSION_THRESHOLD]: {
+                                floatValue: 0.0,
+                            },
+                        },
+                    },
+                });
+                expect(await config.getCompressionThreshold()).toBeUndefined();
+            });
+            it('should return undefined if there are no experiments', async () => {
+                const config = new Config(baseParams);
+                expect(await config.getCompressionThreshold()).toBeUndefined();
+            });
+        });
+        describe('getUserCaching', () => {
+            it('should return the remote experiment flag when available', async () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.USER_CACHING]: {
+                                boolValue: true,
+                            },
+                        },
+                        experimentIds: [],
+                    },
+                });
+                expect(await config.getUserCaching()).toBe(true);
+            });
+            it('should return false when the remote flag is false', async () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.USER_CACHING]: {
+                                boolValue: false,
+                            },
+                        },
+                        experimentIds: [],
+                    },
+                });
+                expect(await config.getUserCaching()).toBe(false);
+            });
+            it('should return undefined if there are no experiments', async () => {
+                const config = new Config(baseParams);
+                expect(await config.getUserCaching()).toBeUndefined();
+            });
+        });
     });
     describe('refreshAuth', () => {
         it('should refresh auth and update config', async () => {
@@ -178,7 +279,7 @@ describe('Server Config (config.ts)', () => {
             const mockContentConfig = {
                 apiKey: 'test-key',
             };
-            vi.mocked(createContentGeneratorConfig).mockReturnValue(mockContentConfig);
+            vi.mocked(createContentGeneratorConfig).mockResolvedValue(mockContentConfig);
             // Set fallback mode to true to ensure it gets reset
             config.setFallbackMode(true);
             expect(config.isInFallbackMode()).toBe(true);
@@ -192,19 +293,92 @@ describe('Server Config (config.ts)', () => {
         });
         it('should strip thoughts when switching from GenAI to Vertex', async () => {
             const config = new Config(baseParams);
-            vi.mocked(createContentGeneratorConfig).mockImplementation((_, authType) => ({ authType }));
+            vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => ({ authType }));
             await config.refreshAuth(AuthType.USE_GEMINI);
             await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
             expect(config.getGeminiClient().stripThoughtsFromHistory).toHaveBeenCalledWith();
         });
+        it('should strip thoughts when switching from GenAI to Vertex AI', async () => {
+            const config = new Config(baseParams);
+            vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => ({ authType }));
+            await config.refreshAuth(AuthType.USE_GEMINI);
+            await config.refreshAuth(AuthType.USE_VERTEX_AI);
+            expect(config.getGeminiClient().stripThoughtsFromHistory).toHaveBeenCalledWith();
+        });
         it('should not strip thoughts when switching from Vertex to GenAI', async () => {
             const config = new Config(baseParams);
-            vi.mocked(createContentGeneratorConfig).mockImplementation((_, authType) => ({ authType }));
+            vi.mocked(createContentGeneratorConfig).mockImplementation(async (_, authType) => ({ authType }));
             await config.refreshAuth(AuthType.USE_VERTEX_AI);
             await config.refreshAuth(AuthType.USE_GEMINI);
             expect(config.getGeminiClient().stripThoughtsFromHistory).not.toHaveBeenCalledWith();
         });
     });
+    describe('Preview Features Logic in refreshAuth', () => {
+        beforeEach(() => {
+            // Set up default mock behavior for these functions before each test
+            vi.mocked(getCodeAssistServer).mockReturnValue(undefined);
+            vi.mocked(getExperiments).mockResolvedValue({
+                flags: {},
+                experimentIds: [],
+            });
+        });
+        it('should enable preview features for Google auth when remote flag is true', async () => {
+            // Override the default mock for this specific test
+            vi.mocked(getCodeAssistServer).mockReturnValue({}); // Simulate Google auth by returning a truthy value
+            vi.mocked(getExperiments).mockResolvedValue({
+                flags: {
+                    [ExperimentFlags.ENABLE_PREVIEW]: { boolValue: true },
+                },
+                experimentIds: [],
+            });
+            const config = new Config({ ...baseParams, previewFeatures: undefined });
+            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+            expect(config.getPreviewFeatures()).toBe(true);
+        });
+        it('should disable preview features for Google auth when remote flag is false', async () => {
+            // Override the default mock
+            vi.mocked(getCodeAssistServer).mockReturnValue({});
+            vi.mocked(getExperiments).mockResolvedValue({
+                flags: {
+                    [ExperimentFlags.ENABLE_PREVIEW]: { boolValue: false },
+                },
+                experimentIds: [],
+            });
+            const config = new Config({ ...baseParams, previewFeatures: undefined });
+            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+            expect(config.getPreviewFeatures()).toBe(undefined);
+        });
+        it('should disable preview features for Google auth when remote flag is missing', async () => {
+            // Override the default mock for getCodeAssistServer, the getExperiments mock is already correct
+            vi.mocked(getCodeAssistServer).mockReturnValue({});
+            const config = new Config({ ...baseParams, previewFeatures: undefined });
+            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+            expect(config.getPreviewFeatures()).toBe(undefined);
+        });
+        it('should not change preview features or model if it is already set to true', async () => {
+            const initialModel = 'some-other-model';
+            const config = new Config({
+                ...baseParams,
+                previewFeatures: true,
+                model: initialModel,
+            });
+            // It doesn't matter which auth method we use here, the logic should exit early
+            await config.refreshAuth(AuthType.USE_GEMINI);
+            expect(config.getPreviewFeatures()).toBe(true);
+            expect(config.getModel()).toBe(initialModel);
+        });
+        it('should not change preview features or model if it is already set to false', async () => {
+            const initialModel = 'some-other-model';
+            const config = new Config({
+                ...baseParams,
+                previewFeatures: false,
+                model: initialModel,
+            });
+            await config.refreshAuth(AuthType.USE_GEMINI);
+            expect(config.getPreviewFeatures()).toBe(false);
+            expect(config.getModel()).toBe(initialModel);
+        });
+    });
     it('Config constructor should store userMemory correctly', () => {
         const config = new Config(baseParams);
         expect(config.getUserMemory()).toBe(USER_MEMORY);
@@ -232,7 +406,7 @@ describe('Server Config (config.ts)', () => {
     });
     it('should set default file filtering settings when not provided', () => {
         const config = new Config(baseParams);
-        expect(config.getFileFilteringRespectGitIgnore()).toBe(true);
+        expect(config.getFileFilteringRespectGitIgnore()).toBe(DEFAULT_FILE_FILTERING_OPTIONS.respectGitIgnore);
     });
     it('should set custom file filtering settings when provided', () => {
         const paramsWithFileFiltering = {
@@ -245,7 +419,7 @@ describe('Server Config (config.ts)', () => {
         expect(config.getFileFilteringRespectGitIgnore()).toBe(false);
     });
     it('should initialize WorkspaceContext with includeDirectories', () => {
-        const includeDirectories = ['/path/to/dir1', '/path/to/dir2'];
+        const includeDirectories = ['dir1', 'dir2'];
         const paramsWithIncludeDirs = {
             ...baseParams,
             includeDirectories,
@@ -253,11 +427,11 @@ describe('Server Config (config.ts)', () => {
         const config = new Config(paramsWithIncludeDirs);
         const workspaceContext = config.getWorkspaceContext();
         const directories = workspaceContext.getDirectories();
-        // Should include the target directory plus the included directories
-        expect(directories).toHaveLength(3);
+        // Should include only the target directory initially
+        expect(directories).toHaveLength(1);
         expect(directories).toContain(path.resolve(baseParams.targetDir));
-        expect(directories).toContain('/path/to/dir1');
-        expect(directories).toContain('/path/to/dir2');
+        // The other directories should be in the pending list
+        expect(config.getPendingIncludeDirectories()).toEqual(includeDirectories);
     });
     it('Config constructor should set telemetry to true when provided as true', () => {
         const paramsWithTelemetry = {
@@ -325,14 +499,6 @@ describe('Server Config (config.ts)', () => {
             });
             expect(config.getUsageStatisticsEnabled()).toBe(enabled);
         });
-        it('logs the session start event', async () => {
-            const config = new Config({
-                ...baseParams,
-                usageStatisticsEnabled: true,
-            });
-            await config.refreshAuth(AuthType.USE_GEMINI);
-            expect(ClearcutLogger.prototype.logStartSessionEvent).toHaveBeenCalledOnce();
-        });
     });
     describe('Telemetry Settings', () => {
         it('should return default telemetry target if not provided', () => {
@@ -447,26 +613,105 @@ describe('Server Config (config.ts)', () => {
             expect(config.getUseRipgrep()).toBe(true);
         });
     });
-    describe('UseModelRouter Configuration', () => {
-        it('should default useModelRouter to false when not provided', () => {
-            const config = new Config(baseParams);
+    describe('Model Router with Auth', () => {
+        it('should disable model router by default for oauth-personal', async () => {
+            const config = new Config({
+                ...baseParams,
+                useModelRouter: true,
+            });
+            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+            expect(config.getUseModelRouter()).toBe(true);
+        });
+        it('should enable model router by default for other auth types', async () => {
+            const config = new Config({
+                ...baseParams,
+                useModelRouter: true,
+            });
+            await config.refreshAuth(AuthType.USE_GEMINI);
+            expect(config.getUseModelRouter()).toBe(true);
+        });
+        it('should disable model router for specified auth type', async () => {
+            const config = new Config({
+                ...baseParams,
+                useModelRouter: true,
+                disableModelRouterForAuth: [AuthType.USE_GEMINI],
+            });
+            await config.refreshAuth(AuthType.USE_GEMINI);
             expect(config.getUseModelRouter()).toBe(false);
         });
-        it('should set useModelRouter to true when provided as true', () => {
-            const paramsWithModelRouter = {
+        it('should enable model router for other auth type', async () => {
+            const config = new Config({
                 ...baseParams,
                 useModelRouter: true,
-            };
-            const config = new Config(paramsWithModelRouter);
+                disableModelRouterForAuth: [],
+            });
+            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
             expect(config.getUseModelRouter()).toBe(true);
         });
-        it('should set useModelRouter to false when explicitly provided as false', () => {
-            const paramsWithModelRouter = {
+        it('should keep model router disabled when useModelRouter is false', async () => {
+            const config = new Config({
                 ...baseParams,
                 useModelRouter: false,
-            };
-            const config = new Config(paramsWithModelRouter);
+                disableModelRouterForAuth: [AuthType.USE_GEMINI],
+            });
+            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+            expect(config.getUseModelRouter()).toBe(false);
+        });
+        it('should keep the user-chosen model after refreshAuth, even when model router is disabled for the auth type', async () => {
+            const config = new Config({
+                ...baseParams,
+                useModelRouter: true,
+                disableModelRouterForAuth: [AuthType.USE_GEMINI],
+            });
+            const chosenModel = 'gemini-1.5-pro-latest';
+            config.setModel(chosenModel);
+            await config.refreshAuth(AuthType.USE_GEMINI);
             expect(config.getUseModelRouter()).toBe(false);
+            expect(config.getModel()).toBe(chosenModel);
+        });
+        it('should keep the user-chosen model after refreshAuth, when model router is enabled for the auth type', async () => {
+            const config = new Config({
+                ...baseParams,
+                useModelRouter: true,
+                disableModelRouterForAuth: [AuthType.USE_GEMINI],
+            });
+            const chosenModel = 'gemini-1.5-pro-latest';
+            config.setModel(chosenModel);
+            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+            expect(config.getUseModelRouter()).toBe(true);
+            expect(config.getModel()).toBe(chosenModel);
+        });
+        it('should NOT switch to auto model if cli provides specific model, even if router is enabled', async () => {
+            const config = new Config({
+                ...baseParams,
+                useModelRouter: true,
+                model: 'gemini-flash-latest',
+            });
+            await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+            expect(config.getUseModelRouter()).toBe(true);
+            expect(config.getModel()).toBe('gemini-flash-latest');
+        });
+    });
+    describe('ContinueOnFailedApiCall Configuration', () => {
+        it('should default continueOnFailedApiCall to false when not provided', () => {
+            const config = new Config(baseParams);
+            expect(config.getContinueOnFailedApiCall()).toBe(true);
+        });
+        it('should set continueOnFailedApiCall to true when provided as true', () => {
+            const paramsWithContinueOnFailedApiCall = {
+                ...baseParams,
+                continueOnFailedApiCall: true,
+            };
+            const config = new Config(paramsWithContinueOnFailedApiCall);
+            expect(config.getContinueOnFailedApiCall()).toBe(true);
+        });
+        it('should set continueOnFailedApiCall to false when explicitly provided as false', () => {
+            const paramsWithContinueOnFailedApiCall = {
+                ...baseParams,
+                continueOnFailedApiCall: false,
+            };
+            const config = new Config(paramsWithContinueOnFailedApiCall);
+            expect(config.getContinueOnFailedApiCall()).toBe(false);
         });
     });
     describe('createToolRegistry', () => {
@@ -486,6 +731,38 @@ describe('Server Config (config.ts)', () => {
             const wasReadFileToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ReadFileTool));
             expect(wasReadFileToolRegistered).toBe(false);
         });
+        it('should register subagents as tools when codebaseInvestigatorSettings.enabled is true', async () => {
+            const params = {
+                ...baseParams,
+                codebaseInvestigatorSettings: { enabled: true },
+            };
+            const config = new Config(params);
+            const mockAgentDefinition = {
+                name: 'codebase-investigator',
+                description: 'Agent 1',
+                instructions: 'Inst 1',
+            };
+            const AgentRegistryMock = (await vi.importMock('../agents/registry.js')).AgentRegistry;
+            AgentRegistryMock.prototype.getDefinition.mockReturnValue(mockAgentDefinition);
+            const SubagentToolWrapperMock = (await vi.importMock('../agents/subagent-tool-wrapper.js')).SubagentToolWrapper;
+            await config.initialize();
+            const registerToolMock = (await vi.importMock('../tools/tool-registry')).ToolRegistry.prototype.registerTool;
+            expect(SubagentToolWrapperMock).toHaveBeenCalledTimes(1);
+            expect(SubagentToolWrapperMock).toHaveBeenCalledWith(mockAgentDefinition, config, undefined);
+            const calls = registerToolMock.mock.calls;
+            const registeredWrappers = calls.filter((call) => call[0] instanceof SubagentToolWrapperMock);
+            expect(registeredWrappers).toHaveLength(1);
+        });
+        it('should not register subagents as tools when codebaseInvestigatorSettings.enabled is false', async () => {
+            const params = {
+                ...baseParams,
+                codebaseInvestigatorSettings: { enabled: false },
+            };
+            const config = new Config(params);
+            const SubagentToolWrapperMock = (await vi.importMock('../agents/subagent-tool-wrapper.js')).SubagentToolWrapper;
+            await config.initialize();
+            expect(SubagentToolWrapperMock).not.toHaveBeenCalled();
+        });
         describe('with minified tool class names', () => {
             beforeEach(() => {
                 Object.defineProperty(vi.mocked(ShellTool).prototype.constructor, 'name', {
@@ -509,18 +786,6 @@ describe('Server Config (config.ts)', () => {
                 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,
@@ -572,6 +837,46 @@ describe('Server Config (config.ts)', () => {
             expect(config.getTruncateToolOutputThreshold()).toBe(50000);
         });
     });
+    describe('Proxy Configuration Error Handling', () => {
+        beforeEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should call setGlobalProxy when proxy is configured', () => {
+            const paramsWithProxy = {
+                ...baseParams,
+                proxy: 'http://proxy.example.com:8080',
+            };
+            new Config(paramsWithProxy);
+            expect(mockSetGlobalProxy).toHaveBeenCalledWith('http://proxy.example.com:8080');
+        });
+        it('should not call setGlobalProxy when proxy is not configured', () => {
+            new Config(baseParams);
+            expect(mockSetGlobalProxy).not.toHaveBeenCalled();
+        });
+        it('should emit error feedback when setGlobalProxy throws an error', () => {
+            const proxyError = new Error('Invalid proxy URL');
+            mockSetGlobalProxy.mockImplementation(() => {
+                throw proxyError;
+            });
+            const paramsWithProxy = {
+                ...baseParams,
+                proxy: 'invalid-proxy',
+            };
+            new Config(paramsWithProxy);
+            expect(mockCoreEvents.emitFeedback).toHaveBeenCalledWith('error', 'Invalid proxy configuration detected. Check debug drawer for more details (F12)', proxyError);
+        });
+        it('should not emit error feedback when setGlobalProxy succeeds', () => {
+            mockSetGlobalProxy.mockImplementation(() => {
+                // Success - no error thrown
+            });
+            const paramsWithProxy = {
+                ...baseParams,
+                proxy: 'http://proxy.example.com:8080',
+            };
+            new Config(paramsWithProxy);
+            expect(mockCoreEvents.emitFeedback).not.toHaveBeenCalled();
+        });
+    });
 });
 describe('setApprovalMode with folder trust', () => {
     const baseParams = {
@@ -665,6 +970,35 @@ describe('setApprovalMode with folder trust', () => {
         });
     });
 });
+describe('isYoloModeDisabled', () => {
+    const baseParams = {
+        sessionId: 'test',
+        targetDir: '.',
+        debugMode: false,
+        model: 'test-model',
+        cwd: '.',
+    };
+    it('should return false when yolo mode is not disabled and folder is trusted', () => {
+        const config = new Config(baseParams);
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
+        expect(config.isYoloModeDisabled()).toBe(false);
+    });
+    it('should return true when yolo mode is disabled by parameter', () => {
+        const config = new Config({ ...baseParams, disableYoloMode: true });
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
+        expect(config.isYoloModeDisabled()).toBe(true);
+    });
+    it('should return true when folder is untrusted', () => {
+        const config = new Config(baseParams);
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(false);
+        expect(config.isYoloModeDisabled()).toBe(true);
+    });
+    it('should return true when yolo is disabled and folder is untrusted', () => {
+        const config = new Config({ ...baseParams, disableYoloMode: true });
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(false);
+        expect(config.isYoloModeDisabled()).toBe(true);
+    });
+});
 describe('BaseLlmClient Lifecycle', () => {
     const MODEL = 'gemini-pro';
     const SANDBOX = {
@@ -674,7 +1008,6 @@ describe('BaseLlmClient Lifecycle', () => {
     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';
@@ -686,7 +1019,6 @@ describe('BaseLlmClient Lifecycle', () => {
         targetDir: TARGET_DIR,
         debugMode: DEBUG_MODE,
         question: QUESTION,
-        fullContext: FULL_CONTEXT,
         userMemory: USER_MEMORY,
         telemetry: TELEMETRY_SETTINGS,
         sessionId: SESSION_ID,
@@ -701,7 +1033,7 @@ describe('BaseLlmClient Lifecycle', () => {
         const config = new Config(baseParams);
         const authType = AuthType.USE_GEMINI;
         const mockContentConfig = { model: 'gemini-flash', apiKey: 'test-key' };
-        vi.mocked(createContentGeneratorConfig).mockReturnValue(mockContentConfig);
+        vi.mocked(createContentGeneratorConfig).mockResolvedValue(mockContentConfig);
         await config.refreshAuth(authType);
         // Should not throw
         const llmService = config.getBaseLlmClient();
@@ -709,4 +1041,307 @@ describe('BaseLlmClient Lifecycle', () => {
         expect(BaseLlmClient).toHaveBeenCalledWith(config.getContentGenerator(), config);
     });
 });
+describe('Generation Config Merging (HACK)', () => {
+    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 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,
+        userMemory: USER_MEMORY,
+        telemetry: TELEMETRY_SETTINGS,
+        sessionId: SESSION_ID,
+        model: MODEL,
+        usageStatisticsEnabled: false,
+    };
+    it('should merge default aliases when user provides only overrides', () => {
+        const userOverrides = [
+            {
+                match: { model: 'test-model' },
+                modelConfig: { generateContentConfig: { temperature: 0.1 } },
+            },
+        ];
+        const params = {
+            ...baseParams,
+            modelConfigServiceConfig: {
+                overrides: userOverrides,
+            },
+        };
+        const config = new Config(params);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const serviceConfig = config.modelConfigService.config;
+        // Assert that the default aliases are present
+        expect(serviceConfig.aliases).toEqual(DEFAULT_MODEL_CONFIGS.aliases);
+        // Assert that the user's overrides are present
+        expect(serviceConfig.overrides).toEqual(userOverrides);
+    });
+    it('should use user-provided aliases if they exist', () => {
+        const userAliases = {
+            'my-alias': {
+                modelConfig: { model: 'my-model' },
+            },
+        };
+        const params = {
+            ...baseParams,
+            modelConfigServiceConfig: {
+                aliases: userAliases,
+            },
+        };
+        const config = new Config(params);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const serviceConfig = config.modelConfigService.config;
+        // Assert that the user's aliases are used, not the defaults
+        expect(serviceConfig.aliases).toEqual(userAliases);
+    });
+    it('should use default generation config if none is provided', () => {
+        const params = { ...baseParams };
+        const config = new Config(params);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const serviceConfig = config.modelConfigService.config;
+        // Assert that the full default config is used
+        expect(serviceConfig).toEqual(DEFAULT_MODEL_CONFIGS);
+    });
+});
+describe('Config getHooks', () => {
+    const baseParams = {
+        cwd: '/tmp',
+        targetDir: '/path/to/target',
+        debugMode: false,
+        sessionId: 'test-session-id',
+        model: 'gemini-pro',
+        usageStatisticsEnabled: false,
+    };
+    it('should return undefined when no hooks are provided', () => {
+        const config = new Config(baseParams);
+        expect(config.getHooks()).toBeUndefined();
+    });
+    it('should return empty object when empty hooks are provided', () => {
+        const configWithEmptyHooks = new Config({
+            ...baseParams,
+            hooks: {},
+        });
+        expect(configWithEmptyHooks.getHooks()).toEqual({});
+    });
+    it('should return the hooks configuration when provided', () => {
+        const mockHooks = {
+            [HookEventName.BeforeTool]: [
+                {
+                    matcher: 'write_file',
+                    hooks: [
+                        {
+                            type: HookType.Command,
+                            command: 'echo "test hook"',
+                            timeout: 5000,
+                        },
+                    ],
+                },
+            ],
+            [HookEventName.AfterTool]: [
+                {
+                    hooks: [
+                        {
+                            type: HookType.Command,
+                            command: './hooks/after-tool.sh',
+                            timeout: 10000,
+                        },
+                    ],
+                },
+            ],
+        };
+        const config = new Config({
+            ...baseParams,
+            hooks: mockHooks,
+        });
+        const retrievedHooks = config.getHooks();
+        expect(retrievedHooks).toEqual(mockHooks);
+        expect(retrievedHooks).toBe(mockHooks); // Should return the same reference
+    });
+    it('should return hooks with all supported event types', () => {
+        const allEventHooks = {
+            [HookEventName.BeforeAgent]: [
+                { hooks: [{ type: HookType.Command, command: 'test1' }] },
+            ],
+            [HookEventName.AfterAgent]: [
+                { hooks: [{ type: HookType.Command, command: 'test2' }] },
+            ],
+            [HookEventName.BeforeTool]: [
+                { hooks: [{ type: HookType.Command, command: 'test3' }] },
+            ],
+            [HookEventName.AfterTool]: [
+                { hooks: [{ type: HookType.Command, command: 'test4' }] },
+            ],
+            [HookEventName.BeforeModel]: [
+                { hooks: [{ type: HookType.Command, command: 'test5' }] },
+            ],
+            [HookEventName.AfterModel]: [
+                { hooks: [{ type: HookType.Command, command: 'test6' }] },
+            ],
+            [HookEventName.BeforeToolSelection]: [
+                { hooks: [{ type: HookType.Command, command: 'test7' }] },
+            ],
+            [HookEventName.Notification]: [
+                { hooks: [{ type: HookType.Command, command: 'test8' }] },
+            ],
+            [HookEventName.SessionStart]: [
+                { hooks: [{ type: HookType.Command, command: 'test9' }] },
+            ],
+            [HookEventName.SessionEnd]: [
+                { hooks: [{ type: HookType.Command, command: 'test10' }] },
+            ],
+            [HookEventName.PreCompress]: [
+                { hooks: [{ type: HookType.Command, command: 'test11' }] },
+            ],
+        };
+        const config = new Config({
+            ...baseParams,
+            hooks: allEventHooks,
+        });
+        const retrievedHooks = config.getHooks();
+        expect(retrievedHooks).toEqual(allEventHooks);
+        expect(Object.keys(retrievedHooks)).toHaveLength(11); // All hook event types
+    });
+    describe('setModel', () => {
+        it('should allow setting a pro (any) model and disable fallback mode', () => {
+            const config = new Config(baseParams);
+            config.setFallbackMode(true);
+            expect(config.isInFallbackMode()).toBe(true);
+            const proModel = 'gemini-2.5-pro';
+            config.setModel(proModel);
+            expect(config.getModel()).toBe(proModel);
+            expect(config.isInFallbackMode()).toBe(false);
+            expect(mockCoreEvents.emitModelChanged).toHaveBeenCalledWith(proModel);
+        });
+        it('should allow setting auto model from non-auto model and disable fallback mode', () => {
+            const config = new Config(baseParams);
+            config.setFallbackMode(true);
+            expect(config.isInFallbackMode()).toBe(true);
+            config.setModel('auto');
+            expect(config.getModel()).toBe('auto');
+            expect(config.isInFallbackMode()).toBe(false);
+            expect(mockCoreEvents.emitModelChanged).toHaveBeenCalledWith('auto');
+        });
+        it('should allow setting auto model from auto model if it is in the fallback mode', () => {
+            const config = new Config({
+                cwd: '/tmp',
+                targetDir: '/path/to/target',
+                debugMode: false,
+                sessionId: 'test-session-id',
+                model: 'auto',
+                usageStatisticsEnabled: false,
+            });
+            config.setFallbackMode(true);
+            expect(config.isInFallbackMode()).toBe(true);
+            config.setModel('auto');
+            expect(config.getModel()).toBe('auto');
+            expect(config.isInFallbackMode()).toBe(false);
+            expect(mockCoreEvents.emitModelChanged).toHaveBeenCalledWith('auto');
+        });
+    });
+});
+describe('Config getExperiments', () => {
+    const baseParams = {
+        cwd: '/tmp',
+        targetDir: '/path/to/target',
+        debugMode: false,
+        sessionId: 'test-session-id',
+        model: 'gemini-pro',
+        usageStatisticsEnabled: false,
+    };
+    it('should return undefined when no experiments are provided', () => {
+        const config = new Config(baseParams);
+        expect(config.getExperiments()).toBeUndefined();
+    });
+    it('should return empty object when empty experiments are provided', () => {
+        const configWithEmptyExps = new Config({
+            ...baseParams,
+            experiments: { flags: {}, experimentIds: [] },
+        });
+        expect(configWithEmptyExps.getExperiments()).toEqual({
+            flags: {},
+            experimentIds: [],
+        });
+    });
+    it('should return the experiments configuration when provided', () => {
+        const mockExps = {
+            flags: {
+                testFlag: { boolValue: true },
+            },
+            experimentIds: [],
+        };
+        const config = new Config({
+            ...baseParams,
+            experiments: mockExps,
+        });
+        const retrievedExps = config.getExperiments();
+        expect(retrievedExps).toEqual(mockExps);
+        expect(retrievedExps).toBe(mockExps); // Should return the same reference
+    });
+});
+describe('Config setExperiments logging', () => {
+    const baseParams = {
+        cwd: '/tmp',
+        targetDir: '/path/to/target',
+        debugMode: false,
+        sessionId: 'test-session-id',
+        model: 'gemini-pro',
+        usageStatisticsEnabled: false,
+    };
+    it('logs a sorted, non-truncated summary of experiments when they are set', () => {
+        const config = new Config(baseParams);
+        const debugSpy = vi
+            .spyOn(debugLogger, 'debug')
+            .mockImplementation(() => { });
+        const experiments = {
+            flags: {
+                ZetaFlag: {
+                    boolValue: true,
+                    stringValue: 'zeta',
+                    int32ListValue: { values: [1, 2] },
+                },
+                AlphaFlag: {
+                    boolValue: false,
+                    stringValue: 'alpha',
+                    stringListValue: { values: ['a', 'b', 'c'] },
+                },
+                MiddleFlag: {
+                    // Intentionally sparse to ensure undefined values are omitted
+                    floatValue: 0.42,
+                    int32ListValue: { values: [] },
+                },
+            },
+            experimentIds: [101, 99],
+        };
+        config.setExperiments(experiments);
+        const logCall = debugSpy.mock.calls.find(([message]) => message === 'Experiments loaded');
+        expect(logCall).toBeDefined();
+        const loggedSummary = logCall?.[1];
+        expect(typeof loggedSummary).toBe('string');
+        expect(loggedSummary).toContain('experimentIds');
+        expect(loggedSummary).toContain('101');
+        expect(loggedSummary).toContain('AlphaFlag');
+        expect(loggedSummary).toContain('ZetaFlag');
+        const alphaIndex = loggedSummary.indexOf('AlphaFlag');
+        const zetaIndex = loggedSummary.indexOf('ZetaFlag');
+        expect(alphaIndex).toBeGreaterThan(-1);
+        expect(zetaIndex).toBeGreaterThan(-1);
+        expect(alphaIndex).toBeLessThan(zetaIndex);
+        expect(loggedSummary).toContain('\n');
+        expect(loggedSummary).not.toContain('stringListLength: 0');
+        expect(loggedSummary).not.toContain('int32ListLength: 0');
+        debugSpy.mockRestore();
+    });
+});
 //# sourceMappingURL=config.test.js.map