import { describe, it, expect, jest, beforeEach } from '@jest/globals';
import { duckCouncilTool } from '../../src/tools/duck-council.js';
import { ProviderManager } from '../../src/providers/manager.js';
// Mock dependencies
jest.mock('../../src/utils/logger');
jest.mock('../../src/providers/manager.js');
describe('duckCouncilTool', () => {
let mockProviderManager: jest.Mocked<ProviderManager>;
const mockResponses = [
{
provider: 'openai',
nickname: 'OpenAI Duck',
content: 'I think TypeScript is great for large projects.',
model: 'gpt-4',
latency: 150,
usage: { prompt_tokens: 10, completion_tokens: 25, total_tokens: 35 },
},
{
provider: 'groq',
nickname: 'Groq Duck',
content: 'TypeScript adds type safety which prevents many bugs.',
model: 'llama-3.1-70b',
latency: 80,
usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
},
];
beforeEach(() => {
mockProviderManager = {
getProviderNames: jest.fn().mockReturnValue(['openai', 'groq']),
duckCouncil: jest.fn().mockResolvedValue(mockResponses),
} as unknown as jest.Mocked<ProviderManager>;
});
it('should throw error when prompt is missing', async () => {
await expect(duckCouncilTool(mockProviderManager, {})).rejects.toThrow(
'Prompt is required for the duck council'
);
});
it('should throw error when no providers available', async () => {
mockProviderManager.getProviderNames.mockReturnValue([]);
await expect(
duckCouncilTool(mockProviderManager, { prompt: 'Test' })
).rejects.toThrow('No ducks available for the council!');
});
it('should convene duck council with prompt', async () => {
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'What is TypeScript?',
});
expect(mockProviderManager.duckCouncil).toHaveBeenCalledWith('What is TypeScript?', {
model: undefined,
});
expect(result.content).toHaveLength(1);
expect(result.content[0].type).toBe('text');
});
it('should display council topic', async () => {
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'What is TypeScript?',
});
expect(result.content[0].text).toContain('Duck Council Topic');
expect(result.content[0].text).toContain('What is TypeScript?');
});
it('should display number of ducks in attendance', async () => {
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('2 ducks in attendance');
});
it('should display each duck response with number', async () => {
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('Duck #1: OpenAI Duck');
expect(result.content[0].text).toContain('Duck #2: Groq Duck');
expect(result.content[0].text).toContain('TypeScript is great');
expect(result.content[0].text).toContain('type safety');
});
it('should display model and latency metadata', async () => {
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('gpt-4');
expect(result.content[0].text).toContain('150ms');
expect(result.content[0].text).toContain('35 tokens');
});
it('should handle error responses from ducks', async () => {
mockProviderManager.duckCouncil.mockResolvedValue([
mockResponses[0],
{
provider: 'groq',
nickname: 'Groq Duck',
content: 'Error: API key invalid',
model: '',
latency: 0,
},
]);
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('Duck had to leave early');
expect(result.content[0].text).toContain('API key invalid');
});
it('should show council summary with success count', async () => {
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('Council Summary');
expect(result.content[0].text).toContain('2/2 ducks provided their wisdom');
});
it('should show partial council message when some fail', async () => {
mockProviderManager.duckCouncil.mockResolvedValue([
mockResponses[0],
{
provider: 'groq',
nickname: 'Groq Duck',
content: 'Error: Timeout',
model: '',
latency: 0,
},
]);
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('1/2 ducks provided their wisdom');
expect(result.content[0].text).toContain('Partial council');
});
it('should pass model option', async () => {
await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
model: 'gpt-3.5-turbo',
});
expect(mockProviderManager.duckCouncil).toHaveBeenCalledWith('Test', {
model: 'gpt-3.5-turbo',
});
});
it('should not show latency when zero', async () => {
mockProviderManager.duckCouncil.mockResolvedValue([
{
...mockResponses[0],
latency: 0,
},
]);
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
});
// Should not show "0ms" in output
expect(result.content[0].text).not.toContain('0ms');
});
it('should not show tokens when usage missing', async () => {
mockProviderManager.duckCouncil.mockResolvedValue([
{
...mockResponses[0],
usage: undefined,
},
]);
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).not.toContain('tokens');
});
it('should use compareDucksWithProgress when progress is provided', async () => {
mockProviderManager.compareDucksWithProgress = jest.fn().mockResolvedValue(mockResponses) as any;
const mockProgress = {
enabled: true,
report: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
};
await duckCouncilTool(mockProviderManager, { prompt: 'Test' }, mockProgress);
expect(mockProviderManager.compareDucksWithProgress).toHaveBeenCalled();
expect(mockProviderManager.duckCouncil).not.toHaveBeenCalled();
});
it('should use duckCouncil when no progress is provided', async () => {
await duckCouncilTool(mockProviderManager, { prompt: 'Test' });
expect(mockProviderManager.duckCouncil).toHaveBeenCalled();
});
it('should show error message when all ducks fail', async () => {
mockProviderManager.duckCouncil.mockResolvedValue([
{
provider: 'openai',
nickname: 'OpenAI Duck',
content: 'Error: Connection timeout',
model: '',
latency: 0,
},
{
provider: 'groq',
nickname: 'Groq Duck',
content: 'Error: API error',
model: '',
latency: 0,
},
]);
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('0/2 ducks provided their wisdom');
// Should not show partial council message
expect(result.content[0].text).not.toContain('Partial council');
});
describe('CLI provider support', () => {
const mockCLIResponses = [
{
provider: 'cli-claude',
nickname: 'Claude Agent',
content: 'CLI Claude council opinion',
model: 'cli',
latency: 5000,
usage: { prompt_tokens: 5, completion_tokens: 15, total_tokens: 20 },
},
{
provider: 'cli-gemini',
nickname: 'Gemini Agent',
content: 'CLI Gemini council opinion',
model: 'cli',
latency: 8000,
// no usage
},
];
it('should handle CLI-only council', async () => {
mockProviderManager.getProviderNames.mockReturnValue(['cli-claude', 'cli-gemini']);
mockProviderManager.duckCouncil.mockResolvedValue(mockCLIResponses);
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'CLI council test',
});
expect(result.content[0].text).toContain('2 ducks in attendance');
expect(result.content[0].text).toContain('Claude Agent');
expect(result.content[0].text).toContain('Gemini Agent');
// Note: duck council shows nickname only, not provider name
expect(result.content[0].text).toContain('CLI Claude council opinion');
expect(result.content[0].text).toContain('CLI Gemini council opinion');
});
it('should display CLI model as "cli"', async () => {
mockProviderManager.getProviderNames.mockReturnValue(['cli-claude']);
mockProviderManager.duckCouncil.mockResolvedValue([mockCLIResponses[0]]);
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('cli');
});
it('should handle CLI response without usage', async () => {
mockProviderManager.getProviderNames.mockReturnValue(['cli-gemini']);
mockProviderManager.duckCouncil.mockResolvedValue([
{
provider: 'cli-gemini',
nickname: 'Gemini Agent',
content: 'Response',
model: 'cli',
latency: 8000,
// no usage field
},
]);
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('Gemini Agent');
expect(result.content[0].text).not.toContain('tokens');
});
it('should handle mixed HTTP and CLI council', async () => {
mockProviderManager.getProviderNames.mockReturnValue(['openai', 'cli-claude']);
mockProviderManager.duckCouncil.mockResolvedValue([
{
provider: 'openai',
nickname: 'GPT Duck',
content: 'HTTP opinion',
model: 'gpt-4',
latency: 500,
usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 },
},
{
provider: 'cli-claude',
nickname: 'Claude Agent',
content: 'CLI opinion',
model: 'cli',
latency: 5000,
usage: { prompt_tokens: 5, completion_tokens: 10, total_tokens: 15 },
},
]);
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Mixed council',
});
expect(result.content[0].text).toContain('2 ducks in attendance');
expect(result.content[0].text).toContain('GPT Duck');
expect(result.content[0].text).toContain('Claude Agent');
expect(result.content[0].text).toContain('gpt-4');
expect(result.content[0].text).toContain('2/2 ducks provided their wisdom');
});
it('should handle CLI error responses', async () => {
mockProviderManager.getProviderNames.mockReturnValue(['cli-claude']);
mockProviderManager.duckCouncil.mockResolvedValue([
{
provider: 'cli-claude',
nickname: 'Claude Agent',
content: 'Error: CLI process timed out',
model: '',
latency: 0,
},
]);
const result = await duckCouncilTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('Duck had to leave early');
expect(result.content[0].text).toContain('CLI process timed out');
expect(result.content[0].text).toContain('0/1 ducks provided their wisdom');
});
});
});
