import { describe, it, expect, jest, beforeEach } from '@jest/globals';
import { compareDucksTool } from '../../src/tools/compare-ducks.js';
import { ProviderManager } from '../../src/providers/manager.js';
// Mock dependencies
jest.mock('../../src/utils/logger');
jest.mock('../../src/providers/manager.js');
describe('compareDucksTool', () => {
let mockProviderManager: jest.Mocked<ProviderManager>;
const mockResponses = [
{
provider: 'openai',
nickname: 'OpenAI Duck',
content: 'OpenAI says: TypeScript is great!',
model: 'gpt-4',
latency: 150,
usage: {
prompt_tokens: 10,
completion_tokens: 20,
total_tokens: 30,
},
},
{
provider: 'groq',
nickname: 'Groq Duck',
content: 'Groq says: TypeScript rocks!',
model: 'llama-3.1-70b',
latency: 80,
usage: {
prompt_tokens: 10,
completion_tokens: 15,
total_tokens: 25,
},
},
];
beforeEach(() => {
mockProviderManager = {
compareDucks: jest.fn().mockResolvedValue(mockResponses),
} as unknown as jest.Mocked<ProviderManager>;
});
it('should throw error when prompt is missing', async () => {
await expect(compareDucksTool(mockProviderManager, {})).rejects.toThrow('Prompt is required');
});
it('should compare ducks with basic prompt', async () => {
const result = await compareDucksTool(mockProviderManager, {
prompt: 'What is TypeScript?',
});
expect(mockProviderManager.compareDucks).toHaveBeenCalledWith(
'What is TypeScript?',
undefined,
{ model: undefined }
);
expect(result.content).toHaveLength(2);
expect(result.content[0].type).toBe('text');
expect(result.content[0].text).toContain('Asked:');
expect(result.content[0].text).toContain('What is TypeScript?');
expect(result.content[1].type).toBe('text');
expect(() => JSON.parse(result.content[1].text)).not.toThrow();
});
it('should display all duck responses', async () => {
const result = await compareDucksTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('OpenAI Duck');
expect(result.content[0].text).toContain('Groq Duck');
expect(result.content[0].text).toContain('OpenAI says');
expect(result.content[0].text).toContain('Groq says');
});
it('should display model and token usage', async () => {
const result = await compareDucksTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('gpt-4');
expect(result.content[0].text).toContain('llama-3.1-70b');
expect(result.content[0].text).toContain('Tokens: 30');
expect(result.content[0].text).toContain('Tokens: 25');
});
it('should display latency info', async () => {
const result = await compareDucksTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('150ms');
expect(result.content[0].text).toContain('80ms');
});
it('should show success count in summary', async () => {
const result = await compareDucksTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('2/2 ducks responded successfully');
});
it('should handle error responses', async () => {
mockProviderManager.compareDucks.mockResolvedValue([
mockResponses[0],
{
provider: 'groq',
nickname: 'Groq Duck',
content: 'Error: API key invalid',
model: '',
latency: 0,
},
]);
const result = await compareDucksTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('Error: API key invalid');
expect(result.content[0].text).toContain('1/2 ducks responded successfully');
});
it('should pass specific providers when provided', async () => {
await compareDucksTool(mockProviderManager, {
prompt: 'Test',
providers: ['openai', 'groq'],
});
expect(mockProviderManager.compareDucks).toHaveBeenCalledWith('Test', ['openai', 'groq'], {
model: undefined,
});
});
it('should pass model option', async () => {
await compareDucksTool(mockProviderManager, {
prompt: 'Test',
model: 'gpt-3.5-turbo',
});
expect(mockProviderManager.compareDucks).toHaveBeenCalledWith('Test', undefined, {
model: 'gpt-3.5-turbo',
});
});
it('should handle empty response list', async () => {
mockProviderManager.compareDucks.mockResolvedValue([]);
const result = await compareDucksTool(mockProviderManager, {
prompt: 'Test',
});
expect(result.content[0].text).toContain('0/0 ducks responded successfully');
});
it('should not show latency when zero', async () => {
mockProviderManager.compareDucks.mockResolvedValue([
{
...mockResponses[0],
latency: 0,
},
]);
const result = await compareDucksTool(mockProviderManager, {
prompt: 'Test',
});
// When latency is 0, the ms indicator should not be shown for that response
// (the code checks latency > 0)
expect(result.content[0].text).not.toContain('0ms');
});
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 compareDucksTool(mockProviderManager, { prompt: 'Test' }, mockProgress);
expect(mockProviderManager.compareDucksWithProgress).toHaveBeenCalled();
expect(mockProviderManager.compareDucks).not.toHaveBeenCalled();
});
it('should use compareDucks when no progress is provided', async () => {
await compareDucksTool(mockProviderManager, { prompt: 'Test' });
expect(mockProviderManager.compareDucks).toHaveBeenCalled();
});
describe('CLI provider support', () => {
const mockCLIResponses = [
{
provider: 'cli-claude',
nickname: 'Claude Agent',
content: 'CLI Claude response',
model: 'cli',
latency: 5000,
usage: {
prompt_tokens: 5,
completion_tokens: 10,
total_tokens: 15,
},
},
{
provider: 'cli-gemini',
nickname: 'Gemini Agent',
content: 'CLI Gemini response',
model: 'cli',
latency: 8000,
},
];
it('should handle CLI-only providers', async () => {
mockProviderManager.compareDucks.mockResolvedValue(mockCLIResponses);
const result = await compareDucksTool(mockProviderManager, {
prompt: 'Test CLI',
providers: ['cli-claude', 'cli-gemini'],
});
expect(mockProviderManager.compareDucks).toHaveBeenCalledWith(
'Test CLI',
['cli-claude', 'cli-gemini'],
{ model: undefined }
);
expect(result.content[0].text).toContain('Claude Agent');
expect(result.content[0].text).toContain('Gemini Agent');
expect(result.content[0].text).toContain('cli-claude');
expect(result.content[0].text).toContain('cli-gemini');
});
it('should display CLI responses with model as "cli"', async () => {
mockProviderManager.compareDucks.mockResolvedValue(mockCLIResponses);
const result = await compareDucksTool(mockProviderManager, {
prompt: 'Test',
providers: ['cli-claude'],
});
expect(result.content[0].text).toContain('Model: cli');
});
it('should handle CLI response without usage info', async () => {
mockProviderManager.compareDucks.mockResolvedValue([
{
provider: 'cli-gemini',
nickname: 'Gemini Agent',
content: 'Response without usage',
model: 'cli',
latency: 8000,
// no usage field
},
]);
const result = await compareDucksTool(mockProviderManager, {
prompt: 'Test',
});
// Should not crash, should display response
expect(result.content[0].text).toContain('Gemini Agent');
expect(result.content[0].text).toContain('Response without usage');
// Should not contain "Tokens:" since no usage
expect(result.content[0].text).not.toMatch(/Tokens:\s*\|/);
});
it('should handle mixed HTTP and CLI providers', async () => {
mockProviderManager.compareDucks.mockResolvedValue([
{
provider: 'openai',
nickname: 'GPT Duck',
content: 'HTTP response',
model: 'gpt-4',
latency: 500,
usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 },
},
{
provider: 'cli-claude',
nickname: 'Claude Agent',
content: 'CLI response',
model: 'cli',
latency: 5000,
usage: { prompt_tokens: 5, completion_tokens: 10, total_tokens: 15 },
},
]);
const result = await compareDucksTool(mockProviderManager, {
prompt: 'Mixed test',
providers: ['openai', 'cli-claude'],
});
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('Model: cli');
expect(result.content[0].text).toContain('2/2 ducks responded successfully');
});
it('should include CLI responses in structured JSON output', async () => {
mockProviderManager.compareDucks.mockResolvedValue(mockCLIResponses);
const result = await compareDucksTool(mockProviderManager, {
prompt: 'Test',
providers: ['cli-claude', 'cli-gemini'],
});
const structuredData = JSON.parse(result.content[1].text);
expect(structuredData).toHaveLength(2);
expect(structuredData[0].provider).toBe('cli-claude');
expect(structuredData[0].model).toBe('cli');
expect(structuredData[1].provider).toBe('cli-gemini');
expect(structuredData[1].tokens).toBeNull(); // gemini has no usage
});
});
});
