@jackchen_me/open-multi-agent 1.0.0 → 1.0.1

package/tests/structured-output.test.ts

@@ -1,331 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { z } from 'zod'
-import {
-  buildStructuredOutputInstruction,
-  extractJSON,
-  validateOutput,
-} from '../src/agent/structured-output.js'
-import { Agent } from '../src/agent/agent.js'
-import { AgentRunner } from '../src/agent/runner.js'
-import { ToolRegistry } from '../src/tool/framework.js'
-import { ToolExecutor } from '../src/tool/executor.js'
-import type { AgentConfig, LLMAdapter, LLMResponse } from '../src/types.js'
-
-// ---------------------------------------------------------------------------
-// Mock LLM adapter factory
-// ---------------------------------------------------------------------------
-
-function mockAdapter(responses: string[]): LLMAdapter {
-  let callIndex = 0
-  return {
-    name: 'mock',
-    async chat() {
-      const text = responses[callIndex++] ?? ''
-      return {
-        id: `mock-${callIndex}`,
-        content: [{ type: 'text' as const, text }],
-        model: 'mock-model',
-        stop_reason: 'end_turn',
-        usage: { input_tokens: 10, output_tokens: 20 },
-      } satisfies LLMResponse
-    },
-    async *stream() {
-      /* unused in these tests */
-    },
-  }
-}
-
-// ---------------------------------------------------------------------------
-// extractJSON
-// ---------------------------------------------------------------------------
-
-describe('extractJSON', () => {
-  it('parses clean JSON', () => {
-    expect(extractJSON('{"a":1}')).toEqual({ a: 1 })
-  })
-
-  it('parses JSON wrapped in ```json fence', () => {
-    const raw = 'Here is the result:\n```json\n{"a":1}\n```\nDone.'
-    expect(extractJSON(raw)).toEqual({ a: 1 })
-  })
-
-  it('parses JSON wrapped in bare ``` fence', () => {
-    const raw = '```\n{"a":1}\n```'
-    expect(extractJSON(raw)).toEqual({ a: 1 })
-  })
-
-  it('extracts embedded JSON object from surrounding text', () => {
-    const raw = 'The answer is {"summary":"hello","score":5} as shown above.'
-    expect(extractJSON(raw)).toEqual({ summary: 'hello', score: 5 })
-  })
-
-  it('extracts JSON array', () => {
-    expect(extractJSON('[1,2,3]')).toEqual([1, 2, 3])
-  })
-
-  it('extracts embedded JSON array from surrounding text', () => {
-    const raw = 'Here: [{"a":1},{"a":2}] end'
-    expect(extractJSON(raw)).toEqual([{ a: 1 }, { a: 2 }])
-  })
-
-  it('throws on non-JSON text', () => {
-    expect(() => extractJSON('just plain text')).toThrow('Failed to extract JSON')
-  })
-
-  it('throws on empty string', () => {
-    expect(() => extractJSON('')).toThrow('Failed to extract JSON')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// validateOutput
-// ---------------------------------------------------------------------------
-
-describe('validateOutput', () => {
-  const schema = z.object({
-    summary: z.string(),
-    score: z.number().min(0).max(10),
-  })
-
-  it('returns validated data on success', () => {
-    const data = { summary: 'hello', score: 5 }
-    expect(validateOutput(schema, data)).toEqual(data)
-  })
-
-  it('throws on missing field', () => {
-    expect(() => validateOutput(schema, { summary: 'hello' })).toThrow(
-      'Output validation failed',
-    )
-  })
-
-  it('throws on wrong type', () => {
-    expect(() =>
-      validateOutput(schema, { summary: 'hello', score: 'not a number' }),
-    ).toThrow('Output validation failed')
-  })
-
-  it('throws on value out of range', () => {
-    expect(() =>
-      validateOutput(schema, { summary: 'hello', score: 99 }),
-    ).toThrow('Output validation failed')
-  })
-
-  it('applies Zod transforms', () => {
-    const transformSchema = z.object({
-      name: z.string().transform(s => s.toUpperCase()),
-    })
-    const result = validateOutput(transformSchema, { name: 'alice' })
-    expect(result).toEqual({ name: 'ALICE' })
-  })
-
-  it('strips unknown keys with strict schema', () => {
-    const strictSchema = z.object({ a: z.number() }).strict()
-    expect(() =>
-      validateOutput(strictSchema, { a: 1, b: 2 }),
-    ).toThrow('Output validation failed')
-  })
-
-  it('shows (root) for root-level errors', () => {
-    const stringSchema = z.string()
-    expect(() => validateOutput(stringSchema, 42)).toThrow('(root)')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// buildStructuredOutputInstruction
-// ---------------------------------------------------------------------------
-
-describe('buildStructuredOutputInstruction', () => {
-  it('includes the JSON Schema representation', () => {
-    const schema = z.object({
-      summary: z.string(),
-      score: z.number(),
-    })
-    const instruction = buildStructuredOutputInstruction(schema)
-
-    expect(instruction).toContain('Output Format (REQUIRED)')
-    expect(instruction).toContain('"type": "object"')
-    expect(instruction).toContain('"summary"')
-    expect(instruction).toContain('"score"')
-    expect(instruction).toContain('ONLY valid JSON')
-  })
-
-  it('includes description from Zod schema', () => {
-    const schema = z.object({
-      name: z.string().describe('The person name'),
-    })
-    const instruction = buildStructuredOutputInstruction(schema)
-    expect(instruction).toContain('The person name')
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Agent integration (mocked LLM)
-// ---------------------------------------------------------------------------
-
-/**
- * Build an Agent with a mocked LLM adapter by injecting an AgentRunner
- * directly into the Agent's private `runner` field, bypassing `createAdapter`.
- */
-function buildMockAgent(config: AgentConfig, responses: string[]): Agent {
-  const adapter = mockAdapter(responses)
-  const registry = new ToolRegistry()
-  const executor = new ToolExecutor(registry)
-  const agent = new Agent(config, registry, executor)
-
-  // Inject a pre-built runner so `getRunner()` returns it without calling createAdapter.
-  const runner = new AgentRunner(adapter, registry, executor, {
-    model: config.model,
-    systemPrompt: config.systemPrompt,
-    maxTurns: config.maxTurns,
-    maxTokens: config.maxTokens,
-    temperature: config.temperature,
-    agentName: config.name,
-  })
-  ;(agent as any).runner = runner
-
-  return agent
-}
-
-describe('Agent structured output (end-to-end)', () => {
-  const schema = z.object({
-    summary: z.string(),
-    sentiment: z.enum(['positive', 'negative', 'neutral']),
-    confidence: z.number().min(0).max(1),
-  })
-
-  const baseConfig: AgentConfig = {
-    name: 'test-agent',
-    model: 'mock-model',
-    systemPrompt: 'You are a test agent.',
-    outputSchema: schema,
-  }
-
-  it('happy path: valid JSON on first attempt', async () => {
-    const validJSON = JSON.stringify({
-      summary: 'Great product',
-      sentiment: 'positive',
-      confidence: 0.95,
-    })
-
-    const agent = buildMockAgent(baseConfig, [validJSON])
-    const result = await agent.run('Analyze this review')
-
-    expect(result.success).toBe(true)
-    expect(result.structured).toEqual({
-      summary: 'Great product',
-      sentiment: 'positive',
-      confidence: 0.95,
-    })
-  })
-
-  it('retry: invalid first attempt, valid second attempt', async () => {
-    const invalidJSON = JSON.stringify({
-      summary: 'Great product',
-      sentiment: 'INVALID_VALUE',
-      confidence: 0.95,
-    })
-    const validJSON = JSON.stringify({
-      summary: 'Great product',
-      sentiment: 'positive',
-      confidence: 0.95,
-    })
-
-    const agent = buildMockAgent(baseConfig, [invalidJSON, validJSON])
-    const result = await agent.run('Analyze this review')
-
-    expect(result.success).toBe(true)
-    expect(result.structured).toEqual({
-      summary: 'Great product',
-      sentiment: 'positive',
-      confidence: 0.95,
-    })
-    // Token usage should reflect both attempts
-    expect(result.tokenUsage.input_tokens).toBe(20) // 10 + 10
-    expect(result.tokenUsage.output_tokens).toBe(40) // 20 + 20
-  })
-
-  it('both attempts fail: success=false, structured=undefined', async () => {
-    const bad1 = '{"summary": "ok", "sentiment": "WRONG"}'
-    const bad2 = '{"summary": "ok", "sentiment": "ALSO_WRONG"}'
-
-    const agent = buildMockAgent(baseConfig, [bad1, bad2])
-    const result = await agent.run('Analyze this review')
-
-    expect(result.success).toBe(false)
-    expect(result.structured).toBeUndefined()
-  })
-
-  it('no outputSchema: original behavior, structured is undefined', async () => {
-    const configNoSchema: AgentConfig = {
-      name: 'plain-agent',
-      model: 'mock-model',
-      systemPrompt: 'You are a test agent.',
-    }
-
-    const agent = buildMockAgent(configNoSchema, ['Just plain text output'])
-    const result = await agent.run('Hello')
-
-    expect(result.success).toBe(true)
-    expect(result.output).toBe('Just plain text output')
-    expect(result.structured).toBeUndefined()
-  })
-
-  it('handles JSON wrapped in markdown fence', async () => {
-    const fenced = '```json\n{"summary":"ok","sentiment":"neutral","confidence":0.5}\n```'
-
-    const agent = buildMockAgent(baseConfig, [fenced])
-    const result = await agent.run('Analyze')
-
-    expect(result.success).toBe(true)
-    expect(result.structured).toEqual({
-      summary: 'ok',
-      sentiment: 'neutral',
-      confidence: 0.5,
-    })
-  })
-
-  it('non-JSON output triggers retry, valid JSON on retry succeeds', async () => {
-    const nonJSON = 'I am not sure how to analyze this.'
-    const validJSON = JSON.stringify({
-      summary: 'Uncertain',
-      sentiment: 'neutral',
-      confidence: 0.1,
-    })
-
-    const agent = buildMockAgent(baseConfig, [nonJSON, validJSON])
-    const result = await agent.run('Analyze this review')
-
-    expect(result.success).toBe(true)
-    expect(result.structured).toEqual({
-      summary: 'Uncertain',
-      sentiment: 'neutral',
-      confidence: 0.1,
-    })
-  })
-
-  it('non-JSON output on both attempts: success=false', async () => {
-    const agent = buildMockAgent(baseConfig, [
-      'Sorry, I cannot do that.',
-      'Still cannot do it.',
-    ])
-    const result = await agent.run('Analyze this review')
-
-    expect(result.success).toBe(false)
-    expect(result.structured).toBeUndefined()
-  })
-
-  it('token usage on first-attempt success reflects single call only', async () => {
-    const validJSON = JSON.stringify({
-      summary: 'Good',
-      sentiment: 'positive',
-      confidence: 0.9,
-    })
-
-    const agent = buildMockAgent(baseConfig, [validJSON])
-    const result = await agent.run('Analyze')
-
-    expect(result.tokenUsage.input_tokens).toBe(10)
-    expect(result.tokenUsage.output_tokens).toBe(20)
-  })
-})

package/tests/task-queue.test.ts

@@ -1,244 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { TaskQueue } from '../src/task/queue.js'
-import { createTask } from '../src/task/task.js'
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Create a simple task with a predictable id. */
-function task(id: string, opts: { dependsOn?: string[]; assignee?: string } = {}) {
-  const t = createTask({ title: id, description: `task ${id}`, assignee: opts.assignee })
-  // Override the random UUID so tests can reference tasks by name.
-  return { ...t, id, dependsOn: opts.dependsOn } as ReturnType<typeof createTask>
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('TaskQueue', () => {
-  // -------------------------------------------------------------------------
-  // Basic add & query
-  // -------------------------------------------------------------------------
-
-  it('adds a task and lists it', () => {
-    const q = new TaskQueue()
-    q.add(task('a'))
-    expect(q.list()).toHaveLength(1)
-    expect(q.list()[0].id).toBe('a')
-  })
-
-  it('fires task:ready for a task with no dependencies', () => {
-    const q = new TaskQueue()
-    const handler = vi.fn()
-    q.on('task:ready', handler)
-
-    q.add(task('a'))
-    expect(handler).toHaveBeenCalledTimes(1)
-    expect(handler.mock.calls[0][0].id).toBe('a')
-  })
-
-  it('blocks a task whose dependency is not yet completed', () => {
-    const q = new TaskQueue()
-    q.add(task('a'))
-    q.add(task('b', { dependsOn: ['a'] }))
-
-    const b = q.list().find((t) => t.id === 'b')!
-    expect(b.status).toBe('blocked')
-  })
-
-  // -------------------------------------------------------------------------
-  // Dependency resolution
-  // -------------------------------------------------------------------------
-
-  it('unblocks a dependent task when its dependency completes', () => {
-    const q = new TaskQueue()
-    const readyHandler = vi.fn()
-    q.on('task:ready', readyHandler)
-
-    q.add(task('a'))
-    q.add(task('b', { dependsOn: ['a'] }))
-
-    // 'a' fires task:ready, 'b' is blocked
-    expect(readyHandler).toHaveBeenCalledTimes(1)
-
-    q.complete('a', 'done')
-
-    // 'b' should now be unblocked → fires task:ready
-    expect(readyHandler).toHaveBeenCalledTimes(2)
-    expect(readyHandler.mock.calls[1][0].id).toBe('b')
-    expect(q.list().find((t) => t.id === 'b')!.status).toBe('pending')
-  })
-
-  it('keeps a task blocked until ALL dependencies complete', () => {
-    const q = new TaskQueue()
-    q.add(task('a'))
-    q.add(task('b'))
-    q.add(task('c', { dependsOn: ['a', 'b'] }))
-
-    q.complete('a')
-
-    const cAfterA = q.list().find((t) => t.id === 'c')!
-    expect(cAfterA.status).toBe('blocked')
-
-    q.complete('b')
-
-    const cAfterB = q.list().find((t) => t.id === 'c')!
-    expect(cAfterB.status).toBe('pending')
-  })
-
-  // -------------------------------------------------------------------------
-  // Cascade failure
-  // -------------------------------------------------------------------------
-
-  it('cascades failure to direct dependents', () => {
-    const q = new TaskQueue()
-    const failHandler = vi.fn()
-    q.on('task:failed', failHandler)
-
-    q.add(task('a'))
-    q.add(task('b', { dependsOn: ['a'] }))
-
-    q.fail('a', 'boom')
-
-    expect(failHandler).toHaveBeenCalledTimes(2) // a + b
-    expect(q.list().find((t) => t.id === 'b')!.status).toBe('failed')
-    expect(q.list().find((t) => t.id === 'b')!.result).toContain('dependency')
-  })
-
-  it('cascades failure transitively (a → b → c)', () => {
-    const q = new TaskQueue()
-    q.add(task('a'))
-    q.add(task('b', { dependsOn: ['a'] }))
-    q.add(task('c', { dependsOn: ['b'] }))
-
-    q.fail('a', 'boom')
-
-    expect(q.list().every((t) => t.status === 'failed')).toBe(true)
-  })
-
-  it('does not cascade failure to independent tasks', () => {
-    const q = new TaskQueue()
-    q.add(task('a'))
-    q.add(task('b'))
-    q.add(task('c', { dependsOn: ['a'] }))
-
-    q.fail('a', 'boom')
-
-    expect(q.list().find((t) => t.id === 'b')!.status).toBe('pending')
-    expect(q.list().find((t) => t.id === 'c')!.status).toBe('failed')
-  })
-
-  // -------------------------------------------------------------------------
-  // Completion
-  // -------------------------------------------------------------------------
-
-  it('fires all:complete when every task reaches a terminal state', () => {
-    const q = new TaskQueue()
-    const allComplete = vi.fn()
-    q.on('all:complete', allComplete)
-
-    q.add(task('a'))
-    q.add(task('b'))
-
-    q.complete('a')
-    expect(allComplete).not.toHaveBeenCalled()
-
-    q.complete('b')
-    expect(allComplete).toHaveBeenCalledTimes(1)
-  })
-
-  it('fires all:complete when mix of completed and failed', () => {
-    const q = new TaskQueue()
-    const allComplete = vi.fn()
-    q.on('all:complete', allComplete)
-
-    q.add(task('a'))
-    q.add(task('b', { dependsOn: ['a'] }))
-
-    q.fail('a', 'err') // cascades to b
-    expect(allComplete).toHaveBeenCalledTimes(1)
-  })
-
-  it('isComplete returns true for an empty queue', () => {
-    const q = new TaskQueue()
-    expect(q.isComplete()).toBe(true)
-  })
-
-  // -------------------------------------------------------------------------
-  // Query: next / nextAvailable
-  // -------------------------------------------------------------------------
-
-  it('next() returns a pending task for the given assignee', () => {
-    const q = new TaskQueue()
-    q.add(task('a', { assignee: 'alice' }))
-    q.add(task('b', { assignee: 'bob' }))
-
-    expect(q.next('bob')?.id).toBe('b')
-  })
-
-  it('next() returns undefined when no pending task matches', () => {
-    const q = new TaskQueue()
-    q.add(task('a', { assignee: 'alice' }))
-    expect(q.next('bob')).toBeUndefined()
-  })
-
-  it('nextAvailable() prefers unassigned tasks', () => {
-    const q = new TaskQueue()
-    q.add(task('assigned', { assignee: 'alice' }))
-    q.add(task('unassigned'))
-
-    expect(q.nextAvailable()?.id).toBe('unassigned')
-  })
-
-  // -------------------------------------------------------------------------
-  // Progress
-  // -------------------------------------------------------------------------
-
-  it('getProgress() returns correct counts', () => {
-    const q = new TaskQueue()
-    q.add(task('a'))
-    q.add(task('b'))
-    q.add(task('c', { dependsOn: ['a'] }))
-
-    q.complete('a')
-
-    const p = q.getProgress()
-    expect(p.total).toBe(3)
-    expect(p.completed).toBe(1)
-    expect(p.pending).toBe(2) // b + c (unblocked)
-    expect(p.blocked).toBe(0)
-  })
-
-  // -------------------------------------------------------------------------
-  // Event unsubscribe
-  // -------------------------------------------------------------------------
-
-  it('unsubscribe stops receiving events', () => {
-    const q = new TaskQueue()
-    const handler = vi.fn()
-    const off = q.on('task:ready', handler)
-
-    q.add(task('a'))
-    expect(handler).toHaveBeenCalledTimes(1)
-
-    off()
-    q.add(task('b'))
-    expect(handler).toHaveBeenCalledTimes(1) // no new call
-  })
-
-  // -------------------------------------------------------------------------
-  // Error cases
-  // -------------------------------------------------------------------------
-
-  it('throws when completing a non-existent task', () => {
-    const q = new TaskQueue()
-    expect(() => q.complete('ghost')).toThrow('not found')
-  })
-
-  it('throws when failing a non-existent task', () => {
-    const q = new TaskQueue()
-    expect(() => q.fail('ghost', 'err')).toThrow('not found')
-  })
-})