@office-ai/aioncli-core 0.26.0 → 0.30.0

package/dist/src/agents/registry.test.js

@@ -9,9 +9,12 @@ import { makeFakeConfig } from '../test-utils/config.js';
 import { debugLogger } from '../utils/debugLogger.js';
 import { coreEvents, CoreEvent } from '../utils/events.js';
 import { A2AClientManager } from './a2a-client-manager.js';
-import { DEFAULT_GEMINI_FLASH_LITE_MODEL, GEMINI_MODEL_ALIAS_AUTO, PREVIEW_GEMINI_FLASH_MODEL, PREVIEW_GEMINI_MODEL, PREVIEW_GEMINI_MODEL_AUTO, } from '../config/models.js';
-import * as tomlLoader from './toml-loader.js';
-vi.mock('./toml-loader.js', () => ({
+import { DEFAULT_GEMINI_FLASH_LITE_MODEL, DEFAULT_GEMINI_MODEL, DEFAULT_THINKING_MODE, PREVIEW_GEMINI_FLASH_MODEL, PREVIEW_GEMINI_MODEL, PREVIEW_GEMINI_MODEL_AUTO, } from '../config/models.js';
+import * as tomlLoader from './agentLoader.js';
+import { SimpleExtensionLoader } from '../utils/extensionLoader.js';
+import { ThinkingLevel } from '@google/genai';
+import { PolicyDecision } from '../policy/types.js';
+vi.mock('./agentLoader.js', () => ({
     loadAgentsFromDirectory: vi
         .fn()
         .mockResolvedValue({ agents: [], errors: [] }),
@@ -21,6 +24,16 @@ vi.mock('./a2a-client-manager.js', () => ({
         getInstance: vi.fn(),
     },
 }));
+function makeMockedConfig(params) {
+    const config = makeFakeConfig(params);
+    vi.spyOn(config, 'getToolRegistry').mockReturnValue({
+        getAllToolNames: () => ['tool1', 'tool2'],
+    });
+    vi.spyOn(config, 'getAgentRegistry').mockReturnValue({
+        getDirectoryContext: () => 'mock directory context',
+    });
+    return config;
+}
 // A test-only subclass to expose the protected `registerAgent` method.
 class TestableAgentRegistry extends AgentRegistry {
     async testRegisterAgent(definition) {
@@ -32,9 +45,19 @@ const MOCK_AGENT_V1 = {
     kind: 'local',
     name: 'MockAgent',
     description: 'Mock Description V1',
-    inputConfig: { inputs: {} },
-    modelConfig: { model: 'test', temp: 0, top_p: 1 },
-    runConfig: { max_time_minutes: 1 },
+    inputConfig: { inputSchema: { type: 'object' } },
+    modelConfig: {
+        model: 'test',
+        generateContentConfig: {
+            temperature: 0,
+            topP: 1,
+            thinkingConfig: {
+                includeThoughts: true,
+                thinkingBudget: -1,
+            },
+        },
+    },
+    runConfig: { maxTimeMinutes: 1 },
     promptConfig: { systemPrompt: 'test' },
 };
 const MOCK_AGENT_V2 = {
@@ -46,7 +69,7 @@ describe('AgentRegistry', () => {
     let registry;
     beforeEach(() => {
         // Default configuration (debugMode: false)
-        mockConfig = makeFakeConfig();
+        mockConfig = makeMockedConfig();
         registry = new TestableAgentRegistry(mockConfig);
         vi.mocked(tomlLoader.loadAgentsFromDirectory).mockResolvedValue({
             agents: [],
@@ -65,7 +88,7 @@ describe('AgentRegistry', () => {
         //   expect(registry.getAllDefinitions()).toEqual([]);
         // });
         it('should log the count of loaded agents in debug mode', async () => {
-            const debugConfig = makeFakeConfig({
+            const debugConfig = makeMockedConfig({
                 debugMode: true,
                 enableAgents: true,
             });
@@ -75,29 +98,35 @@ describe('AgentRegistry', () => {
                 .mockImplementation(() => { });
             await debugRegistry.initialize();
             const agentCount = debugRegistry.getAllDefinitions().length;
-            expect(debugLogSpy).toHaveBeenCalledWith(`[AgentRegistry] Initialized with ${agentCount} agents.`);
+            expect(debugLogSpy).toHaveBeenCalledWith(`[AgentRegistry] Loaded with ${agentCount} agents.`);
         });
-        it('should use preview flash model for codebase investigator if main model is preview pro', async () => {
-            const previewConfig = makeFakeConfig({
-                model: PREVIEW_GEMINI_MODEL,
-                codebaseInvestigatorSettings: {
-                    enabled: true,
-                    model: GEMINI_MODEL_ALIAS_AUTO,
-                },
+        it('should use default model for codebase investigator for non-preview models', async () => {
+            const previewConfig = makeMockedConfig({ model: DEFAULT_GEMINI_MODEL });
+            const previewRegistry = new TestableAgentRegistry(previewConfig);
+            await previewRegistry.initialize();
+            const investigatorDef = previewRegistry.getDefinition('codebase_investigator');
+            expect(investigatorDef).toBeDefined();
+            expect(investigatorDef?.modelConfig.model).toBe(DEFAULT_GEMINI_MODEL);
+            expect(investigatorDef?.modelConfig.generateContentConfig?.thinkingConfig).toStrictEqual({
+                includeThoughts: true,
+                thinkingBudget: DEFAULT_THINKING_MODE,
             });
+        });
+        it('should use preview flash model for codebase investigator if main model is preview pro', async () => {
+            const previewConfig = makeMockedConfig({ model: PREVIEW_GEMINI_MODEL });
             const previewRegistry = new TestableAgentRegistry(previewConfig);
             await previewRegistry.initialize();
             const investigatorDef = previewRegistry.getDefinition('codebase_investigator');
             expect(investigatorDef).toBeDefined();
             expect(investigatorDef?.modelConfig.model).toBe(PREVIEW_GEMINI_FLASH_MODEL);
+            expect(investigatorDef?.modelConfig.generateContentConfig?.thinkingConfig).toStrictEqual({
+                includeThoughts: true,
+                thinkingLevel: ThinkingLevel.HIGH,
+            });
         });
         it('should use preview flash model for codebase investigator if main model is preview auto', async () => {
-            const previewConfig = makeFakeConfig({
+            const previewConfig = makeMockedConfig({
                 model: PREVIEW_GEMINI_MODEL_AUTO,
-                codebaseInvestigatorSettings: {
-                    enabled: true,
-                    model: GEMINI_MODEL_ALIAS_AUTO,
-                },
             });
             const previewRegistry = new TestableAgentRegistry(previewConfig);
             await previewRegistry.initialize();
@@ -106,11 +135,15 @@ describe('AgentRegistry', () => {
             expect(investigatorDef?.modelConfig.model).toBe(PREVIEW_GEMINI_FLASH_MODEL);
         });
         it('should use the model from the investigator settings', async () => {
-            const previewConfig = makeFakeConfig({
+            const previewConfig = makeMockedConfig({
                 model: PREVIEW_GEMINI_MODEL,
-                codebaseInvestigatorSettings: {
-                    enabled: true,
-                    model: DEFAULT_GEMINI_FLASH_LITE_MODEL,
+                agents: {
+                    overrides: {
+                        codebase_investigator: {
+                            enabled: true,
+                            modelConfig: { model: DEFAULT_GEMINI_FLASH_LITE_MODEL },
+                        },
+                    },
                 },
             });
             const previewRegistry = new TestableAgentRegistry(previewConfig);
@@ -120,7 +153,7 @@ describe('AgentRegistry', () => {
             expect(investigatorDef?.modelConfig.model).toBe(DEFAULT_GEMINI_FLASH_LITE_MODEL);
         });
         it('should load agents from user and project directories with correct precedence', async () => {
-            mockConfig = makeFakeConfig({ enableAgents: true });
+            mockConfig = makeMockedConfig({ enableAgents: true });
             registry = new TestableAgentRegistry(mockConfig);
             const userAgent = {
                 ...MOCK_AGENT_V1,
@@ -150,33 +183,197 @@ describe('AgentRegistry', () => {
             expect(vi.mocked(tomlLoader.loadAgentsFromDirectory)).toHaveBeenCalledTimes(2);
         });
         it('should NOT load TOML agents when enableAgents is false', async () => {
-            const disabledConfig = makeFakeConfig({
+            const disabledConfig = makeMockedConfig({
                 enableAgents: false,
-                codebaseInvestigatorSettings: { enabled: false },
+                agents: {
+                    overrides: {
+                        codebase_investigator: { enabled: false },
+                        cli_help: { enabled: false },
+                    },
+                },
             });
             const disabledRegistry = new TestableAgentRegistry(disabledConfig);
             await disabledRegistry.initialize();
             expect(disabledRegistry.getAllDefinitions()).toHaveLength(0);
             expect(vi.mocked(tomlLoader.loadAgentsFromDirectory)).not.toHaveBeenCalled();
         });
-        it('should register introspection agent if enabled', async () => {
-            const config = makeFakeConfig({
-                introspectionAgentSettings: { enabled: true },
+        it('should register CLI help agent by default', async () => {
+            const config = makeMockedConfig();
+            const registry = new TestableAgentRegistry(config);
+            await registry.initialize();
+            expect(registry.getDefinition('cli_help')).toBeDefined();
+        });
+        it('should NOT register CLI help agent if disabled', async () => {
+            const config = makeMockedConfig({
+                agents: {
+                    overrides: {
+                        cli_help: { enabled: false },
+                    },
+                },
             });
             const registry = new TestableAgentRegistry(config);
             await registry.initialize();
-            expect(registry.getDefinition('introspection_agent')).toBeDefined();
+            expect(registry.getDefinition('cli_help')).toBeUndefined();
         });
-        it('should NOT register introspection agent if disabled', async () => {
-            const config = makeFakeConfig({
-                introspectionAgentSettings: { enabled: false },
+        it('should NOT register generalist agent by default (because it is experimental)', async () => {
+            const config = makeMockedConfig();
+            const registry = new TestableAgentRegistry(config);
+            await registry.initialize();
+            expect(registry.getDefinition('generalist')).toBeUndefined();
+        });
+        it('should register generalist agent if explicitly enabled via override', async () => {
+            const config = makeMockedConfig({
+                agents: {
+                    overrides: {
+                        generalist: { enabled: true },
+                    },
+                },
+            });
+            const registry = new TestableAgentRegistry(config);
+            await registry.initialize();
+            expect(registry.getDefinition('generalist')).toBeDefined();
+        });
+        it('should NOT register a non-experimental agent if enabled is false', async () => {
+            // CLI help is NOT experimental, but we explicitly disable it via enabled: false
+            const config = makeMockedConfig({
+                agents: {
+                    overrides: {
+                        cli_help: { enabled: false },
+                    },
+                },
             });
             const registry = new TestableAgentRegistry(config);
             await registry.initialize();
-            expect(registry.getDefinition('introspection_agent')).toBeUndefined();
+            expect(registry.getDefinition('cli_help')).toBeUndefined();
+        });
+        it('should respect disabled override over enabled override', async () => {
+            const config = makeMockedConfig({
+                agents: {
+                    overrides: {
+                        generalist: { enabled: false },
+                    },
+                },
+            });
+            const registry = new TestableAgentRegistry(config);
+            await registry.initialize();
+            expect(registry.getDefinition('generalist')).toBeUndefined();
+        });
+        it('should load agents from active extensions', async () => {
+            const extensionAgent = {
+                ...MOCK_AGENT_V1,
+                name: 'extension-agent',
+            };
+            const extensions = [
+                {
+                    name: 'test-extension',
+                    isActive: true,
+                    agents: [extensionAgent],
+                    version: '1.0.0',
+                    path: '/path/to/extension',
+                    contextFiles: [],
+                    id: 'test-extension-id',
+                },
+            ];
+            const mockConfig = makeMockedConfig({
+                extensionLoader: new SimpleExtensionLoader(extensions),
+                enableAgents: true,
+            });
+            const registry = new TestableAgentRegistry(mockConfig);
+            await registry.initialize();
+            expect(registry.getDefinition('extension-agent')).toEqual(extensionAgent);
+        });
+        it('should NOT load agents from inactive extensions', async () => {
+            const extensionAgent = {
+                ...MOCK_AGENT_V1,
+                name: 'extension-agent',
+            };
+            const extensions = [
+                {
+                    name: 'test-extension',
+                    isActive: false,
+                    agents: [extensionAgent],
+                    version: '1.0.0',
+                    path: '/path/to/extension',
+                    contextFiles: [],
+                    id: 'test-extension-id',
+                },
+            ];
+            const mockConfig = makeMockedConfig({
+                extensionLoader: new SimpleExtensionLoader(extensions),
+            });
+            const registry = new TestableAgentRegistry(mockConfig);
+            await registry.initialize();
+            expect(registry.getDefinition('extension-agent')).toBeUndefined();
+        });
+        it('should use agentCardUrl as hash for acknowledgement of remote agents', async () => {
+            mockConfig = makeMockedConfig({ enableAgents: true });
+            // Trust the folder so it attempts to load project agents
+            vi.spyOn(mockConfig, 'isTrustedFolder').mockReturnValue(true);
+            vi.spyOn(mockConfig, 'getFolderTrust').mockReturnValue(true);
+            const registry = new TestableAgentRegistry(mockConfig);
+            const remoteAgent = {
+                kind: 'remote',
+                name: 'RemoteAgent',
+                description: 'A remote agent',
+                agentCardUrl: 'https://example.com/card',
+                inputConfig: { inputSchema: { type: 'object' } },
+                metadata: { hash: 'file-hash', filePath: 'path/to/file.md' },
+            };
+            vi.mocked(tomlLoader.loadAgentsFromDirectory).mockResolvedValue({
+                agents: [remoteAgent],
+                errors: [],
+            });
+            const ackService = {
+                isAcknowledged: vi.fn().mockResolvedValue(true),
+                acknowledge: vi.fn(),
+            };
+            vi.spyOn(mockConfig, 'getAcknowledgedAgentsService').mockReturnValue(ackService);
+            // Mock A2AClientManager to avoid network calls
+            vi.mocked(A2AClientManager.getInstance).mockReturnValue({
+                loadAgent: vi.fn().mockResolvedValue({ name: 'RemoteAgent' }),
+                clearCache: vi.fn(),
+            });
+            await registry.initialize();
+            // Verify ackService was called with the URL, not the file hash
+            expect(ackService.isAcknowledged).toHaveBeenCalledWith(expect.anything(), 'RemoteAgent', 'https://example.com/card');
+            // Also verify that the agent's metadata was updated to use the URL as hash
+            // Use getDefinition because registerAgent might have been called
+            expect(registry.getDefinition('RemoteAgent')?.metadata?.hash).toBe('https://example.com/card');
         });
     });
     describe('registration logic', () => {
+        it('should register runtime overrides when the model is "auto"', async () => {
+            const autoAgent = {
+                ...MOCK_AGENT_V1,
+                name: 'AutoAgent',
+                modelConfig: { ...MOCK_AGENT_V1.modelConfig, model: 'auto' },
+            };
+            const registerOverrideSpy = vi.spyOn(mockConfig.modelConfigService, 'registerRuntimeModelOverride');
+            await registry.testRegisterAgent(autoAgent);
+            // Should register one alias for the custom model config.
+            expect(mockConfig.modelConfigService.getResolvedConfig({
+                model: getModelConfigAlias(autoAgent),
+            })).toStrictEqual({
+                model: 'auto',
+                generateContentConfig: {
+                    temperature: autoAgent.modelConfig.generateContentConfig?.temperature,
+                    topP: autoAgent.modelConfig.generateContentConfig?.topP,
+                    thinkingConfig: {
+                        includeThoughts: true,
+                        thinkingBudget: -1,
+                    },
+                },
+            });
+            // Should register one override for the agent name (scope)
+            expect(registerOverrideSpy).toHaveBeenCalledTimes(1);
+            // Check scope override
+            expect(registerOverrideSpy).toHaveBeenCalledWith(expect.objectContaining({
+                match: { overrideScope: autoAgent.name },
+                modelConfig: expect.objectContaining({
+                    generateContentConfig: expect.any(Object),
+                }),
+            }));
+        });
         it('should register a valid agent definition', async () => {
             await registry.testRegisterAgent(MOCK_AGENT_V1);
             expect(registry.getDefinition('MockAgent')).toEqual(MOCK_AGENT_V1);
@@ -185,8 +382,8 @@ describe('AgentRegistry', () => {
             })).toStrictEqual({
                 model: MOCK_AGENT_V1.modelConfig.model,
                 generateContentConfig: {
-                    temperature: MOCK_AGENT_V1.modelConfig.temp,
-                    topP: MOCK_AGENT_V1.modelConfig.top_p,
+                    temperature: MOCK_AGENT_V1.modelConfig.generateContentConfig?.temperature,
+                    topP: MOCK_AGENT_V1.modelConfig.generateContentConfig?.topP,
                     thinkingConfig: {
                         includeThoughts: true,
                         thinkingBudget: -1,
@@ -200,7 +397,7 @@ describe('AgentRegistry', () => {
                 name: 'RemoteAgent',
                 description: 'A remote agent',
                 agentCardUrl: 'https://example.com/card',
-                inputConfig: { inputs: {} },
+                inputConfig: { inputSchema: { type: 'object' } },
             };
             vi.mocked(A2AClientManager.getInstance).mockReturnValue({
                 loadAgent: vi.fn().mockResolvedValue({ name: 'RemoteAgent' }),
@@ -209,7 +406,7 @@ describe('AgentRegistry', () => {
             expect(registry.getDefinition('RemoteAgent')).toEqual(remoteAgent);
         });
         it('should log remote agent registration in debug mode', async () => {
-            const debugConfig = makeFakeConfig({ debugMode: true });
+            const debugConfig = makeMockedConfig({ debugMode: true });
             const debugRegistry = new TestableAgentRegistry(debugConfig);
             const debugLogSpy = vi
                 .spyOn(debugLogger, 'log')
@@ -219,7 +416,7 @@ describe('AgentRegistry', () => {
                 name: 'RemoteAgent',
                 description: 'A remote agent',
                 agentCardUrl: 'https://example.com/card',
-                inputConfig: { inputs: {} },
+                inputConfig: { inputSchema: { type: 'object' } },
             };
             vi.mocked(A2AClientManager.getInstance).mockReturnValue({
                 loadAgent: vi.fn().mockResolvedValue({ name: 'RemoteAgent' }),
@@ -261,7 +458,7 @@ describe('AgentRegistry', () => {
             expect(registry.getAllDefinitions()).toHaveLength(1);
         });
         it('should log overwrites when in debug mode', async () => {
-            const debugConfig = makeFakeConfig({ debugMode: true });
+            const debugConfig = makeMockedConfig({ debugMode: true });
             const debugRegistry = new TestableAgentRegistry(debugConfig);
             const debugLogSpy = vi
                 .spyOn(debugLogger, 'log')
@@ -286,10 +483,113 @@ describe('AgentRegistry', () => {
             await Promise.all(promises);
             expect(registry.getAllDefinitions()).toHaveLength(100);
         });
+        it('should dynamically register an ALLOW policy for local agents', async () => {
+            const agent = {
+                ...MOCK_AGENT_V1,
+                name: 'PolicyTestAgent',
+            };
+            const policyEngine = mockConfig.getPolicyEngine();
+            const addRuleSpy = vi.spyOn(policyEngine, 'addRule');
+            await registry.testRegisterAgent(agent);
+            expect(addRuleSpy).toHaveBeenCalledWith(expect.objectContaining({
+                toolName: 'PolicyTestAgent',
+                decision: PolicyDecision.ALLOW,
+                priority: 1.05,
+            }));
+        });
+        it('should dynamically register an ASK_USER policy for remote agents', async () => {
+            const remoteAgent = {
+                kind: 'remote',
+                name: 'RemotePolicyAgent',
+                description: 'A remote agent',
+                agentCardUrl: 'https://example.com/card',
+                inputConfig: { inputSchema: { type: 'object' } },
+            };
+            vi.mocked(A2AClientManager.getInstance).mockReturnValue({
+                loadAgent: vi.fn().mockResolvedValue({ name: 'RemotePolicyAgent' }),
+            });
+            const policyEngine = mockConfig.getPolicyEngine();
+            const addRuleSpy = vi.spyOn(policyEngine, 'addRule');
+            await registry.testRegisterAgent(remoteAgent);
+            expect(addRuleSpy).toHaveBeenCalledWith(expect.objectContaining({
+                toolName: 'RemotePolicyAgent',
+                decision: PolicyDecision.ASK_USER,
+                priority: 1.05,
+            }));
+        });
+        it('should not register a policy if a USER policy already exists', async () => {
+            const agent = {
+                ...MOCK_AGENT_V1,
+                name: 'ExistingUserPolicyAgent',
+            };
+            const policyEngine = mockConfig.getPolicyEngine();
+            // Mock hasRuleForTool to return true when ignoreDynamic=true (simulating a user policy)
+            vi.spyOn(policyEngine, 'hasRuleForTool').mockImplementation((toolName, ignoreDynamic) => toolName === 'ExistingUserPolicyAgent' && ignoreDynamic === true);
+            const addRuleSpy = vi.spyOn(policyEngine, 'addRule');
+            await registry.testRegisterAgent(agent);
+            expect(addRuleSpy).not.toHaveBeenCalled();
+        });
+        it('should replace an existing dynamic policy when an agent is overwritten', async () => {
+            const localAgent = {
+                ...MOCK_AGENT_V1,
+                name: 'OverwrittenAgent',
+            };
+            const remoteAgent = {
+                kind: 'remote',
+                name: 'OverwrittenAgent',
+                description: 'A remote agent',
+                agentCardUrl: 'https://example.com/card',
+                inputConfig: { inputSchema: { type: 'object' } },
+            };
+            vi.mocked(A2AClientManager.getInstance).mockReturnValue({
+                loadAgent: vi.fn().mockResolvedValue({ name: 'OverwrittenAgent' }),
+            });
+            const policyEngine = mockConfig.getPolicyEngine();
+            const removeRuleSpy = vi.spyOn(policyEngine, 'removeRulesForTool');
+            const addRuleSpy = vi.spyOn(policyEngine, 'addRule');
+            // 1. Register local
+            await registry.testRegisterAgent(localAgent);
+            expect(addRuleSpy).toHaveBeenLastCalledWith(expect.objectContaining({ decision: PolicyDecision.ALLOW }));
+            // 2. Overwrite with remote
+            await registry.testRegisterAgent(remoteAgent);
+            // Verify old dynamic rule was removed
+            expect(removeRuleSpy).toHaveBeenCalledWith('OverwrittenAgent', 'AgentRegistry (Dynamic)');
+            // Verify new dynamic rule (remote -> ASK_USER) was added
+            expect(addRuleSpy).toHaveBeenLastCalledWith(expect.objectContaining({
+                toolName: 'OverwrittenAgent',
+                decision: PolicyDecision.ASK_USER,
+            }));
+        });
+    });
+    describe('reload', () => {
+        it('should clear existing agents and reload from directories', async () => {
+            const config = makeMockedConfig({ enableAgents: true });
+            const registry = new TestableAgentRegistry(config);
+            const initialAgent = { ...MOCK_AGENT_V1, name: 'InitialAgent' };
+            await registry.testRegisterAgent(initialAgent);
+            expect(registry.getDefinition('InitialAgent')).toBeDefined();
+            const newAgent = { ...MOCK_AGENT_V1, name: 'NewAgent' };
+            vi.mocked(tomlLoader.loadAgentsFromDirectory).mockResolvedValue({
+                agents: [newAgent],
+                errors: [],
+            });
+            const clearCacheSpy = vi.fn();
+            vi.mocked(A2AClientManager.getInstance).mockReturnValue({
+                clearCache: clearCacheSpy,
+            });
+            const emitSpy = vi.spyOn(coreEvents, 'emitAgentsRefreshed');
+            await registry.reload();
+            expect(clearCacheSpy).toHaveBeenCalled();
+            expect(registry.getDefinition('InitialAgent')).toBeUndefined();
+            expect(registry.getDiscoveredDefinition('InitialAgent')).toBeUndefined();
+            expect(registry.getDefinition('NewAgent')).toBeDefined();
+            expect(registry.getDiscoveredDefinition('NewAgent')).toBeDefined();
+            expect(emitSpy).toHaveBeenCalled();
+        });
     });
     describe('inheritance and refresh', () => {
         it('should resolve "inherit" to the current model from configuration', async () => {
-            const config = makeFakeConfig({ model: 'current-model' });
+            const config = makeMockedConfig({ model: 'current-model' });
             const registry = new TestableAgentRegistry(config);
             const agent = {
                 ...MOCK_AGENT_V1,
@@ -302,7 +602,7 @@ describe('AgentRegistry', () => {
             expect(resolved.model).toBe('current-model');
         });
         it('should update inherited models when the main model changes', async () => {
-            const config = makeFakeConfig({ model: 'initial-model' });
+            const config = makeMockedConfig({ model: 'initial-model' });
             const registry = new TestableAgentRegistry(config);
             await registry.initialize();
             const agent = {
@@ -359,23 +659,174 @@ describe('AgentRegistry', () => {
             expect(all).toHaveLength(2);
             expect(all).toEqual(expect.arrayContaining([MOCK_AGENT_V1, ANOTHER_AGENT]));
         });
+        it('getAllDiscoveredAgentNames should return all names including disabled ones', async () => {
+            const configWithDisabled = makeMockedConfig({
+                agents: {
+                    overrides: {
+                        DisabledAgent: { enabled: false },
+                    },
+                },
+            });
+            const registryWithDisabled = new TestableAgentRegistry(configWithDisabled);
+            const enabledAgent = { ...MOCK_AGENT_V1, name: 'EnabledAgent' };
+            const disabledAgent = { ...MOCK_AGENT_V1, name: 'DisabledAgent' };
+            await registryWithDisabled.testRegisterAgent(enabledAgent);
+            await registryWithDisabled.testRegisterAgent(disabledAgent);
+            const discoveredNames = registryWithDisabled.getAllDiscoveredAgentNames();
+            expect(discoveredNames).toContain('EnabledAgent');
+            expect(discoveredNames).toContain('DisabledAgent');
+            expect(discoveredNames).toHaveLength(2);
+            const activeNames = registryWithDisabled.getAllAgentNames();
+            expect(activeNames).toContain('EnabledAgent');
+            expect(activeNames).not.toContain('DisabledAgent');
+            expect(activeNames).toHaveLength(1);
+        });
+        it('getDiscoveredDefinition should return the definition for a disabled agent', async () => {
+            const configWithDisabled = makeMockedConfig({
+                agents: {
+                    overrides: {
+                        DisabledAgent: { enabled: false },
+                    },
+                },
+            });
+            const registryWithDisabled = new TestableAgentRegistry(configWithDisabled);
+            const disabledAgent = {
+                ...MOCK_AGENT_V1,
+                name: 'DisabledAgent',
+                description: 'I am disabled',
+            };
+            await registryWithDisabled.testRegisterAgent(disabledAgent);
+            expect(registryWithDisabled.getDefinition('DisabledAgent')).toBeUndefined();
+            const discovered = registryWithDisabled.getDiscoveredDefinition('DisabledAgent');
+            expect(discovered).toBeDefined();
+            expect(discovered?.description).toBe('I am disabled');
+        });
     });
-    describe('getToolDescription', () => {
-        it('should return default message when no agents are registered', () => {
-            expect(registry.getToolDescription()).toContain('No agents are currently available');
+    describe('overrides', () => {
+        it('should skip registration if agent is disabled in settings', async () => {
+            const config = makeMockedConfig({
+                agents: {
+                    overrides: {
+                        MockAgent: { enabled: false },
+                    },
+                },
+            });
+            const registry = new TestableAgentRegistry(config);
+            await registry.testRegisterAgent(MOCK_AGENT_V1);
+            expect(registry.getDefinition('MockAgent')).toBeUndefined();
+        });
+        it('should skip remote agent registration if disabled in settings', async () => {
+            const config = makeMockedConfig({
+                agents: {
+                    overrides: {
+                        RemoteAgent: { enabled: false },
+                    },
+                },
+            });
+            const registry = new TestableAgentRegistry(config);
+            const remoteAgent = {
+                kind: 'remote',
+                name: 'RemoteAgent',
+                description: 'A remote agent',
+                agentCardUrl: 'https://example.com/card',
+                inputConfig: { inputSchema: { type: 'object' } },
+            };
+            await registry.testRegisterAgent(remoteAgent);
+            expect(registry.getDefinition('RemoteAgent')).toBeUndefined();
+        });
+        it('should merge runConfig overrides', async () => {
+            const config = makeMockedConfig({
+                agents: {
+                    overrides: {
+                        MockAgent: {
+                            runConfig: { maxTurns: 50 },
+                        },
+                    },
+                },
+            });
+            const registry = new TestableAgentRegistry(config);
+            await registry.testRegisterAgent(MOCK_AGENT_V1);
+            const def = registry.getDefinition('MockAgent');
+            expect(def.runConfig.maxTurns).toBe(50);
+            expect(def.runConfig.maxTimeMinutes).toBe(MOCK_AGENT_V1.runConfig.maxTimeMinutes);
+        });
+        it('should apply modelConfig overrides', async () => {
+            const config = makeMockedConfig({
+                agents: {
+                    overrides: {
+                        MockAgent: {
+                            modelConfig: {
+                                model: 'overridden-model',
+                                generateContentConfig: {
+                                    temperature: 0.5,
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            const registry = new TestableAgentRegistry(config);
+            await registry.testRegisterAgent(MOCK_AGENT_V1);
+            const resolved = config.modelConfigService.getResolvedConfig({
+                model: getModelConfigAlias(MOCK_AGENT_V1),
+            });
+            expect(resolved.model).toBe('overridden-model');
+            expect(resolved.generateContentConfig.temperature).toBe(0.5);
+            // topP should still be MOCK_AGENT_V1.modelConfig.top_p (1) because we merged
+            expect(resolved.generateContentConfig.topP).toBe(1);
         });
-        it('should return formatted list of agents when agents are available', async () => {
+        it('should deep merge generateContentConfig (e.g. thinkingConfig)', async () => {
+            const config = makeMockedConfig({
+                agents: {
+                    overrides: {
+                        MockAgent: {
+                            modelConfig: {
+                                generateContentConfig: {
+                                    thinkingConfig: {
+                                        thinkingBudget: 16384,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            const registry = new TestableAgentRegistry(config);
             await registry.testRegisterAgent(MOCK_AGENT_V1);
-            await registry.testRegisterAgent({
-                ...MOCK_AGENT_V2,
-                name: 'AnotherAgent',
-                description: 'Another agent description',
-            });
-            const description = registry.getToolDescription();
-            expect(description).toContain('Delegates a task to a specialized sub-agent');
-            expect(description).toContain('Available agents:');
-            expect(description).toContain(`- **${MOCK_AGENT_V1.name}**: ${MOCK_AGENT_V1.description}`);
-            expect(description).toContain(`- **AnotherAgent**: Another agent description`);
+            const resolved = config.modelConfigService.getResolvedConfig({
+                model: getModelConfigAlias(MOCK_AGENT_V1),
+            });
+            expect(resolved.generateContentConfig.thinkingConfig).toEqual({
+                includeThoughts: true, // Preserved from default
+                thinkingBudget: 16384, // Overridden
+            });
+        });
+        it('should preserve lazy getters when applying overrides', async () => {
+            let getterCalled = false;
+            const agentWithGetter = {
+                ...MOCK_AGENT_V1,
+                name: 'GetterAgent',
+                get toolConfig() {
+                    getterCalled = true;
+                    return { tools: ['lazy-tool'] };
+                },
+            };
+            const config = makeMockedConfig({
+                agents: {
+                    overrides: {
+                        GetterAgent: {
+                            runConfig: { maxTurns: 100 },
+                        },
+                    },
+                },
+            });
+            const registry = new TestableAgentRegistry(config);
+            await registry.testRegisterAgent(agentWithGetter);
+            const registeredDef = registry.getDefinition('GetterAgent');
+            expect(registeredDef.runConfig.maxTurns).toBe(100);
+            expect(getterCalled).toBe(false); // Getter should not have been called yet
+            expect(registeredDef.toolConfig?.tools).toEqual(['lazy-tool']);
+            expect(getterCalled).toBe(true); // Getter should have been called now
         });
     });
 });