@didim365/agent-cli-core 0.1.0

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

@@ -0,0 +1,773 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { AgentRegistry, getModelConfigAlias } from './registry.js';
+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, 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';
+vi.mock('./agentLoader.js', () => ({
+    loadAgentsFromDirectory: vi
+        .fn()
+        .mockResolvedValue({ agents: [], errors: [] }),
+}));
+vi.mock('./a2a-client-manager.js', () => ({
+    A2AClientManager: {
+        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) {
+        await this.registerAgent(definition);
+    }
+}
+// Define mock agent structures for testing registration logic
+const MOCK_AGENT_V1 = {
+    kind: 'local',
+    name: 'MockAgent',
+    description: 'Mock Description V1',
+    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 = {
+    ...MOCK_AGENT_V1,
+    description: 'Mock Description V2 (Updated)',
+};
+describe('AgentRegistry', () => {
+    let mockConfig;
+    let registry;
+    beforeEach(() => {
+        // Default configuration (debugMode: false)
+        mockConfig = makeMockedConfig();
+        registry = new TestableAgentRegistry(mockConfig);
+        vi.mocked(tomlLoader.loadAgentsFromDirectory).mockResolvedValue({
+            agents: [],
+            errors: [],
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks(); // Restore spies after each test
+    });
+    describe('initialize', () => {
+        // TODO: Add this test once we actually have a built-in agent configured.
+        // it('should load built-in agents upon initialization', async () => {
+        //   expect(registry.getAllDefinitions()).toHaveLength(0);
+        //   await registry.initialize();
+        //   // There are currently no built-in agents.
+        //   expect(registry.getAllDefinitions()).toEqual([]);
+        // });
+        it('should log the count of loaded agents in debug mode', async () => {
+            const debugConfig = makeMockedConfig({
+                debugMode: true,
+                enableAgents: true,
+            });
+            const debugRegistry = new TestableAgentRegistry(debugConfig);
+            const debugLogSpy = vi
+                .spyOn(debugLogger, 'log')
+                .mockImplementation(() => { });
+            await debugRegistry.initialize();
+            const agentCount = debugRegistry.getAllDefinitions().length;
+            expect(debugLogSpy).toHaveBeenCalledWith(`[AgentRegistry] Loaded with ${agentCount} agents.`);
+        });
+        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 = makeMockedConfig({
+                model: PREVIEW_GEMINI_MODEL_AUTO,
+            });
+            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);
+        });
+        it('should use the model from the investigator settings', async () => {
+            const previewConfig = makeMockedConfig({
+                model: PREVIEW_GEMINI_MODEL,
+                agents: {
+                    overrides: {
+                        codebase_investigator: {
+                            enabled: true,
+                            modelConfig: { model: DEFAULT_GEMINI_FLASH_LITE_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_FLASH_LITE_MODEL);
+        });
+        it('should load agents from user and project directories with correct precedence', async () => {
+            mockConfig = makeMockedConfig({ enableAgents: true });
+            registry = new TestableAgentRegistry(mockConfig);
+            const userAgent = {
+                ...MOCK_AGENT_V1,
+                name: 'common-agent',
+                description: 'User version',
+            };
+            const projectAgent = {
+                ...MOCK_AGENT_V1,
+                name: 'common-agent',
+                description: 'Project version',
+            };
+            const uniqueProjectAgent = {
+                ...MOCK_AGENT_V1,
+                name: 'project-only',
+                description: 'Project only',
+            };
+            vi.mocked(tomlLoader.loadAgentsFromDirectory)
+                .mockResolvedValueOnce({ agents: [userAgent], errors: [] }) // User dir
+                .mockResolvedValueOnce({
+                agents: [projectAgent, uniqueProjectAgent],
+                errors: [],
+            }); // Project dir
+            await registry.initialize();
+            // Project agent should override user agent
+            expect(registry.getDefinition('common-agent')?.description).toBe('Project version');
+            expect(registry.getDefinition('project-only')).toBeDefined();
+            expect(vi.mocked(tomlLoader.loadAgentsFromDirectory)).toHaveBeenCalledTimes(2);
+        });
+        it('should NOT load TOML agents when enableAgents is false', async () => {
+            const disabledConfig = makeMockedConfig({
+                enableAgents: 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 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('cli_help')).toBeUndefined();
+        });
+        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('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);
+            expect(mockConfig.modelConfigService.getResolvedConfig({
+                model: getModelConfigAlias(MOCK_AGENT_V1),
+            })).toStrictEqual({
+                model: MOCK_AGENT_V1.modelConfig.model,
+                generateContentConfig: {
+                    temperature: MOCK_AGENT_V1.modelConfig.generateContentConfig?.temperature,
+                    topP: MOCK_AGENT_V1.modelConfig.generateContentConfig?.topP,
+                    thinkingConfig: {
+                        includeThoughts: true,
+                        thinkingBudget: -1,
+                    },
+                },
+            });
+        });
+        it('should register a remote agent definition', async () => {
+            const remoteAgent = {
+                kind: 'remote',
+                name: 'RemoteAgent',
+                description: 'A remote agent',
+                agentCardUrl: 'https://example.com/card',
+                inputConfig: { inputSchema: { type: 'object' } },
+            };
+            vi.mocked(A2AClientManager.getInstance).mockReturnValue({
+                loadAgent: vi.fn().mockResolvedValue({ name: 'RemoteAgent' }),
+            });
+            await registry.testRegisterAgent(remoteAgent);
+            expect(registry.getDefinition('RemoteAgent')).toEqual(remoteAgent);
+        });
+        it('should log remote agent registration in debug mode', async () => {
+            const debugConfig = makeMockedConfig({ debugMode: true });
+            const debugRegistry = new TestableAgentRegistry(debugConfig);
+            const debugLogSpy = vi
+                .spyOn(debugLogger, 'log')
+                .mockImplementation(() => { });
+            const remoteAgent = {
+                kind: 'remote',
+                name: 'RemoteAgent',
+                description: 'A remote agent',
+                agentCardUrl: 'https://example.com/card',
+                inputConfig: { inputSchema: { type: 'object' } },
+            };
+            vi.mocked(A2AClientManager.getInstance).mockReturnValue({
+                loadAgent: vi.fn().mockResolvedValue({ name: 'RemoteAgent' }),
+            });
+            await debugRegistry.testRegisterAgent(remoteAgent);
+            expect(debugLogSpy).toHaveBeenCalledWith(`[AgentRegistry] Registered remote agent 'RemoteAgent' with card: https://example.com/card`);
+        });
+        it('should handle special characters in agent names', async () => {
+            const specialAgent = {
+                ...MOCK_AGENT_V1,
+                name: 'Agent-123_$pecial.v2',
+            };
+            await registry.testRegisterAgent(specialAgent);
+            expect(registry.getDefinition('Agent-123_$pecial.v2')).toEqual(specialAgent);
+        });
+        it('should reject an agent definition missing a name', async () => {
+            const invalidAgent = { ...MOCK_AGENT_V1, name: '' };
+            const debugWarnSpy = vi
+                .spyOn(debugLogger, 'warn')
+                .mockImplementation(() => { });
+            await registry.testRegisterAgent(invalidAgent);
+            expect(registry.getDefinition('MockAgent')).toBeUndefined();
+            expect(debugWarnSpy).toHaveBeenCalledWith('[AgentRegistry] Skipping invalid agent definition. Missing name or description.');
+        });
+        it('should reject an agent definition missing a description', async () => {
+            const invalidAgent = { ...MOCK_AGENT_V1, description: '' };
+            const debugWarnSpy = vi
+                .spyOn(debugLogger, 'warn')
+                .mockImplementation(() => { });
+            await registry.testRegisterAgent(invalidAgent);
+            expect(registry.getDefinition('MockAgent')).toBeUndefined();
+            expect(debugWarnSpy).toHaveBeenCalledWith('[AgentRegistry] Skipping invalid agent definition. Missing name or description.');
+        });
+        it('should overwrite an existing agent definition', async () => {
+            await registry.testRegisterAgent(MOCK_AGENT_V1);
+            expect(registry.getDefinition('MockAgent')?.description).toBe('Mock Description V1');
+            await registry.testRegisterAgent(MOCK_AGENT_V2);
+            expect(registry.getDefinition('MockAgent')?.description).toBe('Mock Description V2 (Updated)');
+            expect(registry.getAllDefinitions()).toHaveLength(1);
+        });
+        it('should log overwrites when in debug mode', async () => {
+            const debugConfig = makeMockedConfig({ debugMode: true });
+            const debugRegistry = new TestableAgentRegistry(debugConfig);
+            const debugLogSpy = vi
+                .spyOn(debugLogger, 'log')
+                .mockImplementation(() => { });
+            await debugRegistry.testRegisterAgent(MOCK_AGENT_V1);
+            await debugRegistry.testRegisterAgent(MOCK_AGENT_V2);
+            expect(debugLogSpy).toHaveBeenCalledWith(`[AgentRegistry] Overriding agent 'MockAgent'`);
+        });
+        it('should not log overwrites when not in debug mode', async () => {
+            const debugLogSpy = vi
+                .spyOn(debugLogger, 'log')
+                .mockImplementation(() => { });
+            await registry.testRegisterAgent(MOCK_AGENT_V1);
+            await registry.testRegisterAgent(MOCK_AGENT_V2);
+            expect(debugLogSpy).not.toHaveBeenCalledWith(`[AgentRegistry] Overriding agent 'MockAgent'`);
+        });
+        it('should handle bulk registrations correctly', async () => {
+            const promises = Array.from({ length: 100 }, (_, i) => registry.testRegisterAgent({
+                ...MOCK_AGENT_V1,
+                name: `Agent${i}`,
+            }));
+            await Promise.all(promises);
+            expect(registry.getAllDefinitions()).toHaveLength(100);
+        });
+    });
+    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 = makeMockedConfig({ model: 'current-model' });
+            const registry = new TestableAgentRegistry(config);
+            const agent = {
+                ...MOCK_AGENT_V1,
+                modelConfig: { ...MOCK_AGENT_V1.modelConfig, model: 'inherit' },
+            };
+            await registry.testRegisterAgent(agent);
+            const resolved = config.modelConfigService.getResolvedConfig({
+                model: getModelConfigAlias(agent),
+            });
+            expect(resolved.model).toBe('current-model');
+        });
+        it('should update inherited models when the main model changes', async () => {
+            const config = makeMockedConfig({ model: 'initial-model' });
+            const registry = new TestableAgentRegistry(config);
+            await registry.initialize();
+            const agent = {
+                ...MOCK_AGENT_V1,
+                name: 'InheritingAgent',
+                modelConfig: { ...MOCK_AGENT_V1.modelConfig, model: 'inherit' },
+            };
+            await registry.testRegisterAgent(agent);
+            // Verify initial state
+            let resolved = config.modelConfigService.getResolvedConfig({
+                model: getModelConfigAlias(agent),
+            });
+            expect(resolved.model).toBe('initial-model');
+            // Change model and emit event
+            vi.spyOn(config, 'getModel').mockReturnValue('new-model');
+            coreEvents.emit(CoreEvent.ModelChanged, {
+                model: 'new-model',
+            });
+            // Since the listener is async but not awaited by emit, we should manually
+            // trigger refresh or wait.
+            await vi.waitFor(() => {
+                const resolved = config.modelConfigService.getResolvedConfig({
+                    model: getModelConfigAlias(agent),
+                });
+                if (resolved.model !== 'new-model') {
+                    throw new Error('Model not updated yet');
+                }
+            });
+            // Verify refreshed state
+            resolved = config.modelConfigService.getResolvedConfig({
+                model: getModelConfigAlias(agent),
+            });
+            expect(resolved.model).toBe('new-model');
+        });
+    });
+    describe('accessors', () => {
+        const ANOTHER_AGENT = {
+            ...MOCK_AGENT_V1,
+            name: 'AnotherAgent',
+        };
+        beforeEach(async () => {
+            await registry.testRegisterAgent(MOCK_AGENT_V1);
+            await registry.testRegisterAgent(ANOTHER_AGENT);
+        });
+        it('getDefinition should return the correct definition', () => {
+            expect(registry.getDefinition('MockAgent')).toEqual(MOCK_AGENT_V1);
+            expect(registry.getDefinition('AnotherAgent')).toEqual(ANOTHER_AGENT);
+        });
+        it('getDefinition should return undefined for unknown agents', () => {
+            expect(registry.getDefinition('NonExistentAgent')).toBeUndefined();
+        });
+        it('getAllDefinitions should return all registered definitions', () => {
+            const all = registry.getAllDefinitions();
+            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('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 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);
+            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
+        });
+    });
+    describe('getDirectoryContext', () => {
+        it('should return default message when no agents are registered', () => {
+            expect(registry.getDirectoryContext()).toContain('No sub-agents are currently available.');
+        });
+        it('should return formatted list of agents when agents are available', async () => {
+            await registry.testRegisterAgent(MOCK_AGENT_V1);
+            await registry.testRegisterAgent({
+                ...MOCK_AGENT_V2,
+                name: 'AnotherAgent',
+                description: 'Another agent description',
+            });
+            const description = registry.getDirectoryContext();
+            expect(description).toContain('Sub-agents are specialized expert agents');
+            expect(description).toContain('Available Sub-Agents');
+            expect(description).toContain(`- ${MOCK_AGENT_V1.name}`);
+            expect(description).toContain(`- AnotherAgent`);
+        });
+    });
+});
+//# sourceMappingURL=registry.test.js.map