mcp-rubber-duck 1.10.0 → 1.11.0

package/dist/tools/duck-vote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"duck-vote.d.ts","sourceRoot":"","sources":["../../src/tools/duck-vote.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAK1D,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,wBAAsB,YAAY,CAChC,eAAe,EAAE,eAAe,EAChC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;GAgG9B"}
+{"version":3,"file":"duck-vote.d.ts","sourceRoot":"","sources":["../../src/tools/duck-vote.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAI1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,wBAAsB,YAAY,CAChC,eAAe,EAAE,eAAe,EAChC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,QAAQ,CAAC,EAAE,gBAAgB;;;;;GAyG5B"}

package/dist/tools/duck-vote.js

@@ -1,6 +1,6 @@
 import { ConsensusService } from '../services/consensus.js';
 import { logger } from '../utils/logger.js';
-export async function duckVoteTool(providerManager, args) {
+export async function duckVoteTool(providerManager, args, progress) {
     const { question, options, voters, require_reasoning = true, } = args;
     // Validate inputs
     if (!question || typeof question !== 'string') {
@@ -22,8 +22,12 @@ export async function duckVoteTool(providerManager, args) {
     logger.info(`Starting vote with ${voterNames.length} voters on: "${question}"`);
     const consensusService = new ConsensusService();
     const votePrompt = consensusService.buildVotePrompt(question, options, 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 = responses.map(response => {
         return consensusService.parseVote(response.content, response.provider, response.nickname, options);

package/dist/tools/duck-vote.js.map

@@ -1 +1 @@
-{"version":3,"file":"duck-vote.js","sourceRoot":"","sources":["../../src/tools/duck-vote.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"duck-vote.js","sourceRoot":"","sources":["../../src/tools/duck-vote.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-rubber-duck",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "An MCP server that bridges to multiple OpenAI-compatible LLMs - your AI rubber duck debugging panel",
   "main": "dist/index.js",
   "type": "module",

package/src/providers/enhanced-manager.ts

@@ -209,6 +209,55 @@ export class EnhancedProviderManager extends ProviderManager {
     return Promise.all(promises);
   }
 
+  async compareDucksWithProgressMCP(
+    prompt: string,
+    providerNames: string[] | undefined,
+    options: Partial<ChatOptions> | undefined,
+    onProviderComplete: (providerName: string, completed: number, total: number) => void
+  ): Promise<Array<DuckResponse & { pendingApprovals?: { id: string; message: string }[]; mcpResults?: MCPResult[] }>> {
+    if (!this.mcpEnabled) {
+      return this.compareDucksWithProgress(prompt, providerNames, options, onProviderComplete);
+    }
+
+    const providersToUse = providerNames
+      ? providerNames.map(name => this.enhancedProviders.get(name)).filter(Boolean)
+      : Array.from(this.enhancedProviders.values());
+
+    if (providersToUse.length === 0) {
+      throw new Error('No valid enhanced providers specified');
+    }
+
+    const total = providersToUse.length;
+    let completed = 0;
+
+    const promises = providersToUse.map(provider =>
+      provider ? this.askDuckWithMCP(provider.name, prompt, options)
+        .catch(error => ({
+          provider: provider.name,
+          nickname: provider.nickname,
+          model: '',
+          content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+          latency: 0,
+          cached: false,
+        }))
+        .then(result => {
+          completed++;
+          onProviderComplete(provider.name, completed, total);
+          return result;
+        })
+      : Promise.resolve({
+          provider: 'unknown',
+          nickname: 'Unknown',
+          model: '',
+          content: 'Error: Invalid provider',
+          latency: 0,
+          cached: false,
+        })
+    );
+
+    return Promise.all(promises);
+  }
+
   async duckCouncilWithMCP(
     prompt: string,
     options?: Partial<ChatOptions>

package/src/providers/manager.ts

@@ -183,6 +183,51 @@ export class ProviderManager {
     return Promise.all(promises);
   }
 
+  async compareDucksWithProgress(
+    prompt: string,
+    providerNames: string[] | undefined,
+    options: Partial<ChatOptions> | undefined,
+    onProviderComplete: (providerName: string, completed: number, total: number) => void
+  ): Promise<DuckResponse[]> {
+    const providersToUse = providerNames
+      ? providerNames.map(name => this.providers.get(name)).filter(Boolean)
+      : Array.from(this.providers.values());
+
+    if (providersToUse.length === 0) {
+      throw new Error('No valid providers specified');
+    }
+
+    const total = providersToUse.length;
+    let completed = 0;
+
+    const promises = providersToUse.map(provider =>
+      provider ? this.askDuck(provider.name, prompt, options)
+        .catch(error => ({
+          provider: provider.name,
+          nickname: provider.nickname,
+          model: '',
+          content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+          latency: 0,
+          cached: false,
+        }))
+        .then(result => {
+          completed++;
+          onProviderComplete(provider.name, completed, total);
+          return result;
+        })
+      : Promise.resolve({
+          provider: 'unknown',
+          nickname: 'Unknown',
+          model: '',
+          content: 'Error: Invalid provider',
+          latency: 0,
+          cached: false,
+        })
+    );
+
+    return Promise.all(promises);
+  }
+
   async duckCouncil(
     prompt: string,
     options?: Partial<ChatOptions>

package/src/server.ts

@@ -24,6 +24,8 @@ import { DuckResponse } from './config/types.js';
 import { ApprovalService } from './services/approval.js';
 import { FunctionBridge } from './services/function-bridge.js';
 import { GuardrailsService } from './guardrails/service.js';
+import { TaskManager } from './services/task-manager.js';
+import { createProgressReporter } from './services/progress.js';
 import { logger } from './utils/logger.js';
 import { duckArt, getRandomDuckMessage } from './utils/ascii-art.js';
 
@@ -69,13 +71,32 @@ export class RubberDuckServer {
   private functionBridge?: FunctionBridge;
   private mcpEnabled: boolean = false;
 
+  // Task management
+  private taskManager: TaskManager;
+
   constructor() {
+    this.taskManager = new TaskManager();
+
     this.server = new McpServer(
       {
         name: 'mcp-rubber-duck',
         version: '1.0.0',
       },
-      {}
+      {
+        capabilities: {
+          tasks: {
+            list: {},
+            cancel: {},
+            requests: {
+              tools: { call: {} },
+            },
+          },
+        },
+        taskStore: this.taskManager.taskStore,
+        taskMessageQueue: this.taskManager.taskMessageQueue,
+        defaultTaskPollInterval: this.taskManager.config.pollInterval,
+        maxTaskQueueSize: this.taskManager.config.maxQueueSize,
+      }
     );
 
     // Initialize managers
@@ -313,12 +334,13 @@ export class RubberDuckServer {
         },
         _meta: { ui: { resourceUri: 'ui://rubber-duck/compare-ducks' } },
       },
-      async (args) => {
+      async (args, extra) => {
         try {
+          const progress = createProgressReporter(extra._meta?.progressToken, extra.sendNotification);
           if (this.mcpEnabled && this.enhancedProviderManager) {
-            return this.toolResult(await this.handleCompareDucksWithMCP(args as Record<string, unknown>));
+            return this.toolResult(await this.handleCompareDucksWithMCP(args as Record<string, unknown>, progress));
           }
-          return this.toolResult(await compareDucksTool(this.providerManager, args as Record<string, unknown>));
+          return this.toolResult(await compareDucksTool(this.providerManager, args as Record<string, unknown>, progress));
         } catch (error) {
           return this.toolErrorResult(error);
         }
@@ -339,12 +361,13 @@ export class RubberDuckServer {
           openWorldHint: true,
         },
       },
-      async (args) => {
+      async (args, extra) => {
         try {
+          const progress = createProgressReporter(extra._meta?.progressToken, extra.sendNotification);
           if (this.mcpEnabled && this.enhancedProviderManager) {
-            return this.toolResult(await this.handleDuckCouncilWithMCP(args as Record<string, unknown>));
+            return this.toolResult(await this.handleDuckCouncilWithMCP(args as Record<string, unknown>, progress));
           }
-          return this.toolResult(await duckCouncilTool(this.providerManager, args as Record<string, unknown>));
+          return this.toolResult(await duckCouncilTool(this.providerManager, args as Record<string, unknown>, progress));
         } catch (error) {
           return this.toolErrorResult(error);
         }
@@ -369,9 +392,10 @@ export class RubberDuckServer {
         },
         _meta: { ui: { resourceUri: 'ui://rubber-duck/duck-vote' } },
       },
-      async (args) => {
+      async (args, extra) => {
         try {
-          return this.toolResult(await duckVoteTool(this.providerManager, args as Record<string, unknown>));
+          const progress = createProgressReporter(extra._meta?.progressToken, extra.sendNotification);
+          return this.toolResult(await duckVoteTool(this.providerManager, args as Record<string, unknown>, progress));
         } catch (error) {
           return this.toolErrorResult(error);
         }
@@ -408,8 +432,8 @@ export class RubberDuckServer {
       }
     );
 
-    // duck_iterate
-    this.server.registerTool(
+    // duck_iterate (task-based: supports async execution for long-running iterations)
+    this.server.experimental.tasks.registerToolTask(
       'duck_iterate',
       {
         description: 'Iteratively refine a response between two ducks. One generates, the other critiques/improves, alternating for multiple rounds.',
@@ -423,19 +447,36 @@ export class RubberDuckServer {
           readOnlyHint: true,
           openWorldHint: true,
         },
+        execution: {
+          taskSupport: 'optional',
+        },
       },
-      async (args) => {
-        try {
-          return this.toolResult(await duckIterateTool(this.providerManager, args as Record<string, unknown>));
-        } catch (error) {
-          return this.toolErrorResult(error);
-        }
+      {
+        createTask: async (args, extra) => {
+          const task = await extra.taskStore.createTask({
+            ttl: this.taskManager.config.defaultTtl,
+            pollInterval: this.taskManager.config.pollInterval,
+          });
+          const progress = createProgressReporter(extra._meta?.progressToken, extra.sendNotification);
+          this.taskManager.startBackground(task.taskId, async (signal) => {
+            return this.toolResult(
+              await duckIterateTool(this.providerManager, args as Record<string, unknown>, progress, signal)
+            );
+          });
+          return { task };
+        },
+        getTask: async (_args, extra) => {
+          const task = await extra.taskStore.getTask(extra.taskId);
+          return task;
+        },
+        getTaskResult: async (_args, extra) => {
+          return await extra.taskStore.getTaskResult(extra.taskId) as CallToolResult;
+        },
       }
     );
 
-    // duck_debate
-    registerAppTool(
-      this.server,
+    // duck_debate (task-based: supports async execution for multi-round debates)
+    this.server.experimental.tasks.registerToolTask(
       'duck_debate',
       {
         description: 'Structured multi-round debate between ducks. Supports oxford (pro/con), socratic (questioning), and adversarial (attack/defend) formats.',
@@ -451,13 +492,31 @@ export class RubberDuckServer {
           openWorldHint: true,
         },
         _meta: { ui: { resourceUri: 'ui://rubber-duck/duck-debate' } },
+        execution: {
+          taskSupport: 'optional',
+        },
       },
-      async (args) => {
-        try {
-          return this.toolResult(await duckDebateTool(this.providerManager, args as Record<string, unknown>));
-        } catch (error) {
-          return this.toolErrorResult(error);
-        }
+      {
+        createTask: async (args, extra) => {
+          const task = await extra.taskStore.createTask({
+            ttl: this.taskManager.config.defaultTtl,
+            pollInterval: this.taskManager.config.pollInterval,
+          });
+          const progress = createProgressReporter(extra._meta?.progressToken, extra.sendNotification);
+          this.taskManager.startBackground(task.taskId, async (signal) => {
+            return this.toolResult(
+              await duckDebateTool(this.providerManager, args as Record<string, unknown>, progress, signal)
+            );
+          });
+          return { task };
+        },
+        getTask: async (_args, extra) => {
+          const task = await extra.taskStore.getTask(extra.taskId);
+          return task;
+        },
+        getTaskResult: async (_args, extra) => {
+          return await extra.taskStore.getTaskResult(extra.taskId) as CallToolResult;
+        },
       }
     );
 
@@ -677,7 +736,7 @@ export class RubberDuckServer {
     };
   }
 
-  private async handleCompareDucksWithMCP(args: Record<string, unknown>) {
+  private async handleCompareDucksWithMCP(args: Record<string, unknown>, progress?: import('./services/progress.js').ProgressReporter) {
     if (!this.enhancedProviderManager) {
       throw new Error('Enhanced provider manager not available');
     }
@@ -688,9 +747,16 @@ export class RubberDuckServer {
       model?: string;
     };
 
-    const responses = await this.enhancedProviderManager.compareDucksWithMCP(prompt, providers, {
-      model,
-    });
+    const responses = progress
+      ? await this.enhancedProviderManager.compareDucksWithProgressMCP(
+          prompt,
+          providers,
+          { model },
+          (providerName, completed, total) => {
+            void progress.report(completed, total, `${providerName} responded (${completed}/${total})`);
+          }
+        )
+      : await this.enhancedProviderManager.compareDucksWithMCP(prompt, providers, { model });
 
     const formattedResponse = responses
       .map((response) => this.formatEnhancedDuckResponse(response))
@@ -726,14 +792,23 @@ export class RubberDuckServer {
     };
   }
 
-  private async handleDuckCouncilWithMCP(args: Record<string, unknown>) {
+  private async handleDuckCouncilWithMCP(args: Record<string, unknown>, progress?: import('./services/progress.js').ProgressReporter) {
     if (!this.enhancedProviderManager) {
       throw new Error('Enhanced provider manager not available');
     }
 
     const { prompt, model } = args as { prompt: string; model?: string };
 
-    const responses = await this.enhancedProviderManager.duckCouncilWithMCP(prompt, { model });
+    const responses = progress
+      ? await this.enhancedProviderManager.compareDucksWithProgressMCP(
+          prompt,
+          undefined,
+          { model },
+          (providerName, completed, total) => {
+            void progress.report(completed, total, `${providerName} responded (${completed}/${total})`);
+          }
+        )
+      : await this.enhancedProviderManager.duckCouncilWithMCP(prompt, { model });
 
     const header = '🦆 Duck Council in Session 🦆\n=============================';
     const formattedResponse = responses
@@ -839,6 +914,9 @@ export class RubberDuckServer {
   }
 
   async stop() {
+    // Cleanup task manager (cancel active tasks, clear timers)
+    this.taskManager.shutdown();
+
     // Cleanup usage service (flush pending writes)
     this.usageService.shutdown();
 

package/src/services/progress.ts

@@ -0,0 +1,59 @@
+/**
+ * Progress notification service for MCP tools.
+ *
+ * Provides a lightweight abstraction over MCP's stable `notifications/progress`
+ * mechanism. Tool functions accept an optional `ProgressReporter` to emit
+ * per-step progress without depending on the full `RequestHandlerExtra` type.
+ */
+
+export interface ProgressReporter {
+  /** Report that step `current` of `total` is done, with an optional status message. */
+  report(current: number, total: number, message?: string): Promise<void>;
+  /** Whether the client actually requested progress (sent a progressToken). */
+  readonly enabled: boolean;
+}
+
+/**
+ * Creates a `ProgressReporter` from an MCP tool handler's `extra` parameter.
+ *
+ * If the client did not include a `progressToken` in `_meta`, the returned
+ * reporter is a no-op (`.enabled === false`), so callers can always call
+ * `progress.report()` unconditionally.
+ *
+ * @param progressToken   Value of `extra._meta?.progressToken`
+ * @param sendNotification  Value of `extra.sendNotification` — typed loosely to
+ *   avoid coupling to SDK's strict discriminated union. At runtime the SDK
+ *   accepts any valid JSON-RPC notification including `notifications/progress`.
+ */
+export function createProgressReporter(
+  progressToken: string | number | undefined,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  sendNotification: (notification: any) => Promise<void>
+): ProgressReporter {
+  if (progressToken === undefined) {
+    return {
+      enabled: false,
+      report: async () => {},
+    };
+  }
+
+  return {
+    enabled: true,
+    report: async (current: number, total: number, message?: string) => {
+      try {
+        await sendNotification({
+          method: 'notifications/progress',
+          params: {
+            progressToken,
+            progress: current,
+            total,
+            ...(message !== undefined ? { message } : {}),
+          },
+        });
+      } catch {
+        // Swallow notification errors (e.g., client disconnected).
+        // Progress is best-effort — tool execution should continue regardless.
+      }
+    },
+  };
+}

package/src/services/task-manager.ts

@@ -0,0 +1,162 @@
+/**
+ * Task lifecycle adapter wrapping the MCP SDK's experimental Tasks API.
+ *
+ * This module isolates all direct usage of `@modelcontextprotocol/sdk/experimental`
+ * behind a single adapter class so that future breaking changes in the experimental
+ * API only require updates here.
+ */
+
+import {
+  InMemoryTaskStore,
+  InMemoryTaskMessageQueue,
+} from '@modelcontextprotocol/sdk/experimental';
+import type {
+  TaskStore,
+  TaskMessageQueue,
+} from '@modelcontextprotocol/sdk/experimental';
+import type { CallToolResult, Result } from '@modelcontextprotocol/sdk/types.js';
+import { logger } from '../utils/logger.js';
+
+export interface TaskManagerConfig {
+  /** Time-to-live for completed task results (milliseconds). */
+  defaultTtl: number;
+  /** Suggested interval between client polls (milliseconds). */
+  pollInterval: number;
+  /** Maximum messages per task queue (prevents unbounded growth). */
+  maxQueueSize: number;
+  /** Interval for cleanup/monitoring sweep (milliseconds). */
+  cleanupInterval: number;
+}
+
+const DEFAULT_CONFIG: TaskManagerConfig = {
+  defaultTtl: 300_000,       // 5 minutes
+  pollInterval: 2_000,       // 2 seconds
+  maxQueueSize: 100,
+  cleanupInterval: 60_000,   // 1 minute
+};
+
+/**
+ * Manages MCP task lifecycle: creation, background execution, cancellation, and cleanup.
+ *
+ * - Provides `InMemoryTaskStore` and `InMemoryTaskMessageQueue` instances for
+ *   `McpServer`'s `ProtocolOptions`.
+ * - Tracks active background work via `AbortController` per task for cancellation.
+ * - Handles graceful shutdown (cancels active tasks, clears timers).
+ */
+export class TaskManager {
+  readonly taskStore: TaskStore;
+  readonly taskMessageQueue: TaskMessageQueue;
+  readonly config: TaskManagerConfig;
+
+  /** Maps taskId → AbortController for active background work. */
+  private activeControllers: Map<string, AbortController> = new Map();
+  private cleanupTimer?: ReturnType<typeof setInterval>;
+
+  constructor(config?: Partial<TaskManagerConfig>) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.taskStore = new InMemoryTaskStore();
+    this.taskMessageQueue = new InMemoryTaskMessageQueue();
+    this.startCleanup();
+  }
+
+  /**
+   * Start background work for a task.
+   *
+   * This is fire-and-forget: the returned promise resolves immediately.
+   * The `work` function runs asynchronously; its result is stored in the
+   * task store on completion. On error the task is marked `failed`.
+   * On abort (cancellation) the task is marked `cancelled`.
+   *
+   * @param taskId    ID of the task (from `taskStore.createTask`)
+   * @param work      Async function receiving an `AbortSignal` and returning a `CallToolResult`
+   */
+  startBackground(
+    taskId: string,
+    work: (signal: AbortSignal) => Promise<CallToolResult>
+  ): void {
+    const controller = new AbortController();
+    this.activeControllers.set(taskId, controller);
+
+    void (async () => {
+      try {
+        await this.taskStore.updateTaskStatus(taskId, 'working');
+        const result = await work(controller.signal);
+
+        if (!controller.signal.aborted) {
+          await this.taskStore.storeTaskResult(taskId, 'completed', result as Result);
+        } else {
+          // Work completed but cancellation was requested mid-execution.
+          // Mark as cancelled so the task doesn't stay stuck in 'working'.
+          try {
+            await this.taskStore.updateTaskStatus(taskId, 'cancelled', 'Task was cancelled');
+          } catch {
+            // Task may already be in a terminal state
+          }
+        }
+      } catch (error) {
+        if (controller.signal.aborted) {
+          try {
+            await this.taskStore.updateTaskStatus(taskId, 'cancelled', 'Task was cancelled');
+          } catch {
+            // Task may already be in a terminal state
+          }
+        } else {
+          const message = error instanceof Error ? error.message : String(error);
+          logger.error(`Task ${taskId} failed:`, message);
+          try {
+            await this.taskStore.storeTaskResult(taskId, 'failed', {
+              content: [{ type: 'text', text: `Error: ${message}` }],
+              isError: true,
+            } as Result);
+          } catch {
+            // Task store may have already cleaned up (TTL)
+          }
+        }
+      } finally {
+        this.activeControllers.delete(taskId);
+      }
+    })();
+  }
+
+  /** Cancel a running task by aborting its AbortController. */
+  cancel(taskId: string): boolean {
+    const controller = this.activeControllers.get(taskId);
+    if (controller) {
+      controller.abort();
+      return true;
+    }
+    return false;
+  }
+
+  /** Number of currently active background tasks. */
+  get activeCount(): number {
+    return this.activeControllers.size;
+  }
+
+  private startCleanup(): void {
+    this.cleanupTimer = setInterval(() => {
+      logger.debug(`Active background tasks: ${this.activeControllers.size}`);
+    }, this.config.cleanupInterval);
+    // Allow the process to exit even if the timer is still running
+    if (this.cleanupTimer && typeof this.cleanupTimer === 'object' && 'unref' in this.cleanupTimer) {
+      this.cleanupTimer.unref();
+    }
+  }
+
+  /** Graceful shutdown: cancel all active tasks and clear timers. */
+  shutdown(): void {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = undefined;
+    }
+
+    for (const [taskId, controller] of this.activeControllers) {
+      logger.info(`Cancelling active task ${taskId} during shutdown`);
+      controller.abort();
+    }
+    this.activeControllers.clear();
+
+    // Clear InMemoryTaskStore internal TTL timers
+    (this.taskStore as InMemoryTaskStore).cleanup();
+  }
+}

package/src/tools/compare-ducks.ts

@@ -1,10 +1,12 @@
 import { ProviderManager } from '../providers/manager.js';
 import { duckArt } from '../utils/ascii-art.js';
 import { logger } from '../utils/logger.js';
+import type { ProgressReporter } from '../services/progress.js';
 
 export async function compareDucksTool(
   providerManager: ProviderManager,
-  args: Record<string, unknown>
+  args: Record<string, unknown>,
+  progress?: ProgressReporter
 ) {
   const { prompt, providers, model } = args as {
     prompt?: string;
@@ -16,8 +18,17 @@ export async function compareDucksTool(
     throw new Error('Prompt is required');
   }
 
-  // Get responses from multiple ducks
-  const responses = await providerManager.compareDucks(prompt, providers, { model });
+  // Get responses from multiple ducks, reporting progress as each completes
+  const responses = progress
+    ? await providerManager.compareDucksWithProgress(
+        prompt,
+        providers,
+        { model },
+        (providerName, completed, total) => {
+          void progress.report(completed, total, `${providerName} responded (${completed}/${total})`);
+        }
+      )
+    : await providerManager.compareDucks(prompt, providers, { model });
 
   // Build comparison response
   let response = `${duckArt.panel}\n`;