@jackchen_me/open-multi-agent 0.1.0

package/examples/02-team-collaboration.ts

@@ -0,0 +1,167 @@
+/**
+ * Example 02 — Multi-Agent Team Collaboration
+ *
+ * Three specialised agents (architect, developer, reviewer) collaborate on a
+ * shared goal. The OpenMultiAgent orchestrator breaks the goal into tasks, assigns
+ * them to the right agents, and collects the results.
+ *
+ * Run:
+ *   npx tsx examples/02-team-collaboration.ts
+ *
+ * Prerequisites:
+ *   ANTHROPIC_API_KEY env var must be set.
+ */
+
+import { OpenMultiAgent } from '../src/index.js'
+import type { AgentConfig, OrchestratorEvent } from '../src/types.js'
+
+// ---------------------------------------------------------------------------
+// Agent definitions
+// ---------------------------------------------------------------------------
+
+const architect: AgentConfig = {
+  name: 'architect',
+  model: 'claude-sonnet-4-6',
+  provider: 'anthropic',
+  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: 'claude-sonnet-4-6',
+  provider: 'anthropic',
+  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: 'claude-sonnet-4-6',
+  provider: 'anthropic',
+  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: 'claude-sonnet-4-6',
+  maxConcurrency: 1, // run agents sequentially so output is readable
+  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)}`)
+  }
+}
+
+// Print the developer's final output (the actual code) as a sample
+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))
+}
+
+// Print the reviewer's findings
+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/03-task-pipeline.ts

@@ -0,0 +1,201 @@
+/**
+ * Example 03 — Explicit Task Pipeline with Dependencies
+ *
+ * Demonstrates how to define tasks with explicit dependency chains
+ * (design → implement → test → review) using runTasks(). The TaskQueue
+ * automatically blocks downstream tasks until their dependencies complete.
+ *
+ * Run:
+ *   npx tsx examples/03-task-pipeline.ts
+ *
+ * Prerequisites:
+ *   ANTHROPIC_API_KEY env var must be set.
+ */
+
+import { OpenMultiAgent } from '../src/index.js'
+import type { AgentConfig, OrchestratorEvent, Task } from '../src/types.js'
+
+// ---------------------------------------------------------------------------
+// Agents
+// ---------------------------------------------------------------------------
+
+const designer: AgentConfig = {
+  name: 'designer',
+  model: 'claude-sonnet-4-6',
+  systemPrompt: `You are a software designer. Your output is always a concise technical spec
+in markdown. Focus on interfaces, data shapes, and file structure. Be brief.`,
+  tools: ['file_write'],
+  maxTurns: 4,
+}
+
+const implementer: AgentConfig = {
+  name: 'implementer',
+  model: 'claude-sonnet-4-6',
+  systemPrompt: `You are a TypeScript developer. Read the design spec written by the designer,
+then implement it. Write all files to /tmp/pipeline-output/. Use the tools.`,
+  tools: ['bash', 'file_read', 'file_write'],
+  maxTurns: 10,
+}
+
+const tester: AgentConfig = {
+  name: 'tester',
+  model: 'claude-sonnet-4-6',
+  systemPrompt: `You are a QA engineer. Read the implemented files and run them to verify correctness.
+Report: what passed, what failed, and any bugs found.`,
+  tools: ['bash', 'file_read', 'grep'],
+  maxTurns: 6,
+}
+
+const reviewer: AgentConfig = {
+  name: 'reviewer',
+  model: 'claude-sonnet-4-6',
+  systemPrompt: `You are a code reviewer. Read all files and produce a brief structured review.
+Sections: Summary, Strengths, Issues (if any), Verdict (SHIP / NEEDS WORK).`,
+  tools: ['file_read', 'grep'],
+  maxTurns: 4,
+}
+
+// ---------------------------------------------------------------------------
+// Progress handler — shows dependency blocking/unblocking
+// ---------------------------------------------------------------------------
+
+const taskTimes = new Map<string, number>()
+
+function handleProgress(event: OrchestratorEvent): void {
+  const ts = new Date().toISOString().slice(11, 23)
+
+  switch (event.type) {
+    case 'task_start': {
+      taskTimes.set(event.task ?? '', Date.now())
+      const task = event.data as Task | undefined
+      console.log(`[${ts}] TASK READY    "${task?.title ?? event.task}" (assignee: ${task?.assignee ?? 'any'})`)
+      break
+    }
+    case 'task_complete': {
+      const elapsed = Date.now() - (taskTimes.get(event.task ?? '') ?? Date.now())
+      const task = event.data as Task | undefined
+      console.log(`[${ts}] TASK DONE     "${task?.title ?? event.task}" in ${elapsed}ms`)
+      break
+    }
+    case 'agent_start':
+      console.log(`[${ts}] AGENT START   ${event.agent}`)
+      break
+    case 'agent_complete':
+      console.log(`[${ts}] AGENT DONE    ${event.agent}`)
+      break
+    case 'error': {
+      const task = event.data as Task | undefined
+      console.error(`[${ts}] ERROR         ${event.agent ?? ''}  task="${task?.title ?? event.task}"`)
+      break
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Build the pipeline
+// ---------------------------------------------------------------------------
+
+const orchestrator = new OpenMultiAgent({
+  defaultModel: 'claude-sonnet-4-6',
+  maxConcurrency: 2, // allow test + review to potentially run in parallel later
+  onProgress: handleProgress,
+})
+
+const team = orchestrator.createTeam('pipeline-team', {
+  name: 'pipeline-team',
+  agents: [designer, implementer, tester, reviewer],
+  sharedMemory: true,
+})
+
+// Task IDs — use stable strings so dependsOn can reference them
+// (IDs will be generated by the framework; we capture the returned Task objects)
+const SPEC_FILE = '/tmp/pipeline-output/design-spec.md'
+
+const tasks: Array<{
+  title: string
+  description: string
+  assignee?: string
+  dependsOn?: string[]
+}> = [
+  {
+    title: 'Design: URL shortener data model',
+    description: `Design a minimal in-memory URL shortener service.
+Write a markdown spec to ${SPEC_FILE} covering:
+- TypeScript interfaces for Url and ShortenRequest
+- The shortening algorithm (hash approach is fine)
+- API contract: POST /shorten, GET /:code
+Keep the spec under 30 lines.`,
+    assignee: 'designer',
+    // no dependencies — this is the root task
+  },
+  {
+    title: 'Implement: URL shortener',
+    description: `Read the design spec at ${SPEC_FILE}.
+Implement the URL shortener in /tmp/pipeline-output/src/:
+- shortener.ts: core logic (shorten, resolve functions)
+- server.ts: tiny HTTP server using Node's built-in http module (no Express)
+  - POST /shorten  body: { url: string } → { code: string, short: string }
+  - GET  /:code    → redirect (301) or 404
+- index.ts: entry point that starts the server on port 3002
+No external dependencies beyond Node built-ins.`,
+    assignee: 'implementer',
+    dependsOn: ['Design: URL shortener data model'],
+  },
+  {
+    title: 'Test: URL shortener',
+    description: `Run the URL shortener implementation:
+1. Start the server: node /tmp/pipeline-output/src/index.ts (or tsx)
+2. POST a URL to shorten it using curl
+3. Verify the GET redirect works
+4. Report what passed and what (if anything) failed.
+Kill the server after testing.`,
+    assignee: 'tester',
+    dependsOn: ['Implement: URL shortener'],
+  },
+  {
+    title: 'Review: URL shortener',
+    description: `Read all .ts files in /tmp/pipeline-output/src/ and the design spec.
+Produce a structured code review with sections:
+- Summary (2 sentences)
+- Strengths (bullet list)
+- Issues (bullet list, or "None" if clean)
+- Verdict: SHIP or NEEDS WORK`,
+    assignee: 'reviewer',
+    dependsOn: ['Implement: URL shortener'], // runs in parallel with Test after Implement completes
+  },
+]
+
+// ---------------------------------------------------------------------------
+// Run
+// ---------------------------------------------------------------------------
+
+console.log('Starting 4-stage task pipeline...\n')
+console.log('Pipeline: design → implement → test + review (parallel)')
+console.log('='.repeat(60))
+
+const result = await orchestrator.runTasks(team, tasks)
+
+// ---------------------------------------------------------------------------
+// Summary
+// ---------------------------------------------------------------------------
+
+console.log('\n' + '='.repeat(60))
+console.log('Pipeline complete.\n')
+console.log(`Overall success: ${result.success}`)
+console.log(`Tokens — input: ${result.totalTokenUsage.input_tokens}, output: ${result.totalTokenUsage.output_tokens}`)
+
+console.log('\nPer-agent summary:')
+for (const [name, r] of result.agentResults) {
+  const icon = r.success ? 'OK  ' : 'FAIL'
+  const toolCount = r.toolCalls.map(c => c.toolName).join(', ')
+  console.log(`  [${icon}] ${name.padEnd(14)}  tools used: ${toolCount || '(none)'}`)
+}
+
+// Print the reviewer's verdict
+const review = result.agentResults.get('reviewer')
+if (review?.success) {
+  console.log('\nCode review:')
+  console.log('─'.repeat(60))
+  console.log(review.output)
+  console.log('─'.repeat(60))
+}

package/examples/04-multi-model-team.ts

@@ -0,0 +1,261 @@
+/**
+ * Example 04 — Multi-Model Team with Custom Tools
+ *
+ * Demonstrates:
+ * - Mixing Anthropic and OpenAI models in the same team
+ * - Defining custom tools with defineTool() and Zod schemas
+ * - Building agents with a custom ToolRegistry so they can use custom tools
+ * - Running a team goal that uses the custom tools
+ *
+ * Run:
+ *   npx tsx examples/04-multi-model-team.ts
+ *
+ * Prerequisites:
+ *   ANTHROPIC_API_KEY and OPENAI_API_KEY env vars must be set.
+ *   (If you only have one key, set useOpenAI = false below.)
+ */
+
+import { z } from 'zod'
+import { OpenMultiAgent, defineTool } from '../src/index.js'
+import type { AgentConfig, OrchestratorEvent } from '../src/types.js'
+
+// ---------------------------------------------------------------------------
+// Custom tools — defined with defineTool() + Zod schemas
+// ---------------------------------------------------------------------------
+
+/**
+ * A custom tool that fetches live exchange rates from a public API.
+ */
+const exchangeRateTool = defineTool({
+  name: 'get_exchange_rate',
+  description:
+    'Get the current exchange rate between two currencies. ' +
+    'Returns the rate as a decimal: 1 unit of `from` = N units of `to`.',
+  inputSchema: z.object({
+    from: z.string().describe('ISO 4217 currency code, e.g. "USD"'),
+    to: z.string().describe('ISO 4217 currency code, e.g. "EUR"'),
+  }),
+  execute: async ({ from, to }) => {
+    try {
+      const url = `https://api.exchangerate.host/convert?from=${from}&to=${to}&amount=1`
+      const resp = await fetch(url, { signal: AbortSignal.timeout(5000) })
+
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}`)
+
+      interface ExchangeRateResponse {
+        result?: number
+        info?: { rate?: number }
+      }
+      const json = (await resp.json()) as ExchangeRateResponse
+      const rate: number | undefined = json?.result ?? json?.info?.rate
+
+      if (typeof rate !== 'number') throw new Error('Unexpected API response shape')
+
+      return {
+        data: JSON.stringify({ from, to, rate, timestamp: new Date().toISOString() }),
+        isError: false,
+      }
+    } catch (err) {
+      // Graceful degradation — return a stubbed rate so the team can still proceed
+      const stub = parseFloat((Math.random() * 0.5 + 0.8).toFixed(4))
+      return {
+        data: JSON.stringify({
+          from,
+          to,
+          rate: stub,
+          note: `Live fetch failed (${err instanceof Error ? err.message : String(err)}). Using stub rate.`,
+        }),
+        isError: false,
+      }
+    }
+  },
+})
+
+/**
+ * A custom tool that formats a number as a localised currency string.
+ */
+const formatCurrencyTool = defineTool({
+  name: 'format_currency',
+  description: 'Format a number as a localised currency string.',
+  inputSchema: z.object({
+    amount: z.number().describe('The numeric amount to format.'),
+    currency: z.string().describe('ISO 4217 currency code, e.g. "USD".'),
+    locale: z
+      .string()
+      .optional()
+      .describe('BCP 47 locale string, e.g. "en-US". Defaults to "en-US".'),
+  }),
+  execute: async ({ amount, currency, locale = 'en-US' }) => {
+    try {
+      const formatted = new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency,
+      }).format(amount)
+      return { data: formatted, isError: false }
+    } catch {
+      return { data: `${amount} ${currency}`, isError: true }
+    }
+  },
+})
+
+// ---------------------------------------------------------------------------
+// Helper: build an AgentConfig whose tools list includes custom tool names.
+//
+// Agents reference tools by name in their AgentConfig.tools array.
+// The ToolRegistry is injected via the Agent constructor. When using OpenMultiAgent
+// convenience methods (runTeam, runTasks, runAgent), the orchestrator builds
+// agents internally using buildAgent(), which registers only the five built-in
+// tools. For custom tools, use AgentPool + Agent directly (see the note in the
+// README) or provide the custom tool names in the tools array and rely on a
+// registry you inject yourself.
+//
+// In this example we demonstrate the custom-tool pattern by running the agents
+// directly through AgentPool rather than through the OpenMultiAgent high-level API.
+// ---------------------------------------------------------------------------
+
+import { Agent, AgentPool, ToolRegistry, ToolExecutor, registerBuiltInTools } from '../src/index.js'
+
+/**
+ * Build an Agent with both built-in and custom tools registered.
+ */
+function buildCustomAgent(
+  config: AgentConfig,
+  extraTools: ReturnType<typeof defineTool>[],
+): Agent {
+  const registry = new ToolRegistry()
+  registerBuiltInTools(registry)
+  for (const tool of extraTools) {
+    registry.register(tool)
+  }
+  const executor = new ToolExecutor(registry)
+  return new Agent(config, registry, executor)
+}
+
+// ---------------------------------------------------------------------------
+// Agent definitions — mixed providers
+// ---------------------------------------------------------------------------
+
+const useOpenAI = Boolean(process.env.OPENAI_API_KEY)
+
+const researcherConfig: AgentConfig = {
+  name: 'researcher',
+  model: 'claude-sonnet-4-6',
+  provider: 'anthropic',
+  systemPrompt: `You are a financial data researcher.
+Use the get_exchange_rate tool to fetch current rates between the currency pairs you are given.
+Return the raw rates as a JSON object keyed by pair, e.g. { "USD/EUR": 0.91, "USD/GBP": 0.79 }.`,
+  tools: ['get_exchange_rate'],
+  maxTurns: 6,
+  temperature: 0,
+}
+
+const analystConfig: AgentConfig = {
+  name: 'analyst',
+  model: useOpenAI ? 'gpt-5.4' : 'claude-sonnet-4-6',
+  provider: useOpenAI ? 'openai' : 'anthropic',
+  systemPrompt: `You are a foreign exchange analyst.
+You receive exchange rate data and produce a short briefing.
+Use format_currency to show example conversions.
+Keep the briefing under 200 words.`,
+  tools: ['format_currency'],
+  maxTurns: 4,
+  temperature: 0.3,
+}
+
+// ---------------------------------------------------------------------------
+// Build agents with custom tools
+// ---------------------------------------------------------------------------
+
+const researcher = buildCustomAgent(researcherConfig, [exchangeRateTool])
+const analyst = buildCustomAgent(analystConfig, [formatCurrencyTool])
+
+// ---------------------------------------------------------------------------
+// Run with AgentPool for concurrency control
+// ---------------------------------------------------------------------------
+
+console.log('Multi-model team with custom tools')
+console.log(`Providers: researcher=anthropic, analyst=${useOpenAI ? 'openai (gpt-5.4)' : 'anthropic (fallback)'}`)
+console.log('Custom tools:', [exchangeRateTool.name, formatCurrencyTool.name].join(', '))
+console.log()
+
+const pool = new AgentPool(1) // sequential for readability
+pool.add(researcher)
+pool.add(analyst)
+
+// Step 1: researcher fetches the rates
+console.log('[1/2] Researcher fetching FX rates...')
+const researchResult = await pool.run(
+  'researcher',
+  `Fetch exchange rates for these pairs using the get_exchange_rate tool:
+- USD to EUR
+- USD to GBP
+- USD to JPY
+- EUR to GBP
+
+Return the results as a JSON object: { "USD/EUR": <rate>, "USD/GBP": <rate>, ... }`,
+)
+
+if (!researchResult.success) {
+  console.error('Researcher failed:', researchResult.output)
+  process.exit(1)
+}
+
+console.log('Researcher done. Tool calls made:', researchResult.toolCalls.map(c => c.toolName).join(', '))
+
+// Step 2: analyst writes the briefing, receiving the researcher output as context
+console.log('\n[2/2] Analyst writing FX briefing...')
+const analystResult = await pool.run(
+  'analyst',
+  `Here are the current FX rates gathered by the research team:
+
+${researchResult.output}
+
+Using format_currency, show what $1,000 USD and €1,000 EUR convert to in each of the other currencies.
+Then write a short FX market briefing (under 200 words) covering:
+- Each rate with a brief observation
+- The strongest and weakest currency in the set
+- One-sentence market comment`,
+)
+
+if (!analystResult.success) {
+  console.error('Analyst failed:', analystResult.output)
+  process.exit(1)
+}
+
+console.log('Analyst done. Tool calls made:', analystResult.toolCalls.map(c => c.toolName).join(', '))
+
+// ---------------------------------------------------------------------------
+// Results
+// ---------------------------------------------------------------------------
+
+console.log('\n' + '='.repeat(60))
+
+console.log('\nResearcher output:')
+console.log(researchResult.output.slice(0, 400))
+
+console.log('\nAnalyst briefing:')
+console.log('─'.repeat(60))
+console.log(analystResult.output)
+console.log('─'.repeat(60))
+
+const totalInput = researchResult.tokenUsage.input_tokens + analystResult.tokenUsage.input_tokens
+const totalOutput = researchResult.tokenUsage.output_tokens + analystResult.tokenUsage.output_tokens
+console.log(`\nTotal tokens — input: ${totalInput}, output: ${totalOutput}`)
+
+// ---------------------------------------------------------------------------
+// Bonus: show how defineTool() works in isolation (no LLM needed)
+// ---------------------------------------------------------------------------
+
+console.log('\n--- Bonus: testing custom tools in isolation ---\n')
+
+const fmtResult = await formatCurrencyTool.execute(
+  { amount: 1234.56, currency: 'EUR', locale: 'de-DE' },
+  { agent: { name: 'test', role: 'test', model: 'test' } },
+)
+console.log(`format_currency(1234.56, EUR, de-DE) = ${fmtResult.data}`)
+
+const rateResult = await exchangeRateTool.execute(
+  { from: 'USD', to: 'EUR' },
+  { agent: { name: 'test', role: 'test', model: 'test' } },
+)
+console.log(`get_exchange_rate(USD→EUR) = ${rateResult.data}`)

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@jackchen_me/open-multi-agent",
+  "version": "0.1.0",
+  "description": "Production-grade multi-agent orchestration framework. Model-agnostic, supports team collaboration, task scheduling, and inter-agent communication.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "multi-agent",
+    "orchestration",
+    "llm",
+    "claude",
+    "openai",
+    "mcp",
+    "tool-use",
+    "agent-framework"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.52.0",
+    "openai": "^4.73.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0",
+    "@types/node": "^22.0.0"
+  }
+}