mcp-rubber-duck 1.10.0 → 1.11.0

package/src/tools/duck-council.ts

@@ -1,10 +1,12 @@
 import { ProviderManager } from '../providers/manager.js';
 import { duckArt, getRandomDuckMessage } from '../utils/ascii-art.js';
 import { logger } from '../utils/logger.js';
+import type { ProgressReporter } from '../services/progress.js';
 
 export async function duckCouncilTool(
   providerManager: ProviderManager,
-  args: Record<string, unknown>
+  args: Record<string, unknown>,
+  progress?: ProgressReporter
 ) {
   const { prompt, model } = args as {
     prompt?: string;
@@ -19,13 +21,22 @@ export async function duckCouncilTool(
 
   // Get all available ducks
   const allProviders = providerManager.getProviderNames();
-  
+
   if (allProviders.length === 0) {
     throw new Error('No ducks available for the council!');
   }
 
-  // Get responses from all ducks
-  const responses = await providerManager.duckCouncil(prompt, { model });
+  // Get responses from all ducks, reporting progress as each completes
+  const responses = progress
+    ? await providerManager.compareDucksWithProgress(
+        prompt,
+        undefined,
+        { model },
+        (providerName, completed, total) => {
+          void progress.report(completed, total, `${providerName} responded (${completed}/${total})`);
+        }
+      )
+    : await providerManager.duckCouncil(prompt, { model });
 
   // Build council response with a panel discussion format
   let response = `${duckArt.panel}\n\n`;

package/src/tools/duck-debate.ts

@@ -7,6 +7,7 @@ import {
   DebateResult,
 } from '../config/types.js';
 import { logger } from '../utils/logger.js';
+import type { ProgressReporter } from '../services/progress.js';
 
 export interface DuckDebateArgs {
   prompt: string;
@@ -20,7 +21,9 @@ const DEFAULT_ROUNDS = 3;
 
 export async function duckDebateTool(
   providerManager: ProviderManager,
-  args: Record<string, unknown>
+  args: Record<string, unknown>,
+  progress?: ProgressReporter,
+  signal?: AbortSignal
 ) {
   const {
     prompt,
@@ -73,13 +76,23 @@ export async function duckDebateTool(
 
   // Run debate rounds
   const debateRounds: DebateArgument[][] = [];
+  const totalSteps = rounds * participants.length + 1; // +1 for synthesis
+  let completedSteps = 0;
 
   for (let roundNum = 1; roundNum <= rounds; roundNum++) {
+    if (signal?.aborted) {
+      throw new Error('Task cancelled');
+    }
+
     logger.info(`Debate round ${roundNum}/${rounds}`);
     const roundArguments: DebateArgument[] = [];
 
     // Each participant argues in this round
     for (const participant of participants) {
+      if (signal?.aborted) {
+        throw new Error('Task cancelled');
+      }
+
       const argumentPrompt = buildArgumentPrompt(
         prompt,
         format,
@@ -99,16 +112,33 @@ export async function duckDebateTool(
         content: response.content,
         timestamp: new Date(),
       });
+
+      completedSteps++;
+      if (progress) {
+        void progress.report(
+          completedSteps,
+          totalSteps,
+          `Round ${roundNum}/${rounds}: ${participant.nickname} (${participant.position})`
+        );
+      }
     }
 
     debateRounds.push(roundArguments);
   }
 
+  if (signal?.aborted) {
+    throw new Error('Task cancelled');
+  }
+
   // Generate synthesis
   const synthesizerProvider = synthesizer || debateProviders[0];
   const synthesisPrompt = buildSynthesisPrompt(prompt, format, debateRounds, participants);
   const synthesisResponse = await providerManager.askDuck(synthesizerProvider, synthesisPrompt);
 
+  if (progress) {
+    void progress.report(totalSteps, totalSteps, 'Synthesis complete');
+  }
+
   const result: DebateResult = {
     topic: prompt,
     format,

package/src/tools/duck-iterate.ts

@@ -1,6 +1,7 @@
 import { ProviderManager } from '../providers/manager.js';
 import { IterationRound, IterationResult } from '../config/types.js';
 import { logger } from '../utils/logger.js';
+import type { ProgressReporter } from '../services/progress.js';
 
 export interface DuckIterateArgs {
   prompt: string;
@@ -14,7 +15,9 @@ const CONVERGENCE_THRESHOLD = 0.8; // 80% similarity indicates convergence
 
 export async function duckIterateTool(
   providerManager: ProviderManager,
-  args: Record<string, unknown>
+  args: Record<string, unknown>,
+  progress?: ProgressReporter,
+  signal?: AbortSignal
 ) {
   const {
     prompt,
@@ -54,6 +57,10 @@ export async function duckIterateTool(
   let lastResponse = '';
   let converged = false;
 
+  if (signal?.aborted) {
+    throw new Error('Task cancelled');
+  }
+
   // Round 1: Initial generation by provider A
   const initialResponse = await providerManager.askDuck(providers[0], prompt);
   const providerAInfo = providerManager.getProvider(providers[0]);
@@ -70,8 +77,16 @@ export async function duckIterateTool(
   lastResponse = initialResponse.content;
   logger.info(`Round 1: ${providers[0]} generated initial response`);
 
+  if (progress) {
+    void progress.report(1, iterations, `Round 1/${iterations}: ${providers[0]} generated`);
+  }
+
   // Subsequent rounds: Alternate between providers
   for (let i = 2; i <= iterations; i++) {
+    if (signal?.aborted) {
+      throw new Error('Task cancelled');
+    }
+
     const isProviderA = i % 2 === 1;
     const currentProvider = isProviderA ? providers[0] : providers[1];
     const providerInfo = providerManager.getProvider(currentProvider);
@@ -100,6 +115,10 @@ export async function duckIterateTool(
     lastResponse = response.content;
     logger.info(`Round ${i}: ${currentProvider} ${role === 'critic' ? 'critiqued' : 'refined'}`);
 
+    if (progress) {
+      void progress.report(i, iterations, `Round ${i}/${iterations}: ${currentProvider} ${role}`);
+    }
+
     if (converged) {
       break;
     }

package/src/tools/duck-vote.ts

@@ -2,6 +2,7 @@ import { ProviderManager } from '../providers/manager.js';
 import { ConsensusService } from '../services/consensus.js';
 import { VoteResult } from '../config/types.js';
 import { logger } from '../utils/logger.js';
+import type { ProgressReporter } from '../services/progress.js';
 
 export interface DuckVoteArgs {
   question: string;
@@ -12,7 +13,8 @@ export interface DuckVoteArgs {
 
 export async function duckVoteTool(
   providerManager: ProviderManager,
-  args: Record<string, unknown>
+  args: Record<string, unknown>,
+  progress?: ProgressReporter
 ) {
   const {
     question,
@@ -52,8 +54,17 @@ export async function duckVoteTool(
     require_reasoning
   );
 
-  // Get votes from all ducks in parallel
-  const responses = await providerManager.compareDucks(votePrompt, voterNames);
+  // Get votes from all ducks in parallel, reporting progress as each votes
+  const responses = progress
+    ? await providerManager.compareDucksWithProgress(
+        votePrompt,
+        voterNames,
+        undefined,
+        (providerName, completed, total) => {
+          void progress.report(completed, total, `${providerName} voted (${completed}/${total})`);
+        }
+      )
+    : await providerManager.compareDucks(votePrompt, voterNames);
 
   // Parse votes
   const votes: VoteResult[] = responses.map(response => {

package/tests/duck-debate.test.ts

@@ -389,4 +389,84 @@ describe('duckDebateTool', () => {
     // Should not contain the full 900 A's
     expect(text).not.toContain('A'.repeat(900));
   });
+
+  it('should throw when signal is already aborted before starting', async () => {
+    const controller = new AbortController();
+    controller.abort();
+
+    await expect(
+      duckDebateTool(mockProviderManager, {
+        prompt: 'Test',
+        format: 'oxford',
+      }, undefined, controller.signal)
+    ).rejects.toThrow('Task cancelled');
+  });
+
+  it('should throw when signal is aborted between rounds', async () => {
+    const controller = new AbortController();
+    let callCount = 0;
+
+    // Use mockImplementation so we can abort after round 1 completes
+    mockCreate.mockImplementation(async () => {
+      callCount++;
+      // After both participants in round 1 finish (2 calls), abort
+      if (callCount === 2) {
+        controller.abort();
+      }
+      return {
+        choices: [{ message: { content: `Response ${callCount}` }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      };
+    });
+
+    await expect(
+      duckDebateTool(mockProviderManager, {
+        prompt: 'Test',
+        format: 'oxford',
+        rounds: 3,
+      }, undefined, controller.signal)
+    ).rejects.toThrow('Task cancelled');
+
+    // Only round 1 calls (2 participants), round 2 was never started
+    expect(mockCreate).toHaveBeenCalledTimes(2);
+  });
+
+  it('should report progress when a ProgressReporter is provided', async () => {
+    const mockProgress = {
+      enabled: true,
+      report: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    };
+
+    // 1 round, 2 participants + synthesis = 3 calls
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'PRO' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'CON' }, 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',
+      });
+
+    await duckDebateTool(mockProviderManager, {
+      prompt: 'Test',
+      format: 'oxford',
+      rounds: 1,
+    }, mockProgress);
+
+    // 2 participants + 1 synthesis = 3 progress reports
+    expect(mockProgress.report).toHaveBeenCalledTimes(3);
+    // Total steps = 1 round * 2 participants + 1 synthesis = 3
+    expect(mockProgress.report).toHaveBeenNthCalledWith(1, 1, 3, expect.stringContaining('Round 1/1'));
+    expect(mockProgress.report).toHaveBeenNthCalledWith(2, 2, 3, expect.stringContaining('Round 1/1'));
+    expect(mockProgress.report).toHaveBeenNthCalledWith(3, 3, 3, 'Synthesis complete');
+  });
 });

package/tests/duck-iterate.test.ts

@@ -276,4 +276,85 @@ describe('duckIterateTool', () => {
     // Final response section should have the short refined response
     expect(text).toContain('Short refined response');
   });
+
+  it('should throw when signal is already aborted', async () => {
+    const controller = new AbortController();
+    controller.abort();
+
+    await expect(
+      duckIterateTool(mockProviderManager, {
+        prompt: 'Test',
+        providers: ['openai', 'gemini'],
+        mode: 'refine',
+      }, undefined, controller.signal)
+    ).rejects.toThrow('Task cancelled');
+  });
+
+  it('should throw when signal is aborted between iterations', async () => {
+    const controller = new AbortController();
+    let callCount = 0;
+
+    // Use mockImplementation so we can abort after round 1 completes
+    mockCreate.mockImplementation(async () => {
+      callCount++;
+      // After round 1 (first call = initial generation), abort
+      if (callCount === 1) {
+        controller.abort();
+      }
+      return {
+        choices: [{ message: { content: `Response ${callCount}` }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      };
+    });
+
+    await expect(
+      duckIterateTool(mockProviderManager, {
+        prompt: 'Test',
+        providers: ['openai', 'gemini'],
+        mode: 'refine',
+        iterations: 3,
+      }, undefined, controller.signal)
+    ).rejects.toThrow('Task cancelled');
+
+    // Only 1 call (initial generation), round 2 was never started
+    expect(mockCreate).toHaveBeenCalledTimes(1);
+  });
+
+  it('should report progress when a ProgressReporter is provided', async () => {
+    const mockProgress = {
+      enabled: true,
+      report: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    };
+
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Initial response' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Refined response' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      })
+      .mockResolvedValueOnce({
+        choices: [{ message: { content: 'Final refinement' }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      });
+
+    await duckIterateTool(mockProviderManager, {
+      prompt: 'Test prompt',
+      providers: ['openai', 'gemini'],
+      mode: 'refine',
+      iterations: 3,
+    }, mockProgress);
+
+    // 3 rounds = 3 progress reports
+    expect(mockProgress.report).toHaveBeenCalledTimes(3);
+    expect(mockProgress.report).toHaveBeenNthCalledWith(1, 1, 3, expect.stringContaining('Round 1/3'));
+    expect(mockProgress.report).toHaveBeenNthCalledWith(2, 2, 3, expect.stringContaining('Round 2/3'));
+    expect(mockProgress.report).toHaveBeenNthCalledWith(3, 3, 3, expect.stringContaining('Round 3/3'));
+  });
 });

package/tests/duck-vote.test.ts

@@ -266,6 +266,76 @@ describe('duckVoteTool', () => {
     mockProviderManager.getProviderNames = originalGetProviderNames;
   });
 
+  it('should use compareDucksWithProgress when progress is provided', async () => {
+    const mockProgress = {
+      enabled: true,
+      report: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    };
+
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{
+          message: { content: '{"choice": "Option A", "confidence": 80, "reasoning": "Good"}' },
+          finish_reason: 'stop',
+        }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{
+          message: { content: '{"choice": "Option A", "confidence": 75, "reasoning": "Also good"}' },
+          finish_reason: 'stop',
+        }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      });
+
+    await duckVoteTool(mockProviderManager, {
+      question: 'Best approach?',
+      options: ['Option A', 'Option B'],
+    }, mockProgress);
+
+    // 2 voters = 2 progress reports
+    expect(mockProgress.report).toHaveBeenCalledTimes(2);
+    expect(mockProgress.report).toHaveBeenNthCalledWith(1, 1, 2, expect.stringContaining('voted'));
+    expect(mockProgress.report).toHaveBeenNthCalledWith(2, 2, 2, expect.stringContaining('voted'));
+  });
+
+  it('should use compareDucks when no progress is provided', async () => {
+    mockCreate
+      .mockResolvedValueOnce({
+        choices: [{
+          message: { content: '{"choice": "Option A", "confidence": 80}' },
+          finish_reason: 'stop',
+        }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gpt-4',
+      })
+      .mockResolvedValueOnce({
+        choices: [{
+          message: { content: '{"choice": "Option A", "confidence": 75}' },
+          finish_reason: 'stop',
+        }],
+        usage: { prompt_tokens: 10, completion_tokens: 20, total_tokens: 30 },
+        model: 'gemini-pro',
+      });
+
+    // Spy on compareDucks to ensure it's called (not compareDucksWithProgress)
+    const compareDucksSpy = jest.spyOn(mockProviderManager, 'compareDucks');
+    const compareDucksWithProgressSpy = jest.spyOn(mockProviderManager, 'compareDucksWithProgress');
+
+    await duckVoteTool(mockProviderManager, {
+      question: 'Best approach?',
+      options: ['Option A', 'Option B'],
+    });
+
+    expect(compareDucksSpy).toHaveBeenCalled();
+    expect(compareDucksWithProgressSpy).not.toHaveBeenCalled();
+
+    compareDucksSpy.mockRestore();
+    compareDucksWithProgressSpy.mockRestore();
+  });
+
   it('should handle case when no valid votes result in no winner', async () => {
     // Both responses don't mention any valid option
     mockCreate

package/tests/providers.test.ts

@@ -371,6 +371,127 @@ describe('ProviderManager', () => {
   });
 });
 
+describe('ProviderManager compareDucksWithProgress', () => {
+  let manager: ProviderManager;
+  let mockConfigManager: jest.Mocked<ConfigManager>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockCreate.mockResolvedValue({
+      choices: [{
+        message: { content: 'Mocked response' },
+        finish_reason: 'stop',
+      }],
+      usage: {
+        prompt_tokens: 10,
+        completion_tokens: 20,
+        total_tokens: 30,
+      },
+      model: 'mock-model',
+    });
+
+    mockConfigManager = {
+      getConfig: jest.fn().mockReturnValue({
+        providers: {
+          test1: {
+            api_key: 'key1',
+            base_url: 'https://api1.test.com/v1',
+            default_model: 'model1',
+            nickname: 'Duck 1',
+            models: ['model1'],
+          },
+          test2: {
+            api_key: 'key2',
+            base_url: 'https://api2.test.com/v1',
+            default_model: 'model2',
+            nickname: 'Duck 2',
+            models: ['model2'],
+          },
+        },
+        default_provider: 'test1',
+        cache_ttl: 300,
+        enable_failover: true,
+        default_temperature: 0.7,
+      }),
+    } as any;
+
+    manager = new ProviderManager(mockConfigManager);
+
+    const provider1 = manager.getProvider('test1');
+    const provider2 = manager.getProvider('test2');
+    provider1['client'].chat.completions.create = mockCreate;
+    provider2['client'].chat.completions.create = mockCreate;
+  });
+
+  it('should call onProviderComplete for each provider', async () => {
+    const onComplete = jest.fn();
+
+    await manager.compareDucksWithProgress('Hello', ['test1', 'test2'], undefined, onComplete);
+
+    expect(onComplete).toHaveBeenCalledTimes(2);
+    // First call: completed=1, total=2
+    expect(onComplete).toHaveBeenNthCalledWith(1, expect.any(String), 1, 2);
+    // Second call: completed=2, total=2
+    expect(onComplete).toHaveBeenNthCalledWith(2, expect.any(String), 2, 2);
+  });
+
+  it('should return responses from all providers', async () => {
+    const onComplete = jest.fn();
+
+    const responses = await manager.compareDucksWithProgress('Hello', ['test1', 'test2'], undefined, onComplete);
+
+    expect(responses).toHaveLength(2);
+    expect(responses[0].provider).toBe('test1');
+    expect(responses[1].provider).toBe('test2');
+    expect(responses[0].content).toBe('Mocked response');
+  });
+
+  it('should use all providers when providerNames is undefined', async () => {
+    const onComplete = jest.fn();
+
+    const responses = await manager.compareDucksWithProgress('Hello', undefined, undefined, onComplete);
+
+    expect(responses).toHaveLength(2);
+    expect(onComplete).toHaveBeenCalledTimes(2);
+  });
+
+  it('should call onProviderComplete even when a provider errors', async () => {
+    const provider1 = manager.getProvider('test1');
+    provider1['client'].chat.completions.create = jest.fn().mockRejectedValue(new Error('API Error'));
+
+    const onComplete = jest.fn();
+
+    const responses = await manager.compareDucksWithProgress('Hello', ['test1', 'test2'], undefined, onComplete);
+
+    // Both callbacks should fire (error path included via .catch().then())
+    expect(onComplete).toHaveBeenCalledTimes(2);
+    expect(responses).toHaveLength(2);
+    expect(responses[0].content).toContain('Error');
+    expect(responses[1].content).toBe('Mocked response');
+  });
+
+  it('should throw when no valid providers specified', async () => {
+    const onComplete = jest.fn();
+
+    await expect(
+      manager.compareDucksWithProgress('Hello', ['nonexistent'], undefined, onComplete)
+    ).rejects.toThrow('No valid providers specified');
+
+    expect(onComplete).not.toHaveBeenCalled();
+  });
+
+  it('should pass options through to askDuck', async () => {
+    const onComplete = jest.fn();
+    const askDuckSpy = jest.spyOn(manager, 'askDuck');
+
+    await manager.compareDucksWithProgress('Hello', ['test1'], { model: 'custom-model' }, onComplete);
+
+    expect(askDuckSpy).toHaveBeenCalledWith('test1', 'Hello', { model: 'custom-model' });
+    askDuckSpy.mockRestore();
+  });
+});
+
 describe('ProviderManager Error Cases', () => {
   it('should throw error when no default provider and none specified', () => {
     const mockConfigManager = {