@namzu/sdk 0.1.1 → 0.1.3

package/src/agents/RouterAgent.ts

@@ -1,236 +1,224 @@
-import type { RunEventListener } from '../types/run/index.js'
+import { FallbackResolver } from '../runtime/decision/fallback.js'
+import { DecisionParser } from '../runtime/decision/parser.js'
 import type {
-  RouterAgentConfig,
-  RouterAgentResult,
-  RoutingDecision,
-  AgentInput,
-  AgentMetadata,
+	AgentInput,
+	AgentMetadata,
+	RouterAgentConfig,
+	RouterAgentResult,
+	RoutingDecision,
 } from '../types/agent/index.js'
-import { AbstractAgent } from './AbstractAgent.js'
 import { EMPTY_TOKEN_USAGE } from '../types/common/index.js'
-import { ZERO_COST } from '../utils/cost.js'
-import {
-  createSystemMessage,
-  createUserMessage,
-} from '../types/message/index.js'
-import { DecisionParser } from '../runtime/decision/parser.js'
-import { FallbackResolver } from '../runtime/decision/fallback.js'
 import type { FallbackStrategy } from '../types/decision/index.js'
+import { createSystemMessage, createUserMessage } from '../types/message/index.js'
+import type { RunEventListener } from '../types/run/index.js'
+import { ZERO_COST } from '../utils/cost.js'
 import { getRootLogger } from '../utils/logger.js'
+import { AbstractAgent } from './AbstractAgent.js'
 
 export class RouterAgent extends AbstractAgent<RouterAgentConfig, RouterAgentResult> {
-  readonly type = 'router' as const
-
-  constructor(metadata: Omit<AgentMetadata, 'type' | 'capabilities'>) {
-    super({
-      ...metadata,
-      type: 'router',
-      capabilities: {
-        supportsTools: false,
-        supportsStreaming: true,
-        supportsConcurrency: false,
-        supportsSubAgents: true,
-      },
-    })
-  }
-
-  async run(
-    input: AgentInput,
-    config: RouterAgentConfig,
-    listener?: RunEventListener,
-  ): Promise<RouterAgentResult> {
-    const startTime = Date.now()
-    const runId = this.createRunId()
-
-    await this.emitEvent({ type: 'run_started', runId }, listener)
-
-    const decision = await this.route(input, config)
-
-    let targetRoute = config.routes.find((r) => r.agentId === decision.agentId)
-
-    if (!targetRoute) {
-      const fallback = config.fallbackAgentId
-        ? config.routes.find((r) => r.agentId === config.fallbackAgentId)
-        : undefined
-
-      if (!fallback) {
-        const errorMsg = `No route found for "${decision.agentId}"`
-
-        await this.emitEvent(
-          { type: 'run_failed', runId, error: errorMsg },
-          listener,
-        )
-
-        return {
-          runId,
-          status: 'failed',
-          stopReason: 'error',
-          usage: { ...EMPTY_TOKEN_USAGE },
-          cost: { ...ZERO_COST },
-          iterations: 1,
-          durationMs: Date.now() - startTime,
-          messages: input.messages,
-          lastError: errorMsg,
-          selectedRoute: decision.agentId,
-          routingDecision: decision,
-          delegateResult: {
-            runId,
-            status: 'failed',
-            usage: { ...EMPTY_TOKEN_USAGE },
-            cost: { ...ZERO_COST },
-            iterations: 0,
-            durationMs: 0,
-            messages: [],
-          },
-        }
-      }
-
-      decision.agentId = fallback.agentId
-      targetRoute = fallback
-    }
-
-    const delegateResult = await targetRoute.agent.run(input, config, listener)
-
-    await this.emitEvent(
-      {
-        type: 'run_completed',
-        runId,
-        result: delegateResult.result ?? '',
-      },
-      listener,
-    )
-
-    return {
-      runId,
-      status: delegateResult.status,
-      stopReason: delegateResult.stopReason,
-      usage: delegateResult.usage,
-      cost: delegateResult.cost,
-      iterations: delegateResult.iterations + 1,
-      durationMs: Date.now() - startTime,
-      messages: delegateResult.messages,
-      result: delegateResult.result,
-      lastError: delegateResult.lastError,
-      selectedRoute: decision.agentId,
-      routingDecision: decision,
-      delegateResult,
-    }
-  }
-
-  private async route(
-    input: AgentInput,
-    config: RouterAgentConfig,
-  ): Promise<RoutingDecision> {
-    const log = getRootLogger().child({ component: 'RouterAgent', agent: this.metadata.name })
-
-    const validAgentIds = config.routes.map((r) => r.agentId)
-    const fallbackAgentId = config.fallbackAgentId ?? config.routes[0]?.agentId ?? ''
-    const minConfidence = config.minConfidence ?? 0
-    const maxRetries = config.maxRoutingRetries ?? 1
-
-    const parser = new DecisionParser(
-      {
-        validAgentIds,
-        minConfidence,
-        maxRetries,
-        fallbackAgentId,
-      },
-      log,
-    )
-
-    const fallbackStrategies: FallbackStrategy[] = []
-
-    const patternMap = new Map<string, string[]>()
-    for (const route of config.routes) {
-      if (route.matchPatterns && route.matchPatterns.length > 0) {
-        patternMap.set(route.agentId, route.matchPatterns)
-      }
-    }
-    if (patternMap.size > 0) {
-      fallbackStrategies.push({ type: 'pattern_match', patterns: patternMap })
-    }
-
-    if (config.fallbackAgentId) {
-      fallbackStrategies.push({ type: 'fixed', agentId: config.fallbackAgentId })
-    }
-
-    fallbackStrategies.push({ type: 'first_route' })
-
-    const fallbackResolver = new FallbackResolver(fallbackStrategies, log)
-
-    const routeDescriptions = config.routes
-      .map((r) => `- ${r.agentId}: ${r.description}`)
-      .join('\n')
-
-    const prompt = config.routingPrompt ??
-      `Given the user's request, select the most appropriate agent.\n\nAvailable agents:\n${routeDescriptions}\n\nRespond with JSON only: { "agentId": "<id>", "confidence": <0-1>, "reasoning": "<why>" }`
-
-    const userContent = input.messages
-      .filter((m) => m.role === 'user')
-      .map((m) => m.content)
-      .filter((c): c is string => c !== null)
-      .join('\n')
-
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      try {
-        const response = await config.provider.chat({
-          model: config.model,
-          messages: [
-            createSystemMessage(prompt),
-            createUserMessage(userContent),
-          ],
-          temperature: 0,
-          maxTokens: 200,
-        })
-
-        const parseResult = parser.parse(response.message.content)
-
-        if (parseResult.ok && parseResult.source === 'parsed') {
-          return {
-            agentId: parseResult.decision.agentId,
-            confidence: parseResult.decision.confidence,
-            reasoning: parseResult.decision.reasoning,
-            routingSource: 'provider',
-          }
-        }
-
-        if (parseResult.ok && parseResult.source === 'fallback') {
-          log.warn(`Routing attempt ${attempt + 1} fell back`, {
-            reason: parseResult.reason,
-            decision: parseResult.decision,
-          })
-
-          if (attempt === maxRetries - 1) {
-            return {
-              agentId: parseResult.decision.agentId,
-              confidence: parseResult.decision.confidence,
-              reasoning: parseResult.decision.reasoning,
-              routingSource: 'fallback',
-            }
-          }
-
-          continue
-        }
-
-        if (!parseResult.ok) {
-          log.warn(`Routing attempt ${attempt + 1} failed to parse`, {
-            error: parseResult.error,
-          })
-          if (attempt === maxRetries - 1) {
-            break
-          }
-          continue
-        }
-      } catch (err) {
-        log.warn(`Routing LLM call failed on attempt ${attempt + 1}`, {
-          error: String(err),
-        })
-        if (attempt === maxRetries - 1) {
-          break
-        }
-      }
-    }
-
-    return fallbackResolver.resolve(userContent, validAgentIds)
-  }
+	readonly type = 'router' as const
+
+	constructor(metadata: Omit<AgentMetadata, 'type' | 'capabilities'>) {
+		super({
+			...metadata,
+			type: 'router',
+			capabilities: {
+				supportsTools: false,
+				supportsStreaming: true,
+				supportsConcurrency: false,
+				supportsSubAgents: true,
+			},
+		})
+	}
+
+	async run(
+		input: AgentInput,
+		config: RouterAgentConfig,
+		listener?: RunEventListener,
+	): Promise<RouterAgentResult> {
+		const startTime = Date.now()
+		const runId = this.createRunId()
+
+		await this.emitEvent({ type: 'run_started', runId }, listener)
+
+		const decision = await this.route(input, config)
+
+		let targetRoute = config.routes.find((r) => r.agentId === decision.agentId)
+
+		if (!targetRoute) {
+			const fallback = config.fallbackAgentId
+				? config.routes.find((r) => r.agentId === config.fallbackAgentId)
+				: undefined
+
+			if (!fallback) {
+				const errorMsg = `No route found for "${decision.agentId}"`
+
+				await this.emitEvent({ type: 'run_failed', runId, error: errorMsg }, listener)
+
+				return {
+					runId,
+					status: 'failed',
+					stopReason: 'error',
+					usage: { ...EMPTY_TOKEN_USAGE },
+					cost: { ...ZERO_COST },
+					iterations: 1,
+					durationMs: Date.now() - startTime,
+					messages: input.messages,
+					lastError: errorMsg,
+					selectedRoute: decision.agentId,
+					routingDecision: decision,
+					delegateResult: {
+						runId,
+						status: 'failed',
+						usage: { ...EMPTY_TOKEN_USAGE },
+						cost: { ...ZERO_COST },
+						iterations: 0,
+						durationMs: 0,
+						messages: [],
+					},
+				}
+			}
+
+			decision.agentId = fallback.agentId
+			targetRoute = fallback
+		}
+
+		const delegateResult = await targetRoute.agent.run(input, config, listener)
+
+		await this.emitEvent(
+			{
+				type: 'run_completed',
+				runId,
+				result: delegateResult.result ?? '',
+			},
+			listener,
+		)
+
+		return {
+			runId,
+			status: delegateResult.status,
+			stopReason: delegateResult.stopReason,
+			usage: delegateResult.usage,
+			cost: delegateResult.cost,
+			iterations: delegateResult.iterations + 1,
+			durationMs: Date.now() - startTime,
+			messages: delegateResult.messages,
+			result: delegateResult.result,
+			lastError: delegateResult.lastError,
+			selectedRoute: decision.agentId,
+			routingDecision: decision,
+			delegateResult,
+		}
+	}
+
+	private async route(input: AgentInput, config: RouterAgentConfig): Promise<RoutingDecision> {
+		const log = getRootLogger().child({ component: 'RouterAgent', agent: this.metadata.name })
+
+		const validAgentIds = config.routes.map((r) => r.agentId)
+		const fallbackAgentId = config.fallbackAgentId ?? config.routes[0]?.agentId ?? ''
+		const minConfidence = config.minConfidence ?? 0
+		const maxRetries = config.maxRoutingRetries ?? 1
+
+		const parser = new DecisionParser(
+			{
+				validAgentIds,
+				minConfidence,
+				maxRetries,
+				fallbackAgentId,
+			},
+			log,
+		)
+
+		const fallbackStrategies: FallbackStrategy[] = []
+
+		const patternMap = new Map<string, string[]>()
+		for (const route of config.routes) {
+			if (route.matchPatterns && route.matchPatterns.length > 0) {
+				patternMap.set(route.agentId, route.matchPatterns)
+			}
+		}
+		if (patternMap.size > 0) {
+			fallbackStrategies.push({ type: 'pattern_match', patterns: patternMap })
+		}
+
+		if (config.fallbackAgentId) {
+			fallbackStrategies.push({ type: 'fixed', agentId: config.fallbackAgentId })
+		}
+
+		fallbackStrategies.push({ type: 'first_route' })
+
+		const fallbackResolver = new FallbackResolver(fallbackStrategies, log)
+
+		const routeDescriptions = config.routes
+			.map((r) => `- ${r.agentId}: ${r.description}`)
+			.join('\n')
+
+		const prompt =
+			config.routingPrompt ??
+			`Given the user's request, select the most appropriate agent.\n\nAvailable agents:\n${routeDescriptions}\n\nRespond with JSON only: { "agentId": "<id>", "confidence": <0-1>, "reasoning": "<why>" }`
+
+		const userContent = input.messages
+			.filter((m) => m.role === 'user')
+			.map((m) => m.content)
+			.filter((c): c is string => c !== null)
+			.join('\n')
+
+		for (let attempt = 0; attempt < maxRetries; attempt++) {
+			try {
+				const response = await config.provider.chat({
+					model: config.model,
+					messages: [createSystemMessage(prompt), createUserMessage(userContent)],
+					temperature: 0,
+					maxTokens: 200,
+				})
+
+				const parseResult = parser.parse(response.message.content)
+
+				if (parseResult.ok && parseResult.source === 'parsed') {
+					return {
+						agentId: parseResult.decision.agentId,
+						confidence: parseResult.decision.confidence,
+						reasoning: parseResult.decision.reasoning,
+						routingSource: 'provider',
+					}
+				}
+
+				if (parseResult.ok && parseResult.source === 'fallback') {
+					log.warn(`Routing attempt ${attempt + 1} fell back`, {
+						reason: parseResult.reason,
+						decision: parseResult.decision,
+					})
+
+					if (attempt === maxRetries - 1) {
+						return {
+							agentId: parseResult.decision.agentId,
+							confidence: parseResult.decision.confidence,
+							reasoning: parseResult.decision.reasoning,
+							routingSource: 'fallback',
+						}
+					}
+
+					continue
+				}
+
+				if (!parseResult.ok) {
+					log.warn(`Routing attempt ${attempt + 1} failed to parse`, {
+						error: parseResult.error,
+					})
+					if (attempt === maxRetries - 1) {
+						break
+					}
+				}
+			} catch (err) {
+				log.warn(`Routing LLM call failed on attempt ${attempt + 1}`, {
+					error: String(err),
+				})
+				if (attempt === maxRetries - 1) {
+					break
+				}
+			}
+		}
+
+		return fallbackResolver.resolve(userContent, validAgentIds)
+	}
 }

package/src/agents/SupervisorAgent.ts

@@ -1,39 +1,36 @@
+import { LocalTaskGateway } from '../gateway/local.js'
+import { ToolRegistry } from '../registry/tool/execute.js'
+import { drainQuery } from '../runtime/query/index.js'
+import type { LaunchedTaskMeta } from '../runtime/query/iteration/phases/context.js'
+import { buildCoordinatorTools } from '../tools/coordinator/index.js'
+import type { TaskGateway } from '../types/agent/gateway.js'
 import type {
 	AgentInput,
 	AgentMetadata,
 	SupervisorAgentConfig,
 	SupervisorAgentResult,
-} from "../types/agent/index.js";
-import type { AgentTaskContext } from "../types/agent/task.js";
-import type { TaskGateway } from "../types/agent/gateway.js";
-import type { TaskId, ThreadId } from "../types/ids/index.js";
-import type { RunEventListener } from "../types/run/index.js";
-import type { LaunchedTaskMeta } from "../runtime/query/iteration/phases/context.js";
-import { EMPTY_TOKEN_USAGE } from "../types/common/index.js";
-import { ZERO_COST } from "../utils/cost.js";
-import { ToolRegistry } from "../registry/tool/execute.js";
-import { LocalTaskGateway } from "../gateway/local.js";
-import { buildCoordinatorTools } from "../tools/coordinator/index.js";
-import { drainQuery } from "../runtime/query/index.js";
-import { AbstractAgent } from "./AbstractAgent.js";
+} from '../types/agent/index.js'
+import type { AgentTaskContext } from '../types/agent/task.js'
+import { EMPTY_TOKEN_USAGE } from '../types/common/index.js'
+import type { TaskId, ThreadId } from '../types/ids/index.js'
+import type { RunEventListener } from '../types/run/index.js'
+import { ZERO_COST } from '../utils/cost.js'
+import { AbstractAgent } from './AbstractAgent.js'
 
-export class SupervisorAgent extends AbstractAgent<
-	SupervisorAgentConfig,
-	SupervisorAgentResult
-> {
-	readonly type = "supervisor" as const;
+export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, SupervisorAgentResult> {
+	readonly type = 'supervisor' as const
 
-	constructor(metadata: Omit<AgentMetadata, "type" | "capabilities">) {
+	constructor(metadata: Omit<AgentMetadata, 'type' | 'capabilities'>) {
 		super({
 			...metadata,
-			type: "supervisor",
+			type: 'supervisor',
 			capabilities: {
 				supportsTools: true,
 				supportsStreaming: true,
 				supportsConcurrency: true,
 				supportsSubAgents: true,
 			},
-		});
+		})
 	}
 
 	async run(
@@ -41,16 +38,16 @@ export class SupervisorAgent extends AbstractAgent<
 		config: SupervisorAgentConfig,
 		listener?: RunEventListener,
 	): Promise<SupervisorAgentResult> {
-		const startTime = Date.now();
-		const runId = this.createRunId();
+		const startTime = Date.now()
+		const runId = this.createRunId()
 
 		if (!config.threadId) {
-			throw new Error("SupervisorAgent requires threadId in config");
+			throw new Error('SupervisorAgent requires threadId in config')
 		}
 
-		let gateway: TaskGateway;
+		let gateway: TaskGateway
 		if (config.gateway) {
-			gateway = config.gateway;
+			gateway = config.gateway
 		} else if (config.agentManager) {
 			const taskContext: AgentTaskContext = {
 				parentRunId: runId,
@@ -63,17 +60,15 @@ export class SupervisorAgent extends AbstractAgent<
 				},
 				factoryOptions: config.factoryOptions,
 				threadId: config.threadId as ThreadId,
-			};
-			gateway = new LocalTaskGateway(config.agentManager, taskContext, listener, input);
+			}
+			gateway = new LocalTaskGateway(config.agentManager, taskContext, listener, input)
 		} else {
-			throw new Error(
-				"SupervisorAgentConfig requires either 'gateway' or 'agentManager'",
-			);
+			throw new Error("SupervisorAgentConfig requires either 'gateway' or 'agentManager'")
 		}
 
-		const launchedTasks = new Map<TaskId, LaunchedTaskMeta>();
+		const launchedTasks = new Map<TaskId, LaunchedTaskMeta>()
 
-		let planManagerRef: import('../manager/plan/lifecycle.js').PlanManager | undefined;
+		let planManagerRef: import('../manager/plan/lifecycle.js').PlanManager | undefined
 
 		const coordinatorToolDefs = buildCoordinatorTools({
 			gateway,
@@ -83,13 +78,13 @@ export class SupervisorAgent extends AbstractAgent<
 			runId,
 			getPlanManager: () => planManagerRef,
 			onTaskLaunched: (agentTaskId, meta) => {
-				launchedTasks.set(agentTaskId, meta);
+				launchedTasks.set(agentTaskId, meta)
 			},
-		});
+		})
 
-		const tools = new ToolRegistry();
+		const tools = new ToolRegistry()
 		for (const tool of coordinatorToolDefs) {
-			tools.register(tool);
+			tools.register(tool)
 		}
 
 		const session = await drainQuery(
@@ -114,22 +109,24 @@ export class SupervisorAgent extends AbstractAgent<
 				runId,
 				parentRunId: config.parentRunId,
 				depth: config.depth,
-				contextLevel: "full",
-				onContextCreated: ({ planManager }) => { planManagerRef = planManager; },
+				contextLevel: 'full',
+				onContextCreated: ({ planManager }) => {
+					planManagerRef = planManager
+				},
 				taskStore: input.taskStore,
 				runtimeToolOverrides: input.runtimeToolOverrides,
 				taskGateway: gateway,
 				launchedTasks,
 			},
 			listener,
-		);
+		)
 
-		const taskHandles = gateway.listTasks();
+		const taskHandles = gateway.listTasks()
 		const taskResults = taskHandles.map((handle, index) => ({
 			agentId: handle.agentId,
 			result: handle.result ?? {
 				runId,
-				status: handle.state as "completed" | "failed" | "cancelled",
+				status: handle.state as 'completed' | 'failed' | 'cancelled',
 				usage: { ...EMPTY_TOKEN_USAGE },
 				cost: { ...ZERO_COST },
 				iterations: 0,
@@ -137,15 +134,13 @@ export class SupervisorAgent extends AbstractAgent<
 				messages: [],
 			},
 			taskIndex: index,
-		}));
+		}))
 
-		const completedTasks = taskResults.filter(
-			(t) => t.result.status === "completed",
-		).length;
+		const completedTasks = taskResults.filter((t) => t.result.status === 'completed').length
 
 		return {
 			runId: session.id,
-			status: session.status === "completed" ? "completed" : "failed",
+			status: session.status === 'completed' ? 'completed' : 'failed',
 			stopReason: session.stopReason,
 			usage: session.tokenUsage,
 			cost: session.costInfo,
@@ -157,6 +152,6 @@ export class SupervisorAgent extends AbstractAgent<
 			taskResults,
 			completedTasks,
 			totalTasks: taskResults.length,
-		};
+		}
 	}
 }