mcp-rubber-duck 1.9.5 → 1.11.0

package/tests/services/task-manager.test.ts

@@ -0,0 +1,344 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+
+jest.mock('../../src/utils/logger');
+
+import { TaskManager } from '../../src/services/task-manager.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+
+describe('TaskManager', () => {
+  let taskManager: TaskManager;
+
+  beforeEach(() => {
+    taskManager = new TaskManager({
+      cleanupInterval: 600_000, // long interval to avoid noise
+    });
+  });
+
+  afterEach(() => {
+    taskManager.shutdown();
+  });
+
+  describe('constructor', () => {
+    it('should use default config values when none provided', () => {
+      const tm = new TaskManager();
+      try {
+        expect(tm.config.defaultTtl).toBe(300_000);
+        expect(tm.config.pollInterval).toBe(2_000);
+        expect(tm.config.maxQueueSize).toBe(100);
+        expect(tm.config.cleanupInterval).toBe(60_000);
+      } finally {
+        tm.shutdown();
+      }
+    });
+
+    it('should allow partial config overrides', () => {
+      const tm = new TaskManager({ defaultTtl: 60_000 });
+      try {
+        expect(tm.config.defaultTtl).toBe(60_000);
+        expect(tm.config.pollInterval).toBe(2_000); // default preserved
+      } finally {
+        tm.shutdown();
+      }
+    });
+
+    it('should provide a task store and message queue', () => {
+      expect(taskManager.taskStore).toBeDefined();
+      expect(taskManager.taskMessageQueue).toBeDefined();
+    });
+  });
+
+  describe('startBackground', () => {
+    it('should execute work and store a completed result', async () => {
+      // Create a task first (need requestId and request)
+      const task = await taskManager.taskStore.createTask(
+        { ttl: 60_000 },
+        'req-1',
+        { method: 'tools/call', params: { name: 'test', arguments: {} } }
+      );
+
+      const expectedResult: CallToolResult = {
+        content: [{ type: 'text', text: 'done!' }],
+      };
+
+      taskManager.startBackground(task.taskId, async () => {
+        return expectedResult;
+      });
+
+      // Wait for the background work to complete
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      const storedTask = await taskManager.taskStore.getTask(task.taskId);
+      expect(storedTask?.status).toBe('completed');
+
+      const result = await taskManager.taskStore.getTaskResult(task.taskId);
+      expect(result).toEqual(expectedResult);
+    });
+
+    it('should store a failed result when work throws', async () => {
+      const task = await taskManager.taskStore.createTask(
+        { ttl: 60_000 },
+        'req-2',
+        { method: 'tools/call', params: { name: 'test', arguments: {} } }
+      );
+
+      taskManager.startBackground(task.taskId, async () => {
+        throw new Error('Something went wrong');
+      });
+
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      const storedTask = await taskManager.taskStore.getTask(task.taskId);
+      expect(storedTask?.status).toBe('failed');
+
+      const result = await taskManager.taskStore.getTaskResult(task.taskId);
+      expect((result as CallToolResult).isError).toBe(true);
+      expect((result as CallToolResult).content[0]).toEqual(
+        expect.objectContaining({ type: 'text', text: expect.stringContaining('Something went wrong') })
+      );
+    });
+
+    it('should mark task as cancelled when work is aborted', async () => {
+      const task = await taskManager.taskStore.createTask(
+        { ttl: 60_000 },
+        'req-3',
+        { method: 'tools/call', params: { name: 'test', arguments: {} } }
+      );
+
+      taskManager.startBackground(task.taskId, async (signal) => {
+        // Simulate long-running work that checks the signal
+        return new Promise<CallToolResult>((resolve, reject) => {
+          const interval = setInterval(() => {
+            if (signal.aborted) {
+              clearInterval(interval);
+              reject(new Error('aborted'));
+            }
+          }, 10);
+        });
+      });
+
+      // Give it a moment to start
+      await new Promise(resolve => setTimeout(resolve, 20));
+
+      // Cancel it
+      const cancelled = taskManager.cancel(task.taskId);
+      expect(cancelled).toBe(true);
+
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      const storedTask = await taskManager.taskStore.getTask(task.taskId);
+      expect(storedTask?.status).toBe('cancelled');
+    });
+
+    it('should mark task as cancelled when work succeeds but signal was already aborted', async () => {
+      const task = await taskManager.taskStore.createTask(
+        { ttl: 60_000 },
+        'req-abort-success',
+        { method: 'tools/call', params: { name: 'test', arguments: {} } }
+      );
+
+      // Simulate: work succeeds, but the abort signal fires during the last step.
+      // The work function returns normally (no throw), yet signal.aborted is true.
+      taskManager.startBackground(task.taskId, async (signal) => {
+        // Pretend we're doing multi-step work; abort happens during the last step
+        // but the function still returns a result instead of throwing.
+        const controller = (taskManager as any).activeControllers.get(task.taskId) as AbortController;
+        controller.abort(); // abort mid-execution
+        // Return successfully despite abort
+        return { content: [{ type: 'text', text: 'completed despite abort' }] };
+      });
+
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      const storedTask = await taskManager.taskStore.getTask(task.taskId);
+      // Should be cancelled, NOT completed or stuck in 'working'
+      expect(storedTask?.status).toBe('cancelled');
+    });
+
+    it('should clean up the AbortController after work completes', async () => {
+      const task = await taskManager.taskStore.createTask(
+        { ttl: 60_000 },
+        'req-4',
+        { method: 'tools/call', params: { name: 'test', arguments: {} } }
+      );
+
+      taskManager.startBackground(task.taskId, async () => {
+        return { content: [{ type: 'text', text: 'ok' }] };
+      });
+
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(taskManager.activeCount).toBe(0);
+    });
+  });
+
+  describe('cancel', () => {
+    it('should return false if the task is not active', () => {
+      expect(taskManager.cancel('nonexistent')).toBe(false);
+    });
+
+    it('should return true and abort the signal for an active task', async () => {
+      const task = await taskManager.taskStore.createTask(
+        { ttl: 60_000 },
+        'req-5',
+        { method: 'tools/call', params: { name: 'test', arguments: {} } }
+      );
+
+      let signalAborted = false;
+      taskManager.startBackground(task.taskId, async (signal) => {
+        return new Promise<CallToolResult>((resolve, reject) => {
+          signal.addEventListener('abort', () => {
+            signalAborted = true;
+            reject(new Error('aborted'));
+          });
+        });
+      });
+
+      await new Promise(resolve => setTimeout(resolve, 20));
+      expect(taskManager.cancel(task.taskId)).toBe(true);
+
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(signalAborted).toBe(true);
+    });
+  });
+
+  describe('activeCount', () => {
+    it('should track the number of running tasks', async () => {
+      expect(taskManager.activeCount).toBe(0);
+
+      const task1 = await taskManager.taskStore.createTask(
+        { ttl: 60_000 },
+        'req-a',
+        { method: 'tools/call', params: { name: 'test', arguments: {} } }
+      );
+      const task2 = await taskManager.taskStore.createTask(
+        { ttl: 60_000 },
+        'req-b',
+        { method: 'tools/call', params: { name: 'test', arguments: {} } }
+      );
+
+      let resolve1: () => void;
+      let resolve2: () => void;
+      const p1 = new Promise<void>(r => { resolve1 = r; });
+      const p2 = new Promise<void>(r => { resolve2 = r; });
+
+      taskManager.startBackground(task1.taskId, async () => {
+        await p1;
+        return { content: [{ type: 'text', text: '1' }] };
+      });
+      taskManager.startBackground(task2.taskId, async () => {
+        await p2;
+        return { content: [{ type: 'text', text: '2' }] };
+      });
+
+      await new Promise(resolve => setTimeout(resolve, 20));
+      expect(taskManager.activeCount).toBe(2);
+
+      resolve1!();
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(taskManager.activeCount).toBe(1);
+
+      resolve2!();
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(taskManager.activeCount).toBe(0);
+    });
+  });
+
+  describe('shutdown', () => {
+    it('should cancel all active tasks', async () => {
+      const task = await taskManager.taskStore.createTask(
+        { ttl: 60_000 },
+        'req-s',
+        { method: 'tools/call', params: { name: 'test', arguments: {} } }
+      );
+
+      let aborted = false;
+      taskManager.startBackground(task.taskId, async (signal) => {
+        return new Promise<CallToolResult>((resolve, reject) => {
+          signal.addEventListener('abort', () => {
+            aborted = true;
+            reject(new Error('aborted'));
+          });
+        });
+      });
+
+      await new Promise(resolve => setTimeout(resolve, 20));
+      expect(taskManager.activeCount).toBe(1);
+
+      taskManager.shutdown();
+
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(aborted).toBe(true);
+      expect(taskManager.activeCount).toBe(0);
+    });
+
+    it('should be safe to call multiple times', () => {
+      taskManager.shutdown();
+      taskManager.shutdown();
+      // No error thrown
+    });
+  });
+
+  describe('TTL edge cases', () => {
+    it('should handle task TTL expiry during background work without crashing', async () => {
+      // Use a very short TTL so the task entry is cleaned up before work completes
+      const shortTtlManager = new TaskManager({
+        cleanupInterval: 600_000,
+      });
+
+      try {
+        const task = await shortTtlManager.taskStore.createTask(
+          { ttl: 50 },  // 50ms TTL — very short
+          'req-ttl',
+          { method: 'tools/call', params: { name: 'test', arguments: {} } }
+        );
+
+        shortTtlManager.startBackground(task.taskId, async () => {
+          // Simulate slow work that exceeds the TTL
+          await new Promise(resolve => setTimeout(resolve, 150));
+          return { content: [{ type: 'text', text: 'finished after TTL' }] };
+        });
+
+        // Wait for both TTL cleanup and work to complete
+        await new Promise(resolve => setTimeout(resolve, 300));
+
+        // The task entry should have been cleaned up by TTL
+        const storedTask = await shortTtlManager.taskStore.getTask(task.taskId);
+        expect(storedTask).toBeNull();
+
+        // Critically: no uncaught errors should have occurred.
+        // The startBackground catch handler gracefully handles "Task not found" errors
+        // from storeTaskResult when the TTL has already cleaned up the entry.
+        expect(shortTtlManager.activeCount).toBe(0);
+      } finally {
+        shortTtlManager.shutdown();
+      }
+    });
+
+    it('should handle task TTL expiry during failed background work without crashing', async () => {
+      const shortTtlManager = new TaskManager({
+        cleanupInterval: 600_000,
+      });
+
+      try {
+        const task = await shortTtlManager.taskStore.createTask(
+          { ttl: 50 },
+          'req-ttl-fail',
+          { method: 'tools/call', params: { name: 'test', arguments: {} } }
+        );
+
+        shortTtlManager.startBackground(task.taskId, async () => {
+          await new Promise(resolve => setTimeout(resolve, 150));
+          throw new Error('Work failed after TTL expired');
+        });
+
+        await new Promise(resolve => setTimeout(resolve, 300));
+
+        const storedTask = await shortTtlManager.taskStore.getTask(task.taskId);
+        expect(storedTask).toBeNull();
+        expect(shortTtlManager.activeCount).toBe(0);
+      } finally {
+        shortTtlManager.shutdown();
+      }
+    });
+  });
+});

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 () => {
@@ -187,4 +189,23 @@ describe('compareDucksTool', () => {
     // (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();
+  });
 });

package/tests/tools/duck-council.test.ts

@@ -190,6 +190,25 @@ describe('duckCouncilTool', () => {
     expect(result.content[0].text).not.toContain('tokens');
   });
 
+  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 duckCouncilTool(mockProviderManager, { prompt: 'Test' }, mockProgress);
+
+    expect(mockProviderManager.compareDucksWithProgress).toHaveBeenCalled();
+    expect(mockProviderManager.duckCouncil).not.toHaveBeenCalled();
+  });
+
+  it('should use duckCouncil when no progress is provided', async () => {
+    await duckCouncilTool(mockProviderManager, { prompt: 'Test' });
+
+    expect(mockProviderManager.duckCouncil).toHaveBeenCalled();
+  });
+
   it('should show error message when all ducks fail', async () => {
     mockProviderManager.duckCouncil.mockResolvedValue([
       {