/**
 * @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 { 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';
import { A2AAuthProviderFactory } from './auth-provider/factory.js';
vi.mock('./agentLoader.js', () => ({
    loadAgentsFromDirectory: vi
        .fn()
        .mockResolvedValue({ agents: [], errors: [] }),
}));
vi.mock('./a2a-client-manager.js', () => ({
    A2AClientManager: vi.fn(),
}));
vi.mock('./auth-provider/factory.js', () => ({
    A2AAuthProviderFactory: {
        create: vi.fn(),
        validateAuthConfig: vi.fn().mockReturnValue({ valid: true }),
        describeRequiredAuth: vi.fn().mockReturnValue('API key required'),
    },
}));
function makeMockedConfig(params) {
    const config = makeFakeConfig(params);
    vi.spyOn(config, 'getToolRegistry').mockReturnValue({
        getAllToolNames: () => ['tool1', 'tool2'],
    });
    vi.spyOn(config, 'getAgentRegistry').mockReturnValue({
        getDirectoryContext: () => 'mock directory context',
        getAllDefinitions: () => [],
    });
    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 },
                        generalist: { 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 register generalist agent by default', async () => {
            const config = makeMockedConfig();
            const registry = new TestableAgentRegistry(config);
            await registry.initialize();
            expect(registry.getDefinition('generalist')).toBeDefined();
        });
        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.spyOn(mockConfig, 'getA2AClientManager').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.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: vi.fn().mockResolvedValue({ name: 'RemoteAgent' }),
            });
            await registry.testRegisterAgent(remoteAgent);
            expect(registry.getDefinition('RemoteAgent')).toEqual(remoteAgent);
        });
        it('should register a remote agent with authentication configuration', async () => {
            const mockAuth = {
                type: 'http',
                scheme: 'Bearer',
                token: 'secret-token',
            };
            const remoteAgent = {
                kind: 'remote',
                name: 'RemoteAgentWithAuth',
                description: 'A remote agent',
                agentCardUrl: 'https://example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
                auth: mockAuth,
            };
            const mockHandler = {
                type: 'http',
                headers: vi
                    .fn()
                    .mockResolvedValue({ Authorization: 'Bearer secret-token' }),
                shouldRetryWithHeaders: vi.fn(),
            };
            vi.mocked(A2AAuthProviderFactory.create).mockResolvedValue(mockHandler);
            const loadAgentSpy = vi
                .fn()
                .mockResolvedValue({ name: 'RemoteAgentWithAuth' });
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: loadAgentSpy,
                clearCache: vi.fn(),
            });
            await registry.testRegisterAgent(remoteAgent);
            expect(A2AAuthProviderFactory.create).toHaveBeenCalledWith({
                authConfig: mockAuth,
                agentName: 'RemoteAgentWithAuth',
                targetUrl: 'https://example.com/card',
                agentCardUrl: 'https://example.com/card',
            });
            expect(loadAgentSpy).toHaveBeenCalledWith('RemoteAgentWithAuth', 'https://example.com/card', mockHandler);
            expect(registry.getDefinition('RemoteAgentWithAuth')).toEqual(remoteAgent);
        });
        it('should not register remote agent when auth provider factory returns undefined', async () => {
            const remoteAgent = {
                kind: 'remote',
                name: 'RemoteAgentBadAuth',
                description: 'A remote agent',
                agentCardUrl: 'https://example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
                auth: {
                    type: 'http',
                    scheme: 'Bearer',
                    token: 'secret-token',
                },
            };
            vi.mocked(A2AAuthProviderFactory.create).mockResolvedValue(undefined);
            const loadAgentSpy = vi.fn();
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: loadAgentSpy,
                clearCache: vi.fn(),
            });
            const warnSpy = vi
                .spyOn(debugLogger, 'warn')
                .mockImplementation(() => { });
            await registry.testRegisterAgent(remoteAgent);
            expect(loadAgentSpy).not.toHaveBeenCalled();
            expect(registry.getDefinition('RemoteAgentBadAuth')).toBeUndefined();
            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Error loading A2A agent'), expect.any(Error));
            warnSpy.mockRestore();
        });
        it('should log remote agent registration in debug mode', async () => {
            const debugConfig = makeMockedConfig({ debugMode: true });
            const debugRegistry = new TestableAgentRegistry(debugConfig);
            vi.spyOn(debugConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: vi.fn().mockResolvedValue({ name: 'RemoteAgent' }),
            });
            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' } },
            };
            await debugRegistry.testRegisterAgent(remoteAgent);
            expect(debugLogSpy).toHaveBeenCalledWith(`[AgentRegistry] Registered remote agent 'RemoteAgent' with card: https://example.com/card`);
        });
        it('should emit error feedback with userMessage when A2AAgentError is thrown', async () => {
            const { AgentConnectionError } = await import('./a2a-errors.js');
            const feedbackSpy = vi
                .spyOn(coreEvents, 'emitFeedback')
                .mockImplementation(() => { });
            const remoteAgent = {
                kind: 'remote',
                name: 'FailAgent',
                description: 'An agent that fails to load',
                agentCardUrl: 'https://unreachable.example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
            };
            const a2aError = new AgentConnectionError('FailAgent', 'https://unreachable.example.com/card', new Error('ECONNREFUSED'));
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: vi.fn().mockRejectedValue(a2aError),
            });
            await registry.testRegisterAgent(remoteAgent);
            expect(feedbackSpy).toHaveBeenCalledWith('error', `[FailAgent] ${a2aError.userMessage}`);
            expect(registry.getDefinition('FailAgent')).toBeUndefined();
        });
        it('should emit generic error feedback for non-A2AAgentError failures', async () => {
            const feedbackSpy = vi
                .spyOn(coreEvents, 'emitFeedback')
                .mockImplementation(() => { });
            const remoteAgent = {
                kind: 'remote',
                name: 'FailAgent',
                description: 'An agent that fails',
                agentCardUrl: 'https://example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
            };
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: vi.fn().mockRejectedValue(new Error('unexpected crash')),
            });
            await registry.testRegisterAgent(remoteAgent);
            expect(feedbackSpy).toHaveBeenCalledWith('error', '[FailAgent] Failed to load remote agent: unexpected crash');
            expect(registry.getDefinition('FailAgent')).toBeUndefined();
        });
        it('should emit warning feedback when auth config is missing for secured agent', async () => {
            const feedbackSpy = vi
                .spyOn(coreEvents, 'emitFeedback')
                .mockImplementation(() => { });
            vi.mocked(A2AAuthProviderFactory.validateAuthConfig).mockReturnValue({
                valid: false,
                diff: { requiredSchemes: ['api_key'], missingConfig: ['api_key'] },
            });
            vi.mocked(A2AAuthProviderFactory.describeRequiredAuth).mockReturnValue('apiKey (header: x-api-key)');
            const remoteAgent = {
                kind: 'remote',
                name: 'SecuredAgent',
                description: 'A secured remote agent',
                agentCardUrl: 'https://example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
                // No auth configured
            };
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: vi.fn().mockResolvedValue({
                    name: 'SecuredAgent',
                    securitySchemes: {
                        api_key: {
                            type: 'apiKey',
                            in: 'header',
                            name: 'x-api-key',
                        },
                    },
                }),
            });
            await registry.testRegisterAgent(remoteAgent);
            // Agent should still be registered (ADC fallback)
            expect(registry.getDefinition('SecuredAgent')).toBeDefined();
            // But a warning should have been emitted
            expect(feedbackSpy).toHaveBeenCalledWith('warning', expect.stringContaining('SecuredAgent'));
        });
        it('should surface an error if remote agent registration fails', async () => {
            const remoteAgent = {
                kind: 'remote',
                name: 'FailingRemoteAgent',
                description: 'A remote agent',
                agentCardUrl: 'https://example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
            };
            const error = new Error('401 Unauthorized');
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: vi.fn().mockRejectedValue(error),
            });
            const feedbackSpy = vi.spyOn(coreEvents, 'emitFeedback');
            await registry.testRegisterAgent(remoteAgent);
            expect(feedbackSpy).toHaveBeenCalledWith('error', `[FailingRemoteAgent] Failed to load remote agent: 401 Unauthorized`);
        });
        it('should merge user and agent description and skills when registering a remote agent', async () => {
            const remoteAgent = {
                kind: 'remote',
                name: 'RemoteAgentWithDescription',
                description: 'User-provided description',
                agentCardUrl: 'https://example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
            };
            const mockAgentCard = {
                name: 'RemoteAgentWithDescription',
                description: 'Card-provided description',
                skills: [
                    { name: 'Skill1', description: 'Desc1' },
                    { name: 'Skill2', description: 'Desc2' },
                ],
            };
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: vi.fn().mockResolvedValue(mockAgentCard),
                clearCache: vi.fn(),
            });
            await registry.testRegisterAgent(remoteAgent);
            const registered = registry.getDefinition('RemoteAgentWithDescription');
            expect(registered?.description).toBe('User Description: User-provided description\nAgent Description: Card-provided description\nSkills:\nSkill1: Desc1\nSkill2: Desc2');
        });
        it('should include skills when agent description is empty', async () => {
            const remoteAgent = {
                kind: 'remote',
                name: 'RemoteAgentWithSkillsOnly',
                description: 'User-provided description',
                agentCardUrl: 'https://example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
            };
            const mockAgentCard = {
                name: 'RemoteAgentWithSkillsOnly',
                description: '',
                skills: [{ name: 'Skill1', description: 'Desc1' }],
            };
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: vi.fn().mockResolvedValue(mockAgentCard),
                clearCache: vi.fn(),
            });
            await registry.testRegisterAgent(remoteAgent);
            const registered = registry.getDefinition('RemoteAgentWithSkillsOnly');
            expect(registered?.description).toBe('User Description: User-provided description\nSkills:\nSkill1: Desc1');
        });
        it('should handle empty user or agent descriptions and no skills during merging', async () => {
            const remoteAgent = {
                kind: 'remote',
                name: 'RemoteAgentWithEmptyAgentDescription',
                description: 'User-provided description',
                agentCardUrl: 'https://example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
            };
            const mockAgentCard = {
                name: 'RemoteAgentWithEmptyAgentDescription',
                description: '', // Empty agent description
                skills: [],
            };
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: vi.fn().mockResolvedValue(mockAgentCard),
                clearCache: vi.fn(),
            });
            await registry.testRegisterAgent(remoteAgent);
            const registered = registry.getDefinition('RemoteAgentWithEmptyAgentDescription');
            // Should only contain user description
            expect(registered?.description).toBe('User Description: User-provided description');
        });
        it('should not accumulate descriptions on repeated registration', async () => {
            const remoteAgent = {
                kind: 'remote',
                name: 'RemoteAgentAccumulationTest',
                description: 'User-provided description',
                agentCardUrl: 'https://example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
            };
            const mockAgentCard = {
                name: 'RemoteAgentAccumulationTest',
                description: 'Card-provided description',
                skills: [{ name: 'Skill1', description: 'Desc1' }],
            };
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: vi.fn().mockResolvedValue(mockAgentCard),
                clearCache: vi.fn(),
            });
            // Register first time
            await registry.testRegisterAgent(remoteAgent);
            let registered = registry.getDefinition('RemoteAgentAccumulationTest');
            const firstDescription = registered?.description;
            expect(firstDescription).toBe('User Description: User-provided description\nAgent Description: Card-provided description\nSkills:\nSkill1: Desc1');
            // Register second time with the SAME object
            await registry.testRegisterAgent(remoteAgent);
            registered = registry.getDefinition('RemoteAgentAccumulationTest');
            expect(registered?.description).toBe(firstDescription);
        });
        it('should allow registering a remote agent with an empty initial description', async () => {
            const remoteAgent = {
                kind: 'remote',
                name: 'EmptyDescAgent',
                description: '', // Empty initial description
                agentCardUrl: 'https://example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
            };
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: vi.fn().mockResolvedValue({
                    name: 'EmptyDescAgent',
                    description: 'Loaded from card',
                }),
                clearCache: vi.fn(),
            });
            await registry.testRegisterAgent(remoteAgent);
            const registered = registry.getDefinition('EmptyDescAgent');
            expect(registered?.description).toBe('Agent Description: Loaded from card');
        });
        it('should provide fallback for skill descriptions if missing in the card', async () => {
            const remoteAgent = {
                kind: 'remote',
                name: 'SkillFallbackAgent',
                description: 'User description',
                agentCardUrl: 'https://example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
            };
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: vi.fn().mockResolvedValue({
                    name: 'SkillFallbackAgent',
                    description: 'Card description',
                    skills: [{ name: 'SkillNoDesc' }], // Missing description
                }),
                clearCache: vi.fn(),
            });
            await registry.testRegisterAgent(remoteAgent);
            const registered = registry.getDefinition('SkillFallbackAgent');
            expect(registered?.description).toContain('SkillNoDesc: No description provided');
        });
        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);
        });
        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.spyOn(mockConfig, 'getA2AClientManager').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.spyOn(mockConfig, 'getA2AClientManager').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.spyOn(config, 'getA2AClientManager').mockReturnValue({
                clearCache: clearCacheSpy,
                loadAgent: vi.fn(),
                getClient: vi.fn(),
            });
            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 skip remote agents when refreshing on model change', async () => {
            const remoteAgent = {
                kind: 'remote',
                name: 'RemoteAgent',
                description: 'A remote agent',
                agentCardUrl: 'https://example.com/card',
                inputConfig: { inputSchema: { type: 'object' } },
            };
            const loadAgentSpy = vi.fn().mockResolvedValue({ name: 'RemoteAgent' });
            vi.spyOn(mockConfig, 'getA2AClientManager').mockReturnValue({
                loadAgent: loadAgentSpy,
                clearCache: vi.fn(),
            });
            await registry.testRegisterAgent(remoteAgent);
            expect(loadAgentSpy).toHaveBeenCalledTimes(1);
            coreEvents.emitModelChanged('new-model');
            await new Promise((resolve) => setTimeout(resolve, 0));
            expect(loadAgentSpy).toHaveBeenCalledTimes(1);
        });
        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
        });
    });
});
//# sourceMappingURL=registry.test.js.map