@providerprotocol/agents 0.0.2 → 0.0.4

package/tests/live/subagent-events.live.test.ts

@@ -1,249 +0,0 @@
-/**
- * Live tests for sub-agent event propagation.
- *
- * These tests verify that sub-agent events are correctly emitted
- * when using the Task tool pattern.
- *
- * @see UAP-1.0 Spec Section 8.7
- */
-
-import { describe, test, expect } from 'bun:test';
-import { agent, AgentState } from '../../src/index.ts';
-import type {
-  SubagentEvent,
-  SubagentStartEvent,
-  SubagentEndEvent,
-  OnSubagentEvent,
-} from '../../src/execution/types.ts';
-import { anthropic } from '@providerprotocol/ai/anthropic';
-import type { Tool } from '@providerprotocol/ai';
-
-/**
- * Helper to create a simple sub-agent tool with event propagation.
- */
-function createSubagentTool(options: {
-  name: string;
-  subagentType: string;
-  onSubagentEvent?: OnSubagentEvent;
-}): Tool {
-  const { name, subagentType, onSubagentEvent } = options;
-
-  // Create a simple sub-agent
-  const subAgent = agent({
-    model: anthropic('claude-3-5-haiku-latest'),
-    params: { max_tokens: 256 },
-    system: 'You are a helpful assistant. Be concise.',
-  });
-
-  return {
-    name,
-    description: `A sub-agent that helps with tasks. Type: ${subagentType}`,
-    parameters: {
-      type: 'object' as const,
-      properties: {
-        task: {
-          type: 'string' as const,
-          description: 'The task to perform',
-        },
-      },
-      required: ['task'],
-    },
-    run: async (params: { task: string }, context?: { toolCallId?: string }) => {
-      const subagentId = `sub-${Date.now()}`;
-      const parentToolCallId = context?.toolCallId ?? `tool-${Date.now()}`;
-      const startTime = Date.now();
-
-      // Emit start event
-      onSubagentEvent?.({
-        type: 'subagent_start',
-        subagentId,
-        subagentType,
-        parentToolCallId,
-        prompt: params.task,
-        timestamp: startTime,
-      });
-
-      try {
-        // Stream the sub-agent for real-time events
-        const stream = subAgent.stream(params.task, AgentState.initial());
-
-        // Forward inner events
-        for await (const event of stream) {
-          onSubagentEvent?.({
-            type: 'subagent_event',
-            subagentId,
-            subagentType,
-            parentToolCallId,
-            innerEvent: event,
-          });
-        }
-
-        const result = await stream.result;
-        const endTime = Date.now();
-
-        // Emit end event
-        onSubagentEvent?.({
-          type: 'subagent_end',
-          subagentId,
-          subagentType,
-          parentToolCallId,
-          success: true,
-          result: result.turn.response.text,
-          timestamp: endTime,
-          toolExecutions: result.turn.toolExecutions?.map((exec) => ({
-            toolName: exec.toolName,
-            arguments: exec.arguments as Record<string, unknown>,
-            result: typeof exec.result === 'string' ? exec.result : JSON.stringify(exec.result),
-          })),
-        });
-
-        return result.turn.response.text;
-      } catch (error) {
-        const endTime = Date.now();
-
-        // Emit error end event
-        onSubagentEvent?.({
-          type: 'subagent_end',
-          subagentId,
-          subagentType,
-          parentToolCallId,
-          success: false,
-          error: error instanceof Error ? error.message : String(error),
-          timestamp: endTime,
-        });
-
-        throw error;
-      }
-    },
-  };
-}
-
-describe('Sub-agent event propagation (live)', () => {
-  test('sub-agent tool emits start, inner events, and end events', async () => {
-    const receivedEvents: SubagentEvent[] = [];
-
-    const subagentTool = createSubagentTool({
-      name: 'helper',
-      subagentType: 'assistant',
-      onSubagentEvent: (event) => receivedEvents.push(event),
-    });
-
-    // Call the tool directly
-    const result = await subagentTool.run({ task: 'Say hello' });
-
-    // Verify we received events
-    expect(receivedEvents.length).toBeGreaterThan(0);
-
-    // Check for start event
-    const startEvent = receivedEvents.find((e) => e.type === 'subagent_start') as SubagentStartEvent | undefined;
-    expect(startEvent).toBeDefined();
-    expect(startEvent?.subagentType).toBe('assistant');
-    expect(startEvent?.prompt).toBe('Say hello');
-
-    // Check for inner events (should have at least text deltas)
-    const innerEvents = receivedEvents.filter((e) => e.type === 'subagent_event');
-    expect(innerEvents.length).toBeGreaterThan(0);
-
-    // Check for end event
-    const endEvent = receivedEvents.find((e) => e.type === 'subagent_end') as SubagentEndEvent | undefined;
-    expect(endEvent).toBeDefined();
-    expect(endEvent?.success).toBe(true);
-    expect(endEvent?.result).toBeDefined();
-
-    // Result should match end event result
-    expect(result).toBe(endEvent?.result);
-
-    // Verify event order: start should come before end
-    const startIndex = receivedEvents.findIndex((e) => e.type === 'subagent_start');
-    const endIndex = receivedEvents.findIndex((e) => e.type === 'subagent_end');
-    expect(startIndex).toBeLessThan(endIndex);
-
-    // All events should have the same subagentId
-    const subagentId = startEvent?.subagentId;
-    expect(receivedEvents.every((e) => e.subagentId === subagentId)).toBe(true);
-  }, 30000);
-
-  test('sub-agent inner events include text deltas', async () => {
-    const receivedEvents: SubagentEvent[] = [];
-
-    const subagentTool = createSubagentTool({
-      name: 'helper',
-      subagentType: 'assistant',
-      onSubagentEvent: (event) => receivedEvents.push(event),
-    });
-
-    await subagentTool.run({ task: 'Count from 1 to 3' });
-
-    // Find text delta events
-    const textDeltas = receivedEvents.filter(
-      (e) => e.type === 'subagent_event' && e.innerEvent.source === 'upp' && e.innerEvent.upp?.type === 'text_delta'
-    );
-
-    // Should have some text deltas
-    expect(textDeltas.length).toBeGreaterThan(0);
-  }, 30000);
-
-  test('sub-agent events have consistent parentToolCallId', async () => {
-    const receivedEvents: SubagentEvent[] = [];
-
-    const subagentTool = createSubagentTool({
-      name: 'helper',
-      subagentType: 'assistant',
-      onSubagentEvent: (event) => receivedEvents.push(event),
-    });
-
-    // Call with explicit context
-    await (subagentTool.run as (params: { task: string }, context?: { toolCallId?: string }) => Promise<string>)(
-      { task: 'Hello' },
-      { toolCallId: 'custom-tool-id-123' }
-    );
-
-    // All events should have the same parentToolCallId
-    expect(receivedEvents.every((e) => e.parentToolCallId === 'custom-tool-id-123')).toBe(true);
-  }, 30000);
-
-  test('timestamps are monotonically increasing', async () => {
-    const receivedEvents: SubagentEvent[] = [];
-
-    const subagentTool = createSubagentTool({
-      name: 'helper',
-      subagentType: 'assistant',
-      onSubagentEvent: (event) => receivedEvents.push(event),
-    });
-
-    await subagentTool.run({ task: 'Hi' });
-
-    const startEvent = receivedEvents.find((e) => e.type === 'subagent_start') as SubagentStartEvent | undefined;
-    const endEvent = receivedEvents.find((e) => e.type === 'subagent_end') as SubagentEndEvent | undefined;
-
-    expect(startEvent?.timestamp).toBeDefined();
-    expect(endEvent?.timestamp).toBeDefined();
-    if (startEvent && endEvent) {
-      expect(endEvent.timestamp).toBeGreaterThanOrEqual(startEvent.timestamp);
-    }
-  }, 30000);
-});
-
-describe('Sub-agent event type guards', () => {
-  test('can filter events by type', async () => {
-    const receivedEvents: SubagentEvent[] = [];
-
-    const subagentTool = createSubagentTool({
-      name: 'helper',
-      subagentType: 'assistant',
-      onSubagentEvent: (event) => receivedEvents.push(event),
-    });
-
-    await subagentTool.run({ task: 'Say one word' });
-
-    // Filter start events
-    const startEvents = receivedEvents.filter((e): e is SubagentStartEvent => e.type === 'subagent_start');
-    expect(startEvents).toHaveLength(1);
-    expect(startEvents[0]?.prompt).toBeDefined();
-
-    // Filter end events
-    const endEvents = receivedEvents.filter((e): e is SubagentEndEvent => e.type === 'subagent_end');
-    expect(endEvents).toHaveLength(1);
-    expect(typeof endEvents[0]?.success).toBe('boolean');
-  }, 30000);
-});

package/tests/live/thread-tree.test.ts

@@ -1,186 +0,0 @@
-import { describe, test, expect, setDefaultTimeout } from 'bun:test';
-import { anthropic } from '@providerprotocol/ai/anthropic';
-import { agent, ThreadTree } from '../../src/index.ts';
-
-// Skip tests if no API key
-const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
-
-// Increase timeout for live API tests (60 seconds)
-setDefaultTimeout(60_000);
-
-describe.skipIf(!ANTHROPIC_API_KEY)('ThreadTree (Live)', () => {
-  describe('basic branching', () => {
-    test('maintains separate contexts in branches', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 100 },
-      });
-
-      const tree = new ThreadTree();
-
-      // First conversation in root
-      const result1 = await a.ask('My name is Alice.', tree.history());
-      tree.current.state = result1.state;
-
-      // Create branch 1 from root
-      const branch1Id = tree.branch(tree.root.id, 'branch-1');
-      tree.checkout(branch1Id);
-
-      // In branch 1, say name is Bob
-      const branch1Result = await a.ask('Actually, my name is Bob.', tree.history());
-      tree.current.state = branch1Result.state;
-
-      // Create branch 2 from root (not from branch 1)
-      const branch2Id = tree.branch(tree.root.id, 'branch-2');
-      tree.checkout(branch2Id);
-
-      // In branch 2, say name is Charlie
-      const branch2Result = await a.ask('Actually, my name is Charlie.', tree.history());
-      tree.current.state = branch2Result.state;
-
-      // Verify branch 1 remembers Bob
-      tree.checkout(branch1Id);
-      const branch1Check = await a.ask('What is my name?', tree.history());
-      expect(branch1Check.turn.response.text.toLowerCase()).toContain('bob');
-
-      // Verify branch 2 remembers Charlie
-      tree.checkout(branch2Id);
-      const branch2Check = await a.ask('What is my name?', tree.history());
-      expect(branch2Check.turn.response.text.toLowerCase()).toContain('charlie');
-    });
-
-    test('branch inherits parent state', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 100 },
-      });
-
-      const tree = new ThreadTree();
-
-      // Establish context in root
-      const result1 = await a.ask('My favorite color is green.', tree.history());
-      tree.current.state = result1.state;
-
-      // Create branch
-      const branchId = tree.branch(tree.root.id, 'color-branch');
-      tree.checkout(branchId);
-
-      // Branch should remember the color from parent
-      const branchResult = await a.ask('What is my favorite color?', tree.history());
-      expect(branchResult.turn.response.text.toLowerCase()).toContain('green');
-    });
-  });
-
-  describe('serialization with live data', () => {
-    test('serializes and restores tree with conversation history', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 100 },
-      });
-
-      const tree = new ThreadTree();
-
-      // Build conversation
-      const result1 = await a.ask('Remember the number 42.', tree.history());
-      tree.current.state = result1.state;
-
-      // Create branch
-      const branchId = tree.branch(tree.root.id, 'number-branch');
-      tree.checkout(branchId);
-
-      const result2 = await a.ask('The number is now 99.', tree.history());
-      tree.current.state = result2.state;
-
-      // Serialize
-      const json = tree.toJSON();
-
-      // Restore
-      const restored = ThreadTree.fromJSON(json);
-
-      // Verify restored tree has correct structure
-      expect(restored.nodes.size).toBe(tree.nodes.size);
-      expect(restored.root.id).toBe(tree.root.id);
-
-      // Checkout branch and verify context
-      restored.checkout(branchId);
-      const checkResult = await a.ask('What number did I mention last?', restored.history());
-      expect(checkResult.turn.response.text).toContain('99');
-    });
-  });
-
-  describe('multiple branches', () => {
-    test('supports multiple simultaneous branches', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 100 },
-      });
-
-      const tree = new ThreadTree();
-
-      // Setup base context
-      const result = await a.ask('I am thinking of a secret word.', tree.history());
-      tree.current.state = result.state;
-
-      // Create 3 branches with different secrets
-      const branch1Id = tree.branch(tree.root.id, 'branch-apple');
-      tree.checkout(branch1Id);
-      const r1 = await a.ask('The secret word is apple.', tree.history());
-      tree.current.state = r1.state;
-
-      const branch2Id = tree.branch(tree.root.id, 'branch-banana');
-      tree.checkout(branch2Id);
-      const r2 = await a.ask('The secret word is banana.', tree.history());
-      tree.current.state = r2.state;
-
-      const branch3Id = tree.branch(tree.root.id, 'branch-cherry');
-      tree.checkout(branch3Id);
-      const r3 = await a.ask('The secret word is cherry.', tree.history());
-      tree.current.state = r3.state;
-
-      // Verify leaves
-      const leaves = tree.getLeaves();
-      expect(leaves.length).toBe(3);
-
-      // Verify each branch has correct secret
-      tree.checkout(branch1Id);
-      const check1 = await a.ask('What is the secret word?', tree.history());
-      expect(check1.turn.response.text.toLowerCase()).toContain('apple');
-
-      tree.checkout(branch2Id);
-      const check2 = await a.ask('What is the secret word?', tree.history());
-      expect(check2.turn.response.text.toLowerCase()).toContain('banana');
-
-      tree.checkout(branch3Id);
-      const check3 = await a.ask('What is the secret word?', tree.history());
-      expect(check3.turn.response.text.toLowerCase()).toContain('cherry');
-    });
-  });
-
-  describe('branch naming', () => {
-    test('retrieves branches by name', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 50 },
-      });
-
-      const tree = new ThreadTree();
-
-      // Build initial state
-      const result = await a.ask('Hello', tree.history());
-      tree.current.state = result.state;
-
-      // Create named branches
-      tree.branch(tree.root.id, 'experiment-a');
-      tree.branch(tree.root.id, 'experiment-b');
-      tree.branch(tree.root.id, 'experiment-c');
-
-      const branches = tree.getBranches();
-
-      // Should have 4 branches (root + 3 named)
-      expect(branches.size).toBe(4);
-      expect([...branches.values()]).toContain('experiment-a');
-      expect([...branches.values()]).toContain('experiment-b');
-      expect([...branches.values()]).toContain('experiment-c');
-    });
-  });
-});