@jackchen_me/open-multi-agent 1.0.0 → 1.0.1

package/examples/11-trace-observability.ts

@@ -1,133 +0,0 @@
-/**
- * Example 11 — Trace Observability
- *
- * Demonstrates the `onTrace` callback for lightweight observability. Every LLM
- * call, tool execution, task lifecycle, and agent run emits a structured trace
- * event with timing data and token usage — giving you full visibility into
- * what's happening inside a multi-agent run.
- *
- * Trace events share a `runId` for correlation, so you can reconstruct the
- * full execution timeline. Pipe them into your own logging, OpenTelemetry, or
- * dashboard.
- *
- * Run:
- *   npx tsx examples/11-trace-observability.ts
- *
- * Prerequisites:
- *   ANTHROPIC_API_KEY env var must be set.
- */
-
-import { OpenMultiAgent } from '../src/index.js'
-import type { AgentConfig, TraceEvent } from '../src/types.js'
-
-// ---------------------------------------------------------------------------
-// Agents
-// ---------------------------------------------------------------------------
-
-const researcher: AgentConfig = {
-  name: 'researcher',
-  model: 'claude-sonnet-4-6',
-  systemPrompt: 'You are a research assistant. Provide concise, factual answers.',
-  maxTurns: 2,
-}
-
-const writer: AgentConfig = {
-  name: 'writer',
-  model: 'claude-sonnet-4-6',
-  systemPrompt: 'You are a technical writer. Summarize research into clear prose.',
-  maxTurns: 2,
-}
-
-// ---------------------------------------------------------------------------
-// Trace handler — log every span with timing
-// ---------------------------------------------------------------------------
-
-function handleTrace(event: TraceEvent): void {
-  const dur = `${event.durationMs}ms`.padStart(7)
-
-  switch (event.type) {
-    case 'llm_call':
-      console.log(
-        `  [LLM]   ${dur}  agent=${event.agent}  model=${event.model}  turn=${event.turn}` +
-        `  tokens=${event.tokens.input_tokens}in/${event.tokens.output_tokens}out`,
-      )
-      break
-    case 'tool_call':
-      console.log(
-        `  [TOOL]  ${dur}  agent=${event.agent}  tool=${event.tool}` +
-        `  error=${event.isError}`,
-      )
-      break
-    case 'task':
-      console.log(
-        `  [TASK]  ${dur}  task="${event.taskTitle}"  agent=${event.agent}` +
-        `  success=${event.success}  retries=${event.retries}`,
-      )
-      break
-    case 'agent':
-      console.log(
-        `  [AGENT] ${dur}  agent=${event.agent}  turns=${event.turns}` +
-        `  tools=${event.toolCalls}  tokens=${event.tokens.input_tokens}in/${event.tokens.output_tokens}out`,
-      )
-      break
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Orchestrator + team
-// ---------------------------------------------------------------------------
-
-const orchestrator = new OpenMultiAgent({
-  defaultModel: 'claude-sonnet-4-6',
-  onTrace: handleTrace,
-})
-
-const team = orchestrator.createTeam('trace-demo', {
-  name: 'trace-demo',
-  agents: [researcher, writer],
-  sharedMemory: true,
-})
-
-// ---------------------------------------------------------------------------
-// Tasks — researcher first, then writer summarizes
-// ---------------------------------------------------------------------------
-
-const tasks = [
-  {
-    title: 'Research topic',
-    description: 'List 5 key benefits of TypeScript for large codebases. Be concise.',
-    assignee: 'researcher',
-  },
-  {
-    title: 'Write summary',
-    description: 'Read the research from shared memory and write a 3-sentence summary.',
-    assignee: 'writer',
-    dependsOn: ['Research topic'],
-  },
-]
-
-// ---------------------------------------------------------------------------
-// Run
-// ---------------------------------------------------------------------------
-
-console.log('Trace Observability Example')
-console.log('='.repeat(60))
-console.log('Pipeline: research → write (with full trace output)')
-console.log('='.repeat(60))
-console.log()
-
-const result = await orchestrator.runTasks(team, tasks)
-
-// ---------------------------------------------------------------------------
-// Summary
-// ---------------------------------------------------------------------------
-
-console.log('\n' + '='.repeat(60))
-console.log(`Overall success: ${result.success}`)
-console.log(`Tokens — input: ${result.totalTokenUsage.input_tokens}, output: ${result.totalTokenUsage.output_tokens}`)
-
-for (const [name, r] of result.agentResults) {
-  const icon = r.success ? 'OK  ' : 'FAIL'
-  console.log(`  [${icon}] ${name}`)
-  console.log(`         ${r.output.slice(0, 200)}`)
-}

package/examples/12-grok.ts

@@ -1,154 +0,0 @@
-/**
- * Example 12 — Multi-Agent Team Collaboration with Grok (xAI)
- *
- * Three specialized agents (architect, developer, reviewer) collaborate via `runTeam()`
- * to build a minimal Express.js REST API. Every agent uses Grok's coding-optimized model.
- *
- * Run:
- *   npx tsx examples/12-grok.ts
- *
- * Prerequisites:
- *   XAI_API_KEY environment variable must be set.
- */
-
-import { OpenMultiAgent } from '../src/index.js'
-import type { AgentConfig, OrchestratorEvent } from '../src/types.js'
-
-// ---------------------------------------------------------------------------
-// Agent definitions (all using grok-code-fast-1)
-// ---------------------------------------------------------------------------
-const architect: AgentConfig = {
-  name: 'architect',
-  model: 'grok-code-fast-1',
-  provider: 'grok',
-  systemPrompt: `You are a software architect with deep experience in Node.js and REST API design.
-Your job is to design clear, production-quality API contracts and file/directory structures.
-Output concise plans in markdown — no unnecessary prose.`,
-  tools: ['bash', 'file_write'],
-  maxTurns: 5,
-  temperature: 0.2,
-}
-
-const developer: AgentConfig = {
-  name: 'developer',
-  model: 'grok-code-fast-1',
-  provider: 'grok',
-  systemPrompt: `You are a TypeScript/Node.js developer. You implement what the architect specifies.
-Write clean, runnable code with proper error handling. Use the tools to write files and run tests.`,
-  tools: ['bash', 'file_read', 'file_write', 'file_edit'],
-  maxTurns: 12,
-  temperature: 0.1,
-}
-
-const reviewer: AgentConfig = {
-  name: 'reviewer',
-  model: 'grok-code-fast-1',
-  provider: 'grok',
-  systemPrompt: `You are a senior code reviewer. Review code for correctness, security, and clarity.
-Provide a structured review with: LGTM items, suggestions, and any blocking issues.
-Read files using the tools before reviewing.`,
-  tools: ['bash', 'file_read', 'grep'],
-  maxTurns: 5,
-  temperature: 0.3,
-}
-
-// ---------------------------------------------------------------------------
-// Progress tracking
-// ---------------------------------------------------------------------------
-const startTimes = new Map<string, number>()
-
-function handleProgress(event: OrchestratorEvent): void {
-  const ts = new Date().toISOString().slice(11, 23) // HH:MM:SS.mmm
-  switch (event.type) {
-    case 'agent_start':
-      startTimes.set(event.agent ?? '', Date.now())
-      console.log(`[${ts}] AGENT START → ${event.agent}`)
-      break
-    case 'agent_complete': {
-      const elapsed = Date.now() - (startTimes.get(event.agent ?? '') ?? Date.now())
-      console.log(`[${ts}] AGENT DONE ← ${event.agent} (${elapsed}ms)`)
-      break
-    }
-    case 'task_start':
-      console.log(`[${ts}] TASK START ↓ ${event.task}`)
-      break
-    case 'task_complete':
-      console.log(`[${ts}] TASK DONE ↑ ${event.task}`)
-      break
-    case 'message':
-      console.log(`[${ts}] MESSAGE • ${event.agent} → (team)`)
-      break
-    case 'error':
-      console.error(`[${ts}] ERROR ✗ agent=${event.agent} task=${event.task}`)
-      if (event.data instanceof Error) console.error(` ${event.data.message}`)
-      break
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Orchestrate
-// ---------------------------------------------------------------------------
-const orchestrator = new OpenMultiAgent({
-  defaultModel: 'grok-code-fast-1',
-  defaultProvider: 'grok',
-  maxConcurrency: 1, // sequential for readable output
-  onProgress: handleProgress,
-})
-
-const team = orchestrator.createTeam('api-team', {
-  name: 'api-team',
-  agents: [architect, developer, reviewer],
-  sharedMemory: true,
-  maxConcurrency: 1,
-})
-
-console.log(`Team "${team.name}" created with agents: ${team.getAgents().map(a => a.name).join(', ')}`)
-console.log('\nStarting team run...\n')
-console.log('='.repeat(60))
-
-const goal = `Create a minimal Express.js REST API in /tmp/express-api/ with:
-- GET /health → { status: "ok" }
-- GET /users → returns a hardcoded array of 2 user objects
-- POST /users → accepts { name, email } body, logs it, returns 201
-- Proper error handling middleware
-- The server should listen on port 3001
-- Include a package.json with the required dependencies`
-
-const result = await orchestrator.runTeam(team, goal)
-
-console.log('\n' + '='.repeat(60))
-
-// ---------------------------------------------------------------------------
-// Results
-// ---------------------------------------------------------------------------
-console.log('\nTeam run complete.')
-console.log(`Success: ${result.success}`)
-console.log(`Total tokens — input: ${result.totalTokenUsage.input_tokens}, output: ${result.totalTokenUsage.output_tokens}`)
-
-console.log('\nPer-agent results:')
-for (const [agentName, agentResult] of result.agentResults) {
-  const status = agentResult.success ? 'OK' : 'FAILED'
-  const tools = agentResult.toolCalls.length
-  console.log(` ${agentName.padEnd(12)} [${status}] tool_calls=${tools}`)
-  if (!agentResult.success) {
-    console.log(` Error: ${agentResult.output.slice(0, 120)}`)
-  }
-}
-
-// Sample outputs
-const developerResult = result.agentResults.get('developer')
-if (developerResult?.success) {
-  console.log('\nDeveloper output (last 600 chars):')
-  console.log('─'.repeat(60))
-  const out = developerResult.output
-  console.log(out.length > 600 ? '...' + out.slice(-600) : out)
-  console.log('─'.repeat(60))
-}
-
-const reviewerResult = result.agentResults.get('reviewer')
-if (reviewerResult?.success) {
-  console.log('\nReviewer output:')
-  console.log('─'.repeat(60))
-  console.log(reviewerResult.output)
-  console.log('─'.repeat(60))
-}

package/examples/13-gemini.ts

@@ -1,48 +0,0 @@
-/**
- * Quick smoke test for the Gemini adapter.
- *
- * Run:
- *   npx tsx examples/13-gemini.ts
- *
- * If GEMINI_API_KEY is not set, the adapter will not work.
- */
-
-import { OpenMultiAgent } from '../src/index.js'
-import type { OrchestratorEvent } from '../src/types.js'
-
-const orchestrator = new OpenMultiAgent({
-  defaultModel: 'gemini-2.5-flash',
-  defaultProvider: 'gemini',
-  onProgress: (event: OrchestratorEvent) => {
-    if (event.type === 'agent_start') {
-      console.log(`[start]    agent=${event.agent}`)
-    } else if (event.type === 'agent_complete') {
-      console.log(`[complete] agent=${event.agent}`)
-    }
-  },
-})
-
-console.log('Testing Gemini adapter with gemini-2.5-flash...\n')
-
-const result = await orchestrator.runAgent(
-  {
-    name: 'assistant',
-    model: 'gemini-2.5-flash',
-    provider: 'gemini',
-    systemPrompt: 'You are a helpful assistant. Keep answers brief.',
-    maxTurns: 1,
-    maxTokens: 256,
-  },
-  'What is 2 + 2? Reply in one sentence.',
-)
-
-if (result.success) {
-  console.log('\nAgent output:')
-  console.log('─'.repeat(60))
-  console.log(result.output)
-  console.log('─'.repeat(60))
-  console.log(`\nTokens: input=${result.tokenUsage.input_tokens}, output=${result.tokenUsage.output_tokens}`)
-} else {
-  console.error('Agent failed:', result.output)
-  process.exit(1)
-}