@jackchen_me/open-multi-agent 0.2.0 → 1.0.1

package/src/agent/structured-output.ts

@@ -1,126 +0,0 @@
-/**
- * @fileoverview Structured output utilities for agent responses.
- *
- * Provides JSON extraction, Zod validation, and system-prompt injection so
- * that agents can return typed, schema-validated output.
- */
-
-import { type ZodSchema } from 'zod'
-import { zodToJsonSchema } from '../tool/framework.js'
-
-// ---------------------------------------------------------------------------
-// System-prompt instruction builder
-// ---------------------------------------------------------------------------
-
-/**
- * Build a JSON-mode instruction block to append to the agent's system prompt.
- *
- * Converts the Zod schema to JSON Schema and formats it as a clear directive
- * for the LLM to respond with valid JSON matching the schema.
- */
-export function buildStructuredOutputInstruction(schema: ZodSchema): string {
-  const jsonSchema = zodToJsonSchema(schema)
-  return [
-    '',
-    '## Output Format (REQUIRED)',
-    'You MUST respond with ONLY valid JSON that conforms to the following JSON Schema.',
-    'Do NOT include any text, markdown fences, or explanation outside the JSON object.',
-    'Do NOT wrap the JSON in ```json code fences.',
-    '',
-    '```',
-    JSON.stringify(jsonSchema, null, 2),
-    '```',
-  ].join('\n')
-}
-
-// ---------------------------------------------------------------------------
-// JSON extraction
-// ---------------------------------------------------------------------------
-
-/**
- * Attempt to extract and parse JSON from the agent's raw text output.
- *
- * Handles three cases in order:
- * 1. The output is already valid JSON (ideal case)
- * 2. The output contains a ` ```json ` fenced block
- * 3. The output contains a bare JSON object/array (first `{`/`[` to last `}`/`]`)
- *
- * @throws {Error} when no valid JSON can be extracted
- */
-export function extractJSON(raw: string): unknown {
-  const trimmed = raw.trim()
-
-  // Case 1: Direct parse
-  try {
-    return JSON.parse(trimmed)
-  } catch {
-    // Continue to fallback strategies
-  }
-
-  // Case 2a: Prefer ```json tagged fence
-  const jsonFenceMatch = trimmed.match(/```json\s*([\s\S]*?)```/)
-  if (jsonFenceMatch?.[1]) {
-    try {
-      return JSON.parse(jsonFenceMatch[1].trim())
-    } catch {
-      // Continue
-    }
-  }
-
-  // Case 2b: Fall back to bare ``` fence
-  const bareFenceMatch = trimmed.match(/```\s*([\s\S]*?)```/)
-  if (bareFenceMatch?.[1]) {
-    try {
-      return JSON.parse(bareFenceMatch[1].trim())
-    } catch {
-      // Continue
-    }
-  }
-
-  // Case 3: Find first { to last } (object)
-  const objStart = trimmed.indexOf('{')
-  const objEnd = trimmed.lastIndexOf('}')
-  if (objStart !== -1 && objEnd > objStart) {
-    try {
-      return JSON.parse(trimmed.slice(objStart, objEnd + 1))
-    } catch {
-      // Fall through
-    }
-  }
-
-  // Case 3b: Find first [ to last ] (array)
-  const arrStart = trimmed.indexOf('[')
-  const arrEnd = trimmed.lastIndexOf(']')
-  if (arrStart !== -1 && arrEnd > arrStart) {
-    try {
-      return JSON.parse(trimmed.slice(arrStart, arrEnd + 1))
-    } catch {
-      // Fall through
-    }
-  }
-
-  throw new Error(
-    `Failed to extract JSON from output. Raw output begins with: "${trimmed.slice(0, 100)}"`,
-  )
-}
-
-// ---------------------------------------------------------------------------
-// Zod validation
-// ---------------------------------------------------------------------------
-
-/**
- * Validate a parsed JSON value against a Zod schema.
- *
- * @returns The validated (and potentially transformed) value on success.
- * @throws {Error} with a human-readable Zod error message on failure.
- */
-export function validateOutput(schema: ZodSchema, data: unknown): unknown {
-  const result = schema.safeParse(data)
-  if (result.success) {
-    return result.data
-  }
-  const issues = result.error.issues
-    .map(issue => `  - ${issue.path.length > 0 ? issue.path.join('.') : '(root)'}: ${issue.message}`)
-    .join('\n')
-  throw new Error(`Output validation failed:\n${issues}`)
-}

package/src/index.ts

@@ -1,167 +0,0 @@
-/**
- * @fileoverview open-multi-agent — public API surface.
- *
- * Import from `'open-multi-agent'` to access everything you need:
- *
- * ```ts
- * import { OpenMultiAgent, Agent, Team, defineTool } from 'open-multi-agent'
- * ```
- *
- * ## Quickstart
- *
- * ### Single agent
- * ```ts
- * const orchestrator = new OpenMultiAgent({ defaultModel: 'claude-opus-4-6' })
- * const result = await orchestrator.runAgent(
- *   { name: 'assistant', model: 'claude-opus-4-6' },
- *   'Explain monads in one paragraph.',
- * )
- * console.log(result.output)
- * ```
- *
- * ### Multi-agent team (auto-orchestrated)
- * ```ts
- * const orchestrator = new OpenMultiAgent()
- * const team = orchestrator.createTeam('writers', {
- *   name: 'writers',
- *   agents: [
- *     { name: 'researcher', model: 'claude-opus-4-6', systemPrompt: 'You research topics thoroughly.' },
- *     { name: 'writer',     model: 'claude-opus-4-6', systemPrompt: 'You write clear documentation.' },
- *   ],
- *   sharedMemory: true,
- * })
- * const result = await orchestrator.runTeam(team, 'Write a guide on TypeScript generics.')
- * console.log(result.agentResults.get('coordinator')?.output)
- * ```
- *
- * ### Custom tools
- * ```ts
- * import { z } from 'zod'
- *
- * const myTool = defineTool({
- *   name: 'fetch_data',
- *   description: 'Fetch JSON data from a URL.',
- *   inputSchema: z.object({ url: z.string().url() }),
- *   execute: async ({ url }) => {
- *     const res = await fetch(url)
- *     return { data: await res.text() }
- *   },
- * })
- * ```
- */
-
-// ---------------------------------------------------------------------------
-// Orchestrator (primary entry point)
-// ---------------------------------------------------------------------------
-
-export { OpenMultiAgent, executeWithRetry, computeRetryDelay } from './orchestrator/orchestrator.js'
-export { Scheduler } from './orchestrator/scheduler.js'
-export type { SchedulingStrategy } from './orchestrator/scheduler.js'
-
-// ---------------------------------------------------------------------------
-// Agent layer
-// ---------------------------------------------------------------------------
-
-export { Agent } from './agent/agent.js'
-export { buildStructuredOutputInstruction, extractJSON, validateOutput } from './agent/structured-output.js'
-export { AgentPool, Semaphore } from './agent/pool.js'
-export type { PoolStatus } from './agent/pool.js'
-
-// ---------------------------------------------------------------------------
-// Team layer
-// ---------------------------------------------------------------------------
-
-export { Team } from './team/team.js'
-export { MessageBus } from './team/messaging.js'
-export type { Message } from './team/messaging.js'
-
-// ---------------------------------------------------------------------------
-// Task layer
-// ---------------------------------------------------------------------------
-
-export { TaskQueue } from './task/queue.js'
-export { createTask, isTaskReady, getTaskDependencyOrder, validateTaskDependencies } from './task/task.js'
-export type { TaskQueueEvent } from './task/queue.js'
-
-// ---------------------------------------------------------------------------
-// Tool system
-// ---------------------------------------------------------------------------
-
-export { defineTool, ToolRegistry, zodToJsonSchema } from './tool/framework.js'
-export { ToolExecutor } from './tool/executor.js'
-export type { ToolExecutorOptions, BatchToolCall } from './tool/executor.js'
-export {
-  registerBuiltInTools,
-  BUILT_IN_TOOLS,
-  bashTool,
-  fileReadTool,
-  fileWriteTool,
-  fileEditTool,
-  grepTool,
-} from './tool/built-in/index.js'
-
-// ---------------------------------------------------------------------------
-// LLM adapters
-// ---------------------------------------------------------------------------
-
-export { createAdapter } from './llm/adapter.js'
-export type { SupportedProvider } from './llm/adapter.js'
-
-// ---------------------------------------------------------------------------
-// Memory
-// ---------------------------------------------------------------------------
-
-export { InMemoryStore } from './memory/store.js'
-export { SharedMemory } from './memory/shared.js'
-
-// ---------------------------------------------------------------------------
-// Types — all public interfaces re-exported for consumer type-checking
-// ---------------------------------------------------------------------------
-
-export type {
-  // Content blocks
-  TextBlock,
-  ToolUseBlock,
-  ToolResultBlock,
-  ImageBlock,
-  ContentBlock,
-
-  // LLM
-  LLMMessage,
-  LLMResponse,
-  LLMAdapter,
-  LLMChatOptions,
-  LLMStreamOptions,
-  LLMToolDef,
-  TokenUsage,
-  StreamEvent,
-
-  // Tools
-  ToolDefinition,
-  ToolResult,
-  ToolUseContext,
-  AgentInfo,
-  TeamInfo,
-
-  // Agent
-  AgentConfig,
-  AgentState,
-  AgentRunResult,
-  ToolCallRecord,
-
-  // Team
-  TeamConfig,
-  TeamRunResult,
-
-  // Task
-  Task,
-  TaskStatus,
-
-  // Orchestrator
-  OrchestratorConfig,
-  OrchestratorEvent,
-
-  // Memory
-  MemoryEntry,
-  MemoryStore,
-} from './types.js'

package/src/llm/adapter.ts

@@ -1,87 +0,0 @@
-/**
- * @fileoverview LLM adapter factory.
- *
- * Re-exports the {@link LLMAdapter} interface and provides a
- * {@link createAdapter} factory that returns the correct concrete
- * implementation based on the requested provider.
- *
- * @example
- * ```ts
- * import { createAdapter } from './adapter.js'
- *
- * const anthropic = createAdapter('anthropic')
- * const openai    = createAdapter('openai', process.env.OPENAI_API_KEY)
- * ```
- */
-
-export type {
-  LLMAdapter,
-  LLMChatOptions,
-  LLMStreamOptions,
-  LLMToolDef,
-  LLMMessage,
-  LLMResponse,
-  StreamEvent,
-  TokenUsage,
-  ContentBlock,
-  TextBlock,
-  ToolUseBlock,
-  ToolResultBlock,
-  ImageBlock,
-} from '../types.js'
-
-import type { LLMAdapter } from '../types.js'
-
-/**
- * The set of LLM providers supported out of the box.
- * Additional providers can be integrated by implementing {@link LLMAdapter}
- * directly and bypassing this factory.
- */
-export type SupportedProvider = 'anthropic' | 'copilot' | 'openai'
-
-/**
- * Instantiate the appropriate {@link LLMAdapter} for the given provider.
- *
- * API keys fall back to the standard environment variables when not supplied
- * explicitly:
- * - `anthropic` → `ANTHROPIC_API_KEY`
- * - `openai`    → `OPENAI_API_KEY`
- * - `copilot`   → `GITHUB_COPILOT_TOKEN` / `GITHUB_TOKEN`, or interactive
- *                  OAuth2 device flow if neither is set
- *
- * Adapters are imported lazily so that projects using only one provider
- * are not forced to install the SDK for the other.
- *
- * @param provider - Which LLM provider to target.
- * @param apiKey   - Optional API key override; falls back to env var.
- * @param baseURL  - Optional base URL for OpenAI-compatible APIs (Ollama, vLLM, etc.).
- * @throws {Error} When the provider string is not recognised.
- */
-export async function createAdapter(
-  provider: SupportedProvider,
-  apiKey?: string,
-  baseURL?: string,
-): Promise<LLMAdapter> {
-  switch (provider) {
-    case 'anthropic': {
-      const { AnthropicAdapter } = await import('./anthropic.js')
-      return new AnthropicAdapter(apiKey, baseURL)
-    }
-    case 'copilot': {
-      if (baseURL) {
-        console.warn('[open-multi-agent] baseURL is not supported for the copilot provider and will be ignored.')
-      }
-      const { CopilotAdapter } = await import('./copilot.js')
-      return new CopilotAdapter(apiKey)
-    }
-    case 'openai': {
-      const { OpenAIAdapter } = await import('./openai.js')
-      return new OpenAIAdapter(apiKey, baseURL)
-    }
-    default: {
-      // The `never` cast here makes TypeScript enforce exhaustiveness.
-      const _exhaustive: never = provider
-      throw new Error(`Unsupported LLM provider: ${String(_exhaustive)}`)
-    }
-  }
-}