@illuma-ai/agents 1.4.0-alpha.5 → 1.5.0

package/src/graphs/__tests__/HandoffRegistry.test.ts

@@ -1,410 +0,0 @@
-import { HandoffRegistry } from '../HandoffRegistry';
-import type { BaseGraphState } from '@/types';
-
-/** Helper to create a resolved promise simulating a child agent completion */
-function createChildPromise(
-  resultText: string,
-  delayMs = 0
-): Promise<BaseGraphState> {
-  return new Promise((resolve) => {
-    const fn = () =>
-      resolve({
-        messages: [
-          {
-            getType: () => 'ai',
-            content: resultText,
-          } as any,
-        ],
-      });
-    if (delayMs > 0) {
-      setTimeout(fn, delayMs);
-    } else {
-      fn();
-    }
-  });
-}
-
-/** Helper to create a failing promise */
-function createFailingPromise(
-  errorMsg: string,
-  delayMs = 0
-): Promise<BaseGraphState> {
-  return new Promise((_resolve, reject) => {
-    const fn = () => reject(new Error(errorMsg));
-    if (delayMs > 0) {
-      setTimeout(fn, delayMs);
-    } else {
-      fn();
-    }
-  });
-}
-
-/** Stub extractResult — returns content string from last AI message */
-function extractResult(messages: any[], _agentId: string): string {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (
-      messages[i].getType() === 'ai' &&
-      typeof messages[i].content === 'string'
-    ) {
-      return messages[i].content;
-    }
-  }
-  return '[no result]';
-}
-
-/** Stub truncateResult — pass through */
-function truncateResult(text: string, _maxChars: number): string {
-  return text;
-}
-
-describe('HandoffRegistry', () => {
-  let registry: HandoffRegistry;
-
-  beforeEach(() => {
-    registry = new HandoffRegistry();
-  });
-
-  describe('spawn', () => {
-    it('should register a new handoff record', () => {
-      const promise = createChildPromise('test result');
-
-      registry.spawn({
-        id: 'agent-1',
-        name: 'Researcher',
-        task: 'Find information',
-        promise,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-
-      expect(registry.size).toBe(1);
-      expect(registry.hasPending()).toBe(true);
-
-      const record = registry.get('agent-1');
-      expect(record).toBeDefined();
-      expect(record!.name).toBe('Researcher');
-      expect(record!.task).toBe('Find information');
-      expect(record!.status).toBe('running');
-    });
-
-    it('should update record on completion', async () => {
-      const promise = createChildPromise('research findings');
-
-      registry.spawn({
-        id: 'agent-1',
-        name: 'Researcher',
-        task: 'Find info',
-        promise,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-
-      // Wait for promise to resolve
-      await promise;
-      // Yield to let .then handler run
-      await new Promise((r) => setTimeout(r, 0));
-
-      const record = registry.get('agent-1')!;
-      expect(record.status).toBe('completed');
-      expect(record.resultText).toBe('research findings');
-      expect(record.durationMs).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should update record on failure', async () => {
-      const promise = createFailingPromise('timeout');
-
-      registry.spawn({
-        id: 'agent-1',
-        name: 'Researcher',
-        task: 'Find info',
-        promise,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-
-      try {
-        await promise;
-      } catch {
-        // expected
-      }
-      await new Promise((r) => setTimeout(r, 0));
-
-      const record = registry.get('agent-1')!;
-      expect(record.status).toBe('failed');
-      expect(record.error).toBe('timeout');
-    });
-
-    it('should call onComplete callback on completion', async () => {
-      const onComplete = jest.fn();
-      const promise = createChildPromise('done');
-
-      registry.spawn({
-        id: 'agent-1',
-        name: 'Worker',
-        task: 'Do work',
-        promise,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-        onComplete,
-      });
-
-      await promise;
-      await new Promise((r) => setTimeout(r, 0));
-
-      expect(onComplete).toHaveBeenCalledTimes(1);
-      expect(onComplete).toHaveBeenCalledWith(
-        expect.objectContaining({
-          id: 'agent-1',
-          status: 'completed',
-          resultText: 'done',
-        })
-      );
-    });
-
-    it('should call onComplete callback on failure', async () => {
-      const onComplete = jest.fn();
-      const promise = createFailingPromise('oops');
-
-      registry.spawn({
-        id: 'agent-1',
-        name: 'Worker',
-        task: 'Do work',
-        promise,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-        onComplete,
-      });
-
-      try {
-        await promise;
-      } catch {
-        // expected
-      }
-      await new Promise((r) => setTimeout(r, 0));
-
-      expect(onComplete).toHaveBeenCalledTimes(1);
-      expect(onComplete).toHaveBeenCalledWith(
-        expect.objectContaining({
-          id: 'agent-1',
-          status: 'failed',
-          error: 'oops',
-        })
-      );
-    });
-  });
-
-  describe('listing methods', () => {
-    it('should list pending and completed separately', async () => {
-      const p1 = createChildPromise('result 1');
-      const p2 = createChildPromise('result 2', 100);
-
-      registry.spawn({
-        id: 'agent-1',
-        name: 'Agent 1',
-        task: 'task 1',
-        promise: p1,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-      registry.spawn({
-        id: 'agent-2',
-        name: 'Agent 2',
-        task: 'task 2',
-        promise: p2,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-
-      // Wait for first to complete
-      await p1;
-      await new Promise((r) => setTimeout(r, 0));
-
-      expect(registry.listCompleted()).toHaveLength(1);
-      expect(registry.listCompleted()[0].id).toBe('agent-1');
-      expect(registry.listPending()).toHaveLength(1);
-      expect(registry.listPending()[0].id).toBe('agent-2');
-      expect(registry.listAll()).toHaveLength(2);
-
-      // Wait for second
-      await p2;
-      await new Promise((r) => setTimeout(r, 0));
-
-      expect(registry.listCompleted()).toHaveLength(2);
-      expect(registry.listPending()).toHaveLength(0);
-    });
-  });
-
-  describe('waitForAll', () => {
-    it('should wait for all pending handoffs', async () => {
-      const p1 = createChildPromise('result 1', 10);
-      const p2 = createChildPromise('result 2', 20);
-
-      registry.spawn({
-        id: 'agent-1',
-        name: 'Agent 1',
-        task: 'task 1',
-        promise: p1,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-      registry.spawn({
-        id: 'agent-2',
-        name: 'Agent 2',
-        task: 'task 2',
-        promise: p2,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-
-      const results = await registry.waitForAll();
-
-      expect(results).toHaveLength(2);
-      expect(results.every((r) => r.status === 'completed')).toBe(true);
-      expect(results[0].resultText).toBe('result 1');
-      expect(results[1].resultText).toBe('result 2');
-    });
-
-    it('should return immediately when no pending handoffs', async () => {
-      const results = await registry.waitForAll();
-      expect(results).toHaveLength(0);
-    });
-  });
-
-  describe('waitForAny', () => {
-    it('should return when any handoff completes', async () => {
-      const p1 = createChildPromise('fast result', 10);
-      const p2 = createChildPromise('slow result', 200);
-
-      registry.spawn({
-        id: 'agent-1',
-        name: 'Fast',
-        task: 'fast task',
-        promise: p1,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-      registry.spawn({
-        id: 'agent-2',
-        name: 'Slow',
-        task: 'slow task',
-        promise: p2,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-
-      const completed = await registry.waitForAny();
-
-      // At least the fast one should be completed
-      expect(completed.length).toBeGreaterThanOrEqual(1);
-      expect(completed.some((r) => r.id === 'agent-1')).toBe(true);
-    });
-  });
-
-  describe('clear', () => {
-    it('should clear all records', () => {
-      registry.spawn({
-        id: 'agent-1',
-        name: 'Agent',
-        task: 'task',
-        promise: createChildPromise('result'),
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-
-      expect(registry.size).toBe(1);
-      registry.clear();
-      expect(registry.size).toBe(0);
-      expect(registry.hasPending()).toBe(false);
-    });
-  });
-
-  describe('parallel spawn workflow', () => {
-    it('should handle the full orchestrator workflow: spawn → collect → synthesize', async () => {
-      // Step 1: Orchestrator spawns two agents in parallel
-      const p1 = createChildPromise('Researcher found: X=42', 10);
-      const p2 = createChildPromise('Analyst found: Y=100', 20);
-
-      registry.spawn({
-        id: 'researcher',
-        name: 'Researcher',
-        task: 'Find X',
-        promise: p1,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-      registry.spawn({
-        id: 'analyst',
-        name: 'Analyst',
-        task: 'Find Y',
-        promise: p2,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-
-      // Step 2: Orchestrator checks status (non-blocking)
-      expect(registry.hasPending()).toBe(true);
-      const status = registry.listAll();
-      expect(status).toHaveLength(2);
-
-      // Step 3: Orchestrator collects all results
-      const results = await registry.waitForAll();
-      expect(results).toHaveLength(2);
-      expect(results.every((r) => r.status === 'completed')).toBe(true);
-
-      // Step 4: Orchestrator uses results for next delegation
-      const researchResult = results.find((r) => r.id === 'researcher')!;
-      expect(researchResult.resultText).toBe('Researcher found: X=42');
-    });
-
-    it('should handle sequential spawn workflow: spawn → collect → spawn with data → collect', async () => {
-      // Round 1: Spawn researcher
-      const p1 = createChildPromise('Research: The answer is 42', 10);
-      registry.spawn({
-        id: 'researcher',
-        name: 'Researcher',
-        task: 'Find the answer',
-        promise: p1,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-
-      // Collect round 1 results
-      const round1 = await registry.waitForAll();
-      const researchData = round1[0].resultText!;
-      expect(researchData).toContain('42');
-
-      // Round 2: Spawn emailer with real data from round 1
-      const p2 = createChildPromise('Email sent with answer: 42', 10);
-      registry.spawn({
-        id: 'emailer',
-        name: 'Email Agent',
-        task: `Send email with: ${researchData}`,
-        promise: p2,
-        extractResult,
-        truncateResult,
-        maxResultChars: 5000,
-      });
-
-      // Collect round 2 results
-      const round2 = await registry.waitForAll();
-      const emailResult = round2.find((r) => r.id === 'emailer')!;
-      expect(emailResult.status).toBe('completed');
-      expect(emailResult.resultText).toContain('Email sent');
-    });
-  });
-});