mcp-rubber-duck 1.9.5 → 1.10.0

package/tests/tools/compare-ducks-ui.test.ts

@@ -0,0 +1,135 @@
+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 structured JSON', () => {
+  let mockProviderManager: jest.Mocked<ProviderManager>;
+
+  const mockResponses = [
+    {
+      provider: 'openai',
+      nickname: 'OpenAI Duck',
+      content: 'TypeScript is great!',
+      model: 'gpt-4',
+      latency: 150,
+      cached: false,
+      usage: {
+        prompt_tokens: 10,
+        completion_tokens: 20,
+        total_tokens: 30,
+      },
+    },
+    {
+      provider: 'groq',
+      nickname: 'Groq Duck',
+      content: 'TypeScript rocks!',
+      model: 'llama-3.1-70b',
+      latency: 80,
+      cached: true,
+      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 return two content items: text and JSON', async () => {
+    const result = await compareDucksTool(mockProviderManager, { prompt: 'Test' });
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[1].type).toBe('text');
+  });
+
+  it('should have valid JSON in the second content item', async () => {
+    const result = await compareDucksTool(mockProviderManager, { prompt: 'Test' });
+
+    const data = JSON.parse(result.content[1].text) as unknown[];
+    expect(Array.isArray(data)).toBe(true);
+  });
+
+  it('should include all provider data in JSON', async () => {
+    const result = await compareDucksTool(mockProviderManager, { prompt: 'Test' });
+
+    const data = JSON.parse(result.content[1].text) as {
+      provider: string;
+      nickname: string;
+      model: string;
+      content: string;
+      latency: number;
+      tokens: { prompt: number; completion: number; total: number } | null;
+      cached: boolean;
+      error?: string;
+    }[];
+
+    expect(data).toHaveLength(2);
+    expect(data[0].provider).toBe('openai');
+    expect(data[0].nickname).toBe('OpenAI Duck');
+    expect(data[0].model).toBe('gpt-4');
+    expect(data[0].content).toBe('TypeScript is great!');
+    expect(data[0].latency).toBe(150);
+    expect(data[0].tokens).toEqual({ prompt: 10, completion: 20, total: 30 });
+    expect(data[0].cached).toBe(false);
+
+    expect(data[1].provider).toBe('groq');
+    expect(data[1].cached).toBe(true);
+  });
+
+  it('should include error info for failed responses', async () => {
+    mockProviderManager.compareDucks.mockResolvedValue([
+      mockResponses[0],
+      {
+        provider: 'groq',
+        nickname: 'Groq Duck',
+        content: 'Error: API key invalid',
+        model: '',
+        latency: 0,
+        cached: false,
+      },
+    ]);
+
+    const result = await compareDucksTool(mockProviderManager, { prompt: 'Test' });
+    const data = JSON.parse(result.content[1].text) as { error?: string }[];
+
+    expect(data[0].error).toBeUndefined();
+    expect(data[1].error).toBe('Error: API key invalid');
+  });
+
+  it('should handle null tokens when usage is missing', async () => {
+    mockProviderManager.compareDucks.mockResolvedValue([
+      {
+        provider: 'openai',
+        nickname: 'OpenAI Duck',
+        content: 'Response',
+        model: 'gpt-4',
+        latency: 100,
+        cached: false,
+      },
+    ]);
+
+    const result = await compareDucksTool(mockProviderManager, { prompt: 'Test' });
+    const data = JSON.parse(result.content[1].text) as { tokens: unknown }[];
+
+    expect(data[0].tokens).toBeNull();
+  });
+
+  it('should preserve text content identical to before', async () => {
+    const result = await compareDucksTool(mockProviderManager, { prompt: 'Test' });
+
+    // First item is text, should contain original format
+    expect(result.content[0].text).toContain('OpenAI Duck');
+    expect(result.content[0].text).toContain('Groq Duck');
+    expect(result.content[0].text).toContain('2/2 ducks responded successfully');
+  });
+});

package/tests/tools/compare-ducks.test.ts

@@ -58,10 +58,12 @@ describe('compareDucksTool', () => {
       undefined,
       { model: undefined }
     );
-    expect(result.content).toHaveLength(1);
+    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 () => {

package/tests/tools/duck-debate-ui.test.ts

@@ -0,0 +1,234 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+
+// Mock OpenAI BEFORE importing
+const mockCreate = jest.fn();
+jest.mock('openai', () => {
+  const MockOpenAI = jest.fn().mockImplementation(() => ({
+    chat: { completions: { create: mockCreate } },
+  }));
+  return { __esModule: true, default: MockOpenAI };
+});
+
+jest.mock('../../src/config/config');
+jest.mock('../../src/utils/logger');
+
+import { duckDebateTool } from '../../src/tools/duck-debate';
+import { ProviderManager } from '../../src/providers/manager';
+import { ConfigManager } from '../../src/config/config';
+
+describe('duckDebateTool structured JSON', () => {
+  let mockProviderManager: ProviderManager;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    const mockConfigManager = {
+      getConfig: jest.fn().mockReturnValue({
+        providers: {
+          openai: {
+            api_key: 'key1',
+            base_url: 'https://api.openai.com/v1',
+            default_model: 'gpt-4',
+            nickname: 'GPT-4',
+            models: ['gpt-4'],
+          },
+          gemini: {
+            api_key: 'key2',
+            base_url: 'https://api.gemini.com/v1',
+            default_model: 'gemini-pro',
+            nickname: 'Gemini',
+            models: ['gemini-pro'],
+          },
+        },
+        default_provider: 'openai',
+        cache_ttl: 300,
+        enable_failover: true,
+        default_temperature: 0.7,
+      }),
+    } as unknown as jest.Mocked<ConfigManager>;
+
+    mockProviderManager = new ProviderManager(mockConfigManager);
+
+    const provider1 = mockProviderManager.getProvider('openai');
+    const provider2 = mockProviderManager.getProvider('gemini');
+    provider1['client'].chat.completions.create = mockCreate;
+    provider2['client'].chat.completions.create = mockCreate;
+  });
+
+  it('should return two content items: text and JSON', async () => {
+    // 1 round, 2 participants + synthesis = 3 calls
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Pro argument' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Con argument' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Synthesis' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      });
+
+    const result = await duckDebateTool(mockProviderManager, {
+      prompt: 'Test topic',
+      format: 'oxford',
+      rounds: 1,
+    });
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[1].type).toBe('text');
+  });
+
+  it('should include debate structure in JSON', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Pro argument' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Con argument' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Final synthesis' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      });
+
+    const result = await duckDebateTool(mockProviderManager, {
+      prompt: 'Microservices vs monolith',
+      format: 'oxford',
+      rounds: 1,
+    });
+
+    const data = JSON.parse(result.content[1].text) as {
+      topic: string;
+      format: string;
+      totalRounds: number;
+      participants: { provider: string; nickname: string; position: string }[];
+      rounds: { round: number; provider: string; nickname: string; position: string; content: string }[][];
+      synthesis: string;
+      synthesizer: string;
+    };
+
+    expect(data.topic).toBe('Microservices vs monolith');
+    expect(data.format).toBe('oxford');
+    expect(data.totalRounds).toBe(1);
+    expect(data.participants).toHaveLength(2);
+    expect(data.participants[0].position).toBe('pro');
+    expect(data.participants[1].position).toBe('con');
+    expect(data.rounds).toHaveLength(1);
+    expect(data.rounds[0]).toHaveLength(2);
+    expect(data.rounds[0][0].content).toBe('Pro argument');
+    expect(data.rounds[0][1].content).toBe('Con argument');
+    expect(data.synthesis).toBe('Final synthesis');
+    expect(data.synthesizer).toBe('openai');
+  });
+
+  it('should assign adversarial positions correctly in JSON', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Defense' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Attack' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Synthesis' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      });
+
+    const result = await duckDebateTool(mockProviderManager, {
+      prompt: 'Is AI dangerous?',
+      format: 'adversarial',
+      rounds: 1,
+    });
+
+    const data = JSON.parse(result.content[1].text) as {
+      format: string;
+      participants: { position: string }[];
+    };
+
+    expect(data.format).toBe('adversarial');
+    // First participant defends (pro), rest challenge (con)
+    expect(data.participants[0].position).toBe('pro');
+    expect(data.participants[1].position).toBe('con');
+  });
+
+  it('should preserve text content alongside JSON', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Pro argument' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Con argument' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Final synthesis' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      });
+
+    const result = await duckDebateTool(mockProviderManager, {
+      prompt: 'Test topic',
+      format: 'oxford',
+      rounds: 1,
+    });
+
+    expect(result.content[0].text).toContain('Oxford Debate');
+    expect(result.content[0].text).toContain('Test topic');
+    expect(result.content[0].text).toContain('Synthesis');
+    expect(result.content[0].text).toContain('ROUND 1');
+  });
+
+  it('should assign socratic positions correctly in JSON', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Question 1' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Response 1' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Synthesis' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      });
+
+    const result = await duckDebateTool(mockProviderManager, {
+      prompt: 'What is truth?',
+      format: 'socratic',
+      rounds: 1,
+    });
+
+    const data = JSON.parse(result.content[1].text) as {
+      format: string;
+      participants: { position: string }[];
+    };
+
+    expect(data.format).toBe('socratic');
+    expect(data.participants[0].position).toBe('neutral');
+    expect(data.participants[1].position).toBe('neutral');
+  });
+});

package/tests/tools/duck-vote-ui.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+
+// Mock OpenAI BEFORE importing
+const mockCreate = jest.fn();
+jest.mock('openai', () => {
+  const MockOpenAI = jest.fn().mockImplementation(() => ({
+    chat: { completions: { create: mockCreate } },
+  }));
+  return { __esModule: true, default: MockOpenAI };
+});
+
+jest.mock('../../src/config/config');
+jest.mock('../../src/utils/logger');
+
+import { duckVoteTool } from '../../src/tools/duck-vote';
+import { ProviderManager } from '../../src/providers/manager';
+import { ConfigManager } from '../../src/config/config';
+
+describe('duckVoteTool structured JSON', () => {
+  let mockProviderManager: ProviderManager;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    const mockConfigManager = {
+      getConfig: jest.fn().mockReturnValue({
+        providers: {
+          openai: {
+            api_key: 'key1',
+            base_url: 'https://api.openai.com/v1',
+            default_model: 'gpt-4',
+            nickname: 'GPT-4',
+            models: ['gpt-4'],
+          },
+          gemini: {
+            api_key: 'key2',
+            base_url: 'https://api.gemini.com/v1',
+            default_model: 'gemini-pro',
+            nickname: 'Gemini',
+            models: ['gemini-pro'],
+          },
+        },
+        default_provider: 'openai',
+        cache_ttl: 300,
+        enable_failover: true,
+        default_temperature: 0.7,
+      }),
+    } as unknown as jest.Mocked<ConfigManager>;
+
+    mockProviderManager = new ProviderManager(mockConfigManager);
+
+    const provider1 = mockProviderManager.getProvider('openai');
+    const provider2 = mockProviderManager.getProvider('gemini');
+    provider1['client'].chat.completions.create = mockCreate;
+    provider2['client'].chat.completions.create = mockCreate;
+  });
+
+  it('should return two content items: text and JSON', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: '{"choice": "A", "confidence": 85, "reasoning": "Solid"}' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: '{"choice": "A", "confidence": 75, "reasoning": "Good"}' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      });
+
+    const result = await duckVoteTool(mockProviderManager, {
+      question: 'Best?',
+      options: ['A', 'B'],
+    });
+
+    expect(result.content).toHaveLength(2);
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[1].type).toBe('text');
+  });
+
+  it('should include vote data in JSON', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: '{"choice": "A", "confidence": 85, "reasoning": "Best"}' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: '{"choice": "A", "confidence": 75, "reasoning": "Good"}' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      });
+
+    const result = await duckVoteTool(mockProviderManager, {
+      question: 'Best approach?',
+      options: ['A', 'B'],
+    });
+
+    const data = JSON.parse(result.content[1].text) as {
+      question: string;
+      options: string[];
+      winner: string | null;
+      isTie: boolean;
+      tally: Record<string, number>;
+      confidenceByOption: Record<string, number>;
+      votes: { voter: string; nickname: string; choice: string; confidence: number; reasoning: string }[];
+      totalVoters: number;
+      validVotes: number;
+      consensusLevel: string;
+    };
+
+    expect(data.question).toBe('Best approach?');
+    expect(data.options).toEqual(['A', 'B']);
+    expect(data.winner).toBe('A');
+    expect(data.consensusLevel).toBe('unanimous');
+    expect(data.tally['A']).toBe(2);
+    expect(data.tally['B']).toBe(0);
+    expect(data.votes).toHaveLength(2);
+    expect(data.votes[0].confidence).toBe(85);
+  });
+
+  it('should reflect tie in JSON data', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: '{"choice": "A", "confidence": 60}' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: '{"choice": "B", "confidence": 90}' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      });
+
+    const result = await duckVoteTool(mockProviderManager, {
+      question: 'Which?',
+      options: ['A', 'B'],
+    });
+
+    const data = JSON.parse(result.content[1].text) as {
+      isTie: boolean;
+      winner: string | null;
+      consensusLevel: string;
+    };
+
+    expect(data.isTie).toBe(true);
+    expect(data.consensusLevel).toBe('split');
+    // Tie-break by confidence: B has 90 vs A has 60
+    expect(data.winner).toBe('B');
+  });
+
+  it('should not include rawResponse in JSON votes', async () => {
+    mockCreate.mockResolvedValueOnce({
+      choices: [{ message: { content: '{"choice": "A", "confidence": 80}' }, finish_reason: 'stop' }],
+      usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+      model: 'gpt-4',
+    });
+
+    const result = await duckVoteTool(mockProviderManager, {
+      question: 'Test?',
+      options: ['A', 'B'],
+      voters: ['openai'],
+    });
+
+    const data = JSON.parse(result.content[1].text) as {
+      votes: Record<string, unknown>[];
+    };
+
+    // rawResponse should not be in the structured output
+    expect(data.votes[0]).not.toHaveProperty('rawResponse');
+  });
+});

package/tests/tools/get-usage-stats.test.ts

@@ -62,9 +62,11 @@ describe('getUsageStatsTool', () => {
       const result = getUsageStatsTool(usageService, { period: 'today' });
 
       expect(result.content).toBeDefined();
-      expect(result.content).toHaveLength(1);
+      expect(result.content).toHaveLength(2);
       expect(result.content[0].type).toBe('text');
       expect(typeof result.content[0].text).toBe('string');
+      expect(result.content[1].type).toBe('text');
+      expect(() => JSON.parse(result.content[1].text)).not.toThrow();
     });
 
     it('should include period label in output', () => {