mcp-rubber-duck 1.5.1 → 1.6.0

package/tests/duck-debate.test.ts

@@ -87,12 +87,39 @@ describe('duckDebateTool', () => {
     ).rejects.toThrow('Rounds must be between 1 and 10');
   });
 
-  it('should throw error when less than 2 providers', async () => {
+  it('should throw error when less than 2 providers specified', async () => {
     await expect(
       duckDebateTool(mockProviderManager, { prompt: 'Test', format: 'oxford', providers: ['openai'] })
     ).rejects.toThrow('At least 2 providers are required');
   });
 
+  it('should throw error when only 1 provider available total', async () => {
+    // Create manager with only 1 provider
+    const singleProviderConfig = {
+      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'],
+          },
+        },
+        default_provider: 'openai',
+        cache_ttl: 300,
+        enable_failover: false,
+        default_temperature: 0.7,
+      }),
+    } as any;
+
+    const singleProviderManager = new ProviderManager(singleProviderConfig);
+
+    await expect(
+      duckDebateTool(singleProviderManager, { prompt: 'Test', format: 'oxford' })
+    ).rejects.toThrow('At least 2 providers are required for a debate');
+  });
+
   it('should throw error when provider does not exist', async () => {
     await expect(
       duckDebateTool(mockProviderManager, { prompt: 'Test', format: 'oxford', providers: ['openai', 'nonexistent'] })
@@ -283,4 +310,81 @@ describe('duckDebateTool', () => {
     const text = result.content[0].text;
     expect(text).toContain('3 rounds completed');
   });
+
+  it('should perform multi-round socratic debate', async () => {
+    // Round 1: 2 participants
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Question round 1' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Response round 1' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      // Round 2 - should use "Build on previous responses" prompt
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Question round 2' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Response round 2' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      // Synthesis
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Socratic 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: 2,
+    });
+
+    const text = result.content[0].text;
+    expect(text).toContain('Socratic Debate');
+    expect(text).toContain('ROUND 1');
+    expect(text).toContain('ROUND 2');
+    expect(text).toContain('2 rounds completed');
+  });
+
+  it('should truncate long arguments in display', async () => {
+    // Create arguments longer than 800 characters
+    const longArgument = 'A'.repeat(900);
+
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: longArgument }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 100, total_tokens: 110 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Short 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',
+      format: 'oxford',
+      rounds: 1,
+    });
+
+    const text = result.content[0].text;
+    expect(text).toContain('[truncated]');
+    // Should not contain the full 900 A's
+    expect(text).not.toContain('A'.repeat(900));
+  });
 });

package/tests/duck-iterate.test.ts

@@ -246,4 +246,34 @@ describe('duckIterateTool', () => {
     expect(mockCreate).toHaveBeenCalledTimes(1);
     expect(result.content[0].text).toContain('1 rounds completed');
   });
+
+  it('should truncate long responses in iteration history', async () => {
+    // Create a response longer than 500 characters
+    const longResponse = 'A'.repeat(600);
+
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: longResponse }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 100, total_tokens: 110 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Short refined response' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      });
+
+    const result = await duckIterateTool(mockProviderManager, {
+      prompt: 'Test',
+      providers: ['openai', 'gemini'],
+      mode: 'refine',
+      iterations: 2,
+    });
+
+    const text = result.content[0].text;
+    // Should contain truncated indicator for the long response in history
+    expect(text).toContain('[truncated]');
+    // Final response section should have the short refined response
+    expect(text).toContain('Short refined response');
+  });
 });

package/tests/duck-judge.test.ts

@@ -293,4 +293,97 @@ describe('duckJudgeTool', () => {
     expect(text).toContain('gemini');
     expect(text).toContain('Not evaluated');
   });
+
+  it('should throw error when no judge provider available', async () => {
+    // Mock getProviderNames to return empty array
+    const originalGetProviderNames = mockProviderManager.getProviderNames;
+    mockProviderManager.getProviderNames = jest.fn().mockReturnValue([]);
+
+    await expect(
+      duckJudgeTool(mockProviderManager, {
+        responses: mockResponses,
+      })
+    ).rejects.toThrow('No judge provider available');
+
+    // Restore original
+    mockProviderManager.getProviderNames = originalGetProviderNames;
+  });
+
+  it('should handle malformed JSON that throws parse error', async () => {
+    // JSON that looks valid but has syntax errors
+    mockCreate.mockResolvedValueOnce({
+      choices: [{
+        message: { content: '{"rankings": [{"provider": "openai", score: invalid}]}' },
+        finish_reason: 'stop',
+      }],
+      usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 },
+      model: 'gpt-4',
+    });
+
+    const result = await duckJudgeTool(mockProviderManager, {
+      responses: mockResponses,
+    });
+
+    const text = result.content[0].text;
+    // Should use fallback evaluation
+    expect(text).toContain('Judge Evaluation');
+    expect(text).toContain('Unable to parse');
+  });
+
+  it('should match provider by nickname in rankings', async () => {
+    // Use nickname instead of provider name
+    const judgeResponse = JSON.stringify({
+      rankings: [
+        { provider: 'GPT-4', score: 85, justification: 'Good response' },
+        { provider: 'Gemini', score: 75, justification: 'Okay response' },
+      ],
+      summary: 'Matched by nickname.',
+    });
+
+    mockCreate.mockResolvedValueOnce({
+      choices: [{
+        message: { content: judgeResponse },
+        finish_reason: 'stop',
+      }],
+      usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 },
+      model: 'gpt-4',
+    });
+
+    const result = await duckJudgeTool(mockProviderManager, {
+      responses: mockResponses,
+    });
+
+    const text = result.content[0].text;
+    expect(text).toContain('85/100');
+    expect(text).toContain('75/100');
+  });
+
+  it('should match provider by contained name in rankings', async () => {
+    // Use partial name that contains the provider name
+    const judgeResponse = JSON.stringify({
+      rankings: [
+        { provider: 'the openai model', score: 90, justification: 'Excellent' },
+        { provider: 'google gemini response', score: 80, justification: 'Good' },
+      ],
+      summary: 'Matched by contained name.',
+    });
+
+    mockCreate.mockResolvedValueOnce({
+      choices: [{
+        message: { content: judgeResponse },
+        finish_reason: 'stop',
+      }],
+      usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 },
+      model: 'gpt-4',
+    });
+
+    const result = await duckJudgeTool(mockProviderManager, {
+      responses: mockResponses,
+    });
+
+    const text = result.content[0].text;
+    // Should successfully match the providers
+    expect(text).toContain('90/100');
+    expect(text).toContain('80/100');
+  });
 });

package/tests/duck-vote.test.ts

@@ -247,4 +247,50 @@ describe('duckVoteTool', () => {
 
     expect(result.content[0].text).toContain('Option A');
   });
+
+  it('should throw error when no voters available', async () => {
+    // Mock getProviderNames to return empty array
+    const originalGetProviderNames = mockProviderManager.getProviderNames;
+    mockProviderManager.getProviderNames = jest.fn().mockReturnValue([]);
+
+    await expect(
+      duckVoteTool(mockProviderManager, {
+        question: 'Test?',
+        options: ['Option A', 'Option B'],
+      })
+    ).rejects.toThrow('No voters available');
+
+    // Restore original
+    mockProviderManager.getProviderNames = originalGetProviderNames;
+  });
+
+  it('should handle case when no valid votes result in no winner', async () => {
+    // Both responses don't mention any valid option
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{
+          message: { content: 'I cannot decide between these options.' },
+          finish_reason: 'stop',
+        }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{
+          message: { content: 'These options are not comparable.' },
+          finish_reason: 'stop',
+        }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      });
+
+    const result = await duckVoteTool(mockProviderManager, {
+      question: 'Test?',
+      options: ['Option A', 'Option B'],
+    });
+
+    const text = result.content[0].text;
+    expect(text).toContain('No valid votes');
+    expect(text).toContain('0/2 valid votes');
+  });
 });

package/tests/health.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { HealthMonitor } from '../src/services/health.js';
+import { ProviderManager } from '../src/providers/manager.js';
+import { ProviderHealth } from '../src/config/types.js';
+
+// Mock dependencies
+jest.mock('../src/utils/logger');
+jest.mock('../src/providers/manager.js');
+
+describe('HealthMonitor', () => {
+  let healthMonitor: HealthMonitor;
+  let mockProviderManager: jest.Mocked<ProviderManager>;
+
+  beforeEach(() => {
+    // Create a mock ProviderManager
+    mockProviderManager = {
+      checkHealth: jest.fn(),
+    } as unknown as jest.Mocked<ProviderManager>;
+
+    healthMonitor = new HealthMonitor(mockProviderManager);
+  });
+
+  describe('performHealthChecks', () => {
+    it('should call providerManager.checkHealth and return results', async () => {
+      const healthResults: ProviderHealth[] = [
+        {
+          provider: 'openai',
+          healthy: true,
+          latency: 150,
+          lastCheck: new Date(),
+        },
+        {
+          provider: 'groq',
+          healthy: true,
+          latency: 80,
+          lastCheck: new Date(),
+        },
+      ];
+
+      mockProviderManager.checkHealth.mockResolvedValue(healthResults);
+
+      const results = await healthMonitor.performHealthChecks();
+
+      expect(mockProviderManager.checkHealth).toHaveBeenCalledTimes(1);
+      expect(results).toEqual(healthResults);
+      expect(results).toHaveLength(2);
+    });
+
+    it('should handle unhealthy providers with errors', async () => {
+      const healthResults: ProviderHealth[] = [
+        {
+          provider: 'openai',
+          healthy: true,
+          latency: 150,
+          lastCheck: new Date(),
+        },
+        {
+          provider: 'groq',
+          healthy: false,
+          lastCheck: new Date(),
+          error: 'Connection refused',
+        },
+      ];
+
+      mockProviderManager.checkHealth.mockResolvedValue(healthResults);
+
+      const results = await healthMonitor.performHealthChecks();
+
+      expect(results).toHaveLength(2);
+      expect(results[0].healthy).toBe(true);
+      expect(results[1].healthy).toBe(false);
+      expect(results[1].error).toBe('Connection refused');
+    });
+
+    it('should handle all unhealthy providers', async () => {
+      const healthResults: ProviderHealth[] = [
+        {
+          provider: 'openai',
+          healthy: false,
+          lastCheck: new Date(),
+          error: 'API key invalid',
+        },
+        {
+          provider: 'groq',
+          healthy: false,
+          lastCheck: new Date(),
+          error: 'Timeout',
+        },
+      ];
+
+      mockProviderManager.checkHealth.mockResolvedValue(healthResults);
+
+      const results = await healthMonitor.performHealthChecks();
+
+      expect(results.every((r) => !r.healthy)).toBe(true);
+    });
+
+    it('should handle empty provider list', async () => {
+      mockProviderManager.checkHealth.mockResolvedValue([]);
+
+      const results = await healthMonitor.performHealthChecks();
+
+      expect(results).toEqual([]);
+    });
+
+    it('should handle providers without latency info', async () => {
+      const healthResults: ProviderHealth[] = [
+        {
+          provider: 'openai',
+          healthy: false,
+          lastCheck: new Date(),
+          error: 'Failed before timing',
+        },
+      ];
+
+      mockProviderManager.checkHealth.mockResolvedValue(healthResults);
+
+      const results = await healthMonitor.performHealthChecks();
+
+      expect(results[0].latency).toBeUndefined();
+    });
+
+    it('should propagate errors from checkHealth', async () => {
+      mockProviderManager.checkHealth.mockRejectedValue(new Error('Network error'));
+
+      await expect(healthMonitor.performHealthChecks()).rejects.toThrow('Network error');
+    });
+  });
+});