@axlsdk/testing 0.3.0 → 0.4.0

package/README.md

@@ -18,21 +18,24 @@ Mock LLM provider with multiple response modes:
 import { MockProvider } from '@axlsdk/testing';
 
 // Sequence mode — return responses in order
-const provider = MockProvider.sequence(['Hello!', 'World!']);
+const provider = MockProvider.sequence([
+  { content: 'Hello!' },
+  { content: 'World!' },
+]);
 
 // Echo mode — return the user's prompt back
 const provider = MockProvider.echo();
 
-// JSON mode — return structured data
-const provider = MockProvider.json({ answer: 42, confidence: 0.95 });
+// JSON mode — return data matching a Zod schema
+const provider = MockProvider.json(z.object({ answer: z.number() }));
 
 // Replay mode — replay from a recorded file
 const provider = MockProvider.replay('./fixtures/conversation.json');
 
 // Function mode — custom response logic
-const provider = MockProvider.fn((messages, options) => {
+const provider = MockProvider.fn((messages, callIndex) => {
   const lastMessage = messages[messages.length - 1];
-  return `You said: ${lastMessage.content}`;
+  return { content: `You said: ${lastMessage.content}` };
 });
 ```
 
@@ -48,71 +51,73 @@ const provider = MockProvider.sequence([
       function: { name: 'calculator', arguments: '{"expression":"2+2"}' },
     }],
   },
-  'The answer is 4.',
+  { content: 'The answer is 4.' },
 ]);
 ```
 
 ### `MockTool`
 
-Wrap a tool to intercept and record calls:
+Create a mock tool to intercept and record calls:
 
 ```typescript
 import { MockTool } from '@axlsdk/testing';
-import { calculator } from './tools';
-
-const mock = new MockTool(calculator);
 
-// Use in agent
-const myAgent = agent({ model: 'test:mock', system: 'Test', tools: [mock] });
+const mock = MockTool.create('calculator', async ({ expression }) => ({
+  result: eval(expression),
+}));
 
-// After execution, inspect calls
-console.log(mock.calls); // [{ input: { expression: '2+2' }, output: { result: 4 } }]
+// Inspect calls after execution
+console.log(mock.calls); // [{ input: { expression: '2+2' } }]
 ```
 
 ### `AxlTestRuntime`
 
-Test runtime that mirrors `WorkflowContext` for deterministic testing:
+Test runtime that wraps `WorkflowContext` for deterministic testing:
 
 ```typescript
 import { AxlTestRuntime, MockProvider } from '@axlsdk/testing';
 
-const provider = MockProvider.sequence(['42']);
-const runtime = new AxlTestRuntime({ provider });
+const runtime = new AxlTestRuntime();
+runtime.register(myWorkflow);
+
+// Mock the LLM
+runtime.mockProvider('openai', MockProvider.sequence([
+  { content: '42' },
+]));
+
+// Mock tools
+runtime.mockTool('calculator', async ({ expression }) => ({ result: 4 }));
 
-// Ask an agent
-const result = await runtime.ask(myAgent, 'What is the answer?');
-expect(result).toBe('42');
+// Execute
+const result = await runtime.execute('my-workflow', { question: 'What is 2+2?' });
 
 // Inspect recorded calls
 expect(runtime.agentCalls()).toHaveLength(1);
-expect(runtime.toolCalls()).toHaveLength(0);
+expect(runtime.toolCalls()).toHaveLength(1);
 expect(runtime.totalCost()).toBe(0);
+```
 
-// Test spawn
-const results = await runtime.spawn(3, async (i) => runtime.ask(myAgent, `Q${i}`));
-expect(results.filter(r => r.ok)).toHaveLength(3);
-
-// Test vote
-const winner = runtime.vote(results, { strategy: 'majority', key: 'answer' });
+For testing human-in-the-loop flows:
 
-// Test budget
-const budgeted = await runtime.budget({ cost: '$1.00' }, async () => {
-  return runtime.ask(myAgent, 'Hello');
+```typescript
+const runtime = new AxlTestRuntime({
+  humanDecisions: (opts) => ({ approved: true }),
 });
-expect(budgeted.budgetExceeded).toBe(false);
 ```
 
 ### Assertions
 
 ```typescript
-const runtime = new AxlTestRuntime({ provider });
+const runtime = new AxlTestRuntime();
+runtime.register(myWorkflow);
+runtime.mockProvider('openai', provider);
 
 // After running your workflow:
 runtime.agentCalls();   // All recorded agent invocations
 runtime.toolCalls();    // All recorded tool invocations
 runtime.totalCost();    // Cumulative cost
 runtime.steps();        // All recorded steps (agents + tools)
-runtime.traces();       // All trace events
+runtime.traceLog();     // All trace events
 ```
 
 ## Example: Testing a Workflow
@@ -120,19 +125,31 @@ runtime.traces();       // All trace events
 ```typescript
 import { describe, it, expect } from 'vitest';
 import { AxlTestRuntime, MockProvider } from '@axlsdk/testing';
-import { myAgent } from '../agents';
-
-describe('my workflow', () => {
-  it('returns structured output', async () => {
-    const provider = MockProvider.json({ answer: 42 });
-    const runtime = new AxlTestRuntime({ provider });
-
-    const result = await runtime.ask(myAgent, 'What is the answer?', {
-      schema: z.object({ answer: z.number() }),
+import { z } from 'zod';
+import { HandleSupport } from '../workflows/support';
+
+describe('HandleSupport workflow', () => {
+  it('processes a refund', async () => {
+    const runtime = new AxlTestRuntime();
+    runtime.register(HandleSupport);
+
+    runtime.mockProvider('openai', MockProvider.sequence([
+      { content: 'Your refund has been processed.' },
+    ]));
+
+    runtime.mockTool('get_order', async ({ orderId }) => ({
+      id: orderId, status: 'delivered', amount: 49.99,
+    }));
+    runtime.mockTool('refund_order', async ({ orderId }) => ({
+      success: true,
+    }));
+
+    const result = await runtime.execute('HandleSupport', {
+      msg: 'I want a refund for order 123',
     });
 
-    expect(result).toEqual({ answer: 42 });
-    expect(runtime.agentCalls()).toHaveLength(1);
+    expect(result).toContain('refund');
+    expect(runtime.toolCalls('refund_order')).toHaveLength(1);
   });
 });
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axlsdk/testing",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Testing utilities for Axl agentic workflows",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -22,7 +22,7 @@
     "dist"
   ],
   "dependencies": {
-    "@axlsdk/axl": "0.3.0"
+    "@axlsdk/axl": "0.4.0"
   },
   "devDependencies": {
     "@types/node": "^25.2.3",