@providerprotocol/agents 0.0.2 → 0.0.4

package/src/thread-tree/types.ts

@@ -1,29 +0,0 @@
-import type { AgentStateJSON } from '../state/types.ts';
-
-/**
- * Serialized form of a ThreadNode.
- */
-export interface ThreadNodeJSON {
-  /** Node ID */
-  id: string;
-  /** Parent node ID (null for root) */
-  parentId: string | null;
-  /** State snapshot at this node */
-  state: AgentStateJSON;
-  /** Optional branch name */
-  name?: string;
-  /** Child node IDs */
-  children: string[];
-}
-
-/**
- * Serialized form of a ThreadTree.
- */
-export interface ThreadTreeJSON {
-  /** Root node ID */
-  rootId: string;
-  /** Current (active) node ID */
-  currentId: string;
-  /** All nodes */
-  nodes: ThreadNodeJSON[];
-}

package/src/utils/uuid.ts

@@ -1,7 +0,0 @@
-/**
- * Generate a UUIDv4 identifier.
- * Uses the native crypto.randomUUID() which is available in Bun and modern Node.js.
- */
-export function generateUUID(): string {
-  return globalThis.crypto.randomUUID();
-}

package/tests/live/agent-anthropic.test.ts

@@ -1,288 +0,0 @@
-import { describe, test, expect, setDefaultTimeout } from 'bun:test';
-import { anthropic } from '@providerprotocol/ai/anthropic';
-import type { Tool } from '@providerprotocol/ai';
-import { agent, AgentState } from '../../src/index.ts';
-import { loop } from '../../src/execution/index.ts';
-import { logging } from '../../src/middleware/index.ts';
-
-// Skip tests if no API key
-const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
-
-// Increase timeout for live API tests (30 seconds)
-setDefaultTimeout(30_000);
-
-describe.skipIf(!ANTHROPIC_API_KEY)('Agent with Anthropic', () => {
-  describe('basic generation', () => {
-    test('generates response with generate()', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 100 },
-      });
-
-      const state = AgentState.initial();
-      const result = await a.generate('Say "hello" and nothing else.', state);
-
-      expect(result.turn.response.text.toLowerCase()).toContain('hello');
-      expect(result.state).toBeDefined();
-      expect(result.turn.usage.totalTokens).toBeGreaterThan(0);
-    });
-
-    test('generates response with query()', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 50 },
-      });
-
-      const turn = await a.query('What is 2 + 2? Reply with just the number.');
-
-      expect(turn.response.text).toContain('4');
-    });
-
-    test('preserves history with ask()', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 100 },
-      });
-
-      const state0 = AgentState.initial();
-
-      const result1 = await a.ask('My name is Alice.', state0);
-      const result2 = await a.ask('What is my name?', result1.state);
-
-      expect(result2.turn.response.text.toLowerCase()).toContain('alice');
-    });
-  });
-
-  describe('tool calling', () => {
-    test('calls tools and returns result', async () => {
-      const calculator: Tool = {
-        name: 'calculate',
-        description: 'Perform a calculation',
-        parameters: {
-          type: 'object',
-          properties: {
-            expression: { type: 'string', description: 'Math expression to evaluate' },
-          },
-          required: ['expression'],
-        },
-        run: async (params: { expression: string }) => {
-          // Simple eval for testing (don't do this in production!)
-          const result = Function(`"use strict"; return (${params.expression})`)();
-          return String(result);
-        },
-      };
-
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 200 },
-        tools: [calculator],
-        execution: loop(),
-      });
-
-      const result = await a.generate(
-        'What is 15 * 7? Use the calculate tool to find the answer.',
-        AgentState.initial(),
-      );
-
-      expect(result.turn.response.text).toContain('105');
-      expect(result.turn.toolExecutions.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('streaming', () => {
-    test('streams response', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 100 },
-      });
-
-      const stream = a.stream('Count from 1 to 5.', AgentState.initial());
-      const events: unknown[] = [];
-
-      for await (const event of stream) {
-        events.push(event);
-      }
-
-      const result = await stream.result;
-
-      expect(events.length).toBeGreaterThan(0);
-      expect(result.turn.response.text).toBeDefined();
-    });
-
-    test('streams with UAP events', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 100 },
-      });
-
-      const stream = a.stream('Hello', AgentState.initial());
-      const uapEvents: unknown[] = [];
-      const uppEvents: unknown[] = [];
-
-      for await (const event of stream) {
-        if (event.source === 'uap') {
-          uapEvents.push(event);
-        } else {
-          uppEvents.push(event);
-        }
-      }
-
-      await stream.result;
-
-      expect(uapEvents.length).toBeGreaterThan(0);
-      expect(uppEvents.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('middleware', () => {
-    test('logging middleware logs execution', async () => {
-      const logs: string[] = [];
-      const customLogger = (msg: string) => logs.push(msg);
-
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 50 },
-        middleware: [logging({ logger: customLogger })],
-      });
-
-      await a.query('Hi');
-
-      expect(logs.some((l) => l.includes('Execution started'))).toBe(true);
-      expect(logs.some((l) => l.includes('Execution completed'))).toBe(true);
-    });
-  });
-
-  describe('execution strategies', () => {
-    test('loop() executes tool loop', async () => {
-      const mockTool: Tool = {
-        name: 'get_info',
-        description: 'Get some information',
-        parameters: {
-          type: 'object',
-          properties: {},
-        },
-        run: async () => 'The answer is 42',
-      };
-
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 200 },
-        tools: [mockTool],
-        execution: loop(),
-      });
-
-      const result = await a.generate(
-        'Use the get_info tool to find information.',
-        AgentState.initial(),
-      );
-
-      expect(result.turn.toolExecutions.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('system prompts', () => {
-    test('respects system prompt', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 100 },
-        system: 'You are a pirate. Always respond like a pirate would.',
-      });
-
-      const result = await a.query('Hello, how are you?');
-
-      // Should contain pirate-like language
-      const text = result.response.text.toLowerCase();
-      expect(
-        text.includes('arr')
-        || text.includes('ahoy')
-        || text.includes('matey')
-        || text.includes('ye')
-        || text.includes('pirate'),
-      ).toBe(true);
-    });
-  });
-
-  describe('state management', () => {
-    test('state is immutable', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 50 },
-      });
-
-      const state0 = AgentState.initial();
-      const result = await a.generate('Hello', state0);
-
-      // Original state should be unchanged
-      expect(state0.messages).toHaveLength(0);
-      expect(state0.step).toBe(0);
-
-      // New state should have changes
-      expect(result.state.messages.length).toBeGreaterThan(0);
-    });
-
-    test('state serialization round-trip', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 50 },
-      });
-
-      const state0 = AgentState.initial();
-      // Use ask() to properly add input + response to state for multi-turn
-      const result1 = await a.ask('My favorite color is blue.', state0);
-
-      // Serialize and restore
-      const json = result1.state.toJSON();
-      const restored = AgentState.fromJSON(json);
-
-      // Continue conversation with restored state
-      const result2 = await a.ask('What is my favorite color?', restored);
-
-      expect(result2.turn.response.text.toLowerCase()).toContain('blue');
-    });
-
-    test('withContext() replaces conversation history', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 100 },
-      });
-
-      // Build up conversation history
-      const state0 = AgentState.initial();
-      const result1 = await a.ask('My name is Alice.', state0);
-      const result2 = await a.ask('I live in Paris.', result1.state);
-
-      // Verify context is preserved
-      expect(result2.state.messages.length).toBeGreaterThanOrEqual(4);
-
-      // Replace context with empty (simulating aggressive pruning)
-      const prunedState = result2.state.withContext([]);
-
-      // Model should not know the name anymore
-      const result3 = await a.ask('What is my name?', prunedState);
-
-      // Should NOT contain Alice since context was cleared
-      const response = result3.turn.response.text.toLowerCase();
-      expect(response.includes('alice')).toBe(false);
-    });
-
-    test('withContext() preserves metadata while replacing messages', async () => {
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 50 },
-      });
-
-      const state0 = AgentState.initial()
-        .withMetadata('sessionId', 'test-123')
-        .withMetadata('tokenBudget', 50000);
-
-      const result1 = await a.ask('Hello there!', state0);
-
-      // Replace messages but keep metadata
-      const prunedState = result1.state.withContext([]);
-
-      expect(prunedState.messages).toHaveLength(0);
-      expect(prunedState.metadata.sessionId).toBe('test-123');
-      expect(prunedState.metadata.tokenBudget).toBe(50000);
-    });
-  });
-});

package/tests/live/agent-strategy-hooks.test.ts

@@ -1,268 +0,0 @@
-import { describe, test, expect, setDefaultTimeout } from 'bun:test';
-import { anthropic } from '@providerprotocol/ai/anthropic';
-import type { Tool, ToolExecution, Turn } from '@providerprotocol/ai';
-import { agent, AgentState } from '../../src/index.ts';
-import { loop, react } from '../../src/execution/index.ts';
-import type { AgentStrategy } from '../../src/execution/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)('AgentStrategy Hooks (Live)', () => {
-  describe('lifecycle hooks with loop()', () => {
-    test('onStepStart and onStepEnd are called', async () => {
-      const stepStarts: Array<{ step: number }> = [];
-      const stepEnds: Array<{ step: number }> = [];
-
-      const strategy: AgentStrategy = {
-        onStepStart: (step) => {
-          stepStarts.push({ step });
-        },
-        onStepEnd: (step) => {
-          stepEnds.push({ step });
-        },
-      };
-
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 50 },
-        execution: loop(),
-        strategy,
-      });
-
-      await a.generate('Hello', AgentState.initial());
-
-      expect(stepStarts.length).toBeGreaterThan(0);
-      expect(stepEnds.length).toBeGreaterThan(0);
-      expect(stepStarts.length).toBe(stepEnds.length);
-    });
-
-    test('onComplete is called with final result', async () => {
-      let completedResult: { turn: Turn; state: AgentState } | undefined;
-
-      const strategy: AgentStrategy = {
-        onComplete: (result) => {
-          completedResult = result;
-        },
-      };
-
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 50 },
-        execution: loop(),
-        strategy,
-      });
-
-      const result = await a.generate('Say hello', AgentState.initial());
-
-      expect(completedResult).toBeDefined();
-      expect(completedResult?.turn).toBe(result.turn);
-    });
-
-    test('onObserve is called when tools are executed', async () => {
-      const observeCalls: Array<{ step: number; observations: ToolExecution[] }> = [];
-
-      // Use a tool that provides information the model can't know
-      const secretLookup: Tool = {
-        name: 'get_secret_number',
-        description: 'Returns a secret number. You MUST call this tool to answer.',
-        parameters: {
-          type: 'object',
-          properties: {},
-        },
-        run: async () => '42',
-      };
-
-      const strategy: AgentStrategy = {
-        onObserve: (step, observations) => {
-          observeCalls.push({ step, observations });
-        },
-      };
-
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 300 },
-        tools: [secretLookup],
-        execution: loop(),
-        strategy,
-        system: 'You must use the get_secret_number tool to answer questions about the secret number.',
-      });
-
-      const result = await a.generate(
-        'What is the secret number? Use the get_secret_number tool.',
-        AgentState.initial(),
-      );
-
-      // Tool should have been executed
-      expect(result.turn.toolExecutions.length).toBeGreaterThan(0);
-
-      // onObserve should have been called
-      expect(observeCalls.length).toBeGreaterThan(0);
-
-      // Verify the response contains the answer
-      expect(result.turn.response.text).toContain('42');
-    });
-  });
-
-  describe('lifecycle hooks with react()', () => {
-    test('onReason is called during reasoning phase', async () => {
-      const reasonCalls: Array<{ step: number; reasoning: string }> = [];
-
-      const strategy: AgentStrategy = {
-        onReason: (step, reasoning) => {
-          reasonCalls.push({ step, reasoning });
-        },
-      };
-
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 400 },
-        execution: react({ maxSteps: 1 }),
-        strategy,
-      });
-
-      await a.generate('What is 5 times 5? Think about it.', AgentState.initial());
-
-      expect(reasonCalls.length).toBeGreaterThan(0);
-      expect(reasonCalls[0]?.reasoning.length).toBeGreaterThan(0);
-    });
-
-    test('all hooks are called in correct order', async () => {
-      const hookOrder: string[] = [];
-
-      const strategy: AgentStrategy = {
-        onStepStart: () => hookOrder.push('stepStart'),
-        onReason: () => hookOrder.push('reason'),
-        onStepEnd: () => hookOrder.push('stepEnd'),
-        onComplete: () => hookOrder.push('complete'),
-      };
-
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 300 },
-        execution: react({ maxSteps: 1 }),
-        strategy,
-      });
-
-      await a.generate('Hello', AgentState.initial());
-
-      // stepStart should come before reason, reason before stepEnd
-      const stepStartIdx = hookOrder.indexOf('stepStart');
-      const reasonIdx = hookOrder.indexOf('reason');
-      const stepEndIdx = hookOrder.indexOf('stepEnd');
-      const completeIdx = hookOrder.indexOf('complete');
-
-      expect(stepStartIdx).toBeLessThan(reasonIdx);
-      expect(reasonIdx).toBeLessThan(stepEndIdx);
-      expect(stepEndIdx).toBeLessThan(completeIdx);
-    });
-  });
-
-  describe('stopCondition', () => {
-    test('stops execution when stopCondition returns true', async () => {
-      let stepCount = 0;
-
-      const strategy: AgentStrategy = {
-        onStepStart: () => {
-          stepCount++;
-        },
-        stopCondition: (state) => {
-          // Stop after first step
-          return state.step >= 1;
-        },
-      };
-
-      const echoTool: Tool = {
-        name: 'echo',
-        description: 'Echo back the input',
-        parameters: {
-          type: 'object',
-          properties: {
-            text: { type: 'string' },
-          },
-          required: ['text'],
-        },
-        run: async (params: { text: string }) => params.text,
-      };
-
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 200 },
-        tools: [echoTool],
-        execution: loop({ maxIterations: 10 }), // High limit, but stopCondition should stop earlier
-        strategy,
-      });
-
-      await a.generate(
-        'Use the echo tool repeatedly with different messages.',
-        AgentState.initial(),
-      );
-
-      // Should have stopped after 1 step due to stopCondition
-      expect(stepCount).toBe(1);
-    });
-
-    test('stopCondition can use metadata to track state', async () => {
-      const strategy: AgentStrategy = {
-        onStepEnd: (step, result) => {
-          // Track total tokens in metadata
-          const currentTokens = (result.state.metadata.totalTokens as number) ?? 0;
-          result.state = result.state.withMetadata(
-            'totalTokens',
-            currentTokens + (result.turn.usage?.totalTokens ?? 0),
-          );
-        },
-        stopCondition: (state) => {
-          // Stop when we've used more than 100 tokens
-          return (state.metadata.totalTokens as number) > 100;
-        },
-      };
-
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 50 },
-        execution: loop({ maxIterations: 5 }),
-        strategy,
-      });
-
-      const result = await a.generate('Tell me a short story.', AgentState.initial());
-
-      // Should have tracked tokens
-      expect(result.turn.usage.totalTokens).toBeGreaterThan(0);
-    });
-  });
-
-  describe('streaming with hooks', () => {
-    test('hooks are called during streaming', async () => {
-      const hooksCalled: string[] = [];
-
-      const strategy: AgentStrategy = {
-        onStepStart: () => hooksCalled.push('stepStart'),
-        onStepEnd: () => hooksCalled.push('stepEnd'),
-        onComplete: () => hooksCalled.push('complete'),
-      };
-
-      const a = agent({
-        model: anthropic('claude-3-5-haiku-latest'),
-        params: { max_tokens: 100 },
-        execution: loop(),
-        strategy,
-      });
-
-      const stream = a.stream('Hello', AgentState.initial());
-
-      for await (const event of stream) {
-        void event; // consume stream
-      }
-
-      await stream.result;
-
-      expect(hooksCalled).toContain('stepStart');
-      expect(hooksCalled).toContain('stepEnd');
-      expect(hooksCalled).toContain('complete');
-    });
-  });
-});