@namzu/sdk 0.1.1 → 0.1.3

package/src/run/reporter.ts

@@ -1,191 +1,185 @@
-import type {
-	AgentRun,
-	RunEvent,
-	RunEventListener,
-} from "../types/run/index.js";
-import { formatCost } from "../utils/cost.js";
-import { type Logger, getRootLogger } from "../utils/logger.js";
+import type { AgentRun, RunEvent, RunEventListener } from '../types/run/index.js'
+import { formatCost } from '../utils/cost.js'
+import { type Logger, getRootLogger } from '../utils/logger.js'
 
 function formatDuration(ms: number): string {
-	if (ms < 1000) return `${ms}ms`;
-	const seconds = Math.floor(ms / 1000);
-	if (seconds < 60) return `${(ms / 1000).toFixed(1)}s`;
-	const minutes = Math.floor(seconds / 60);
-	const remainingSeconds = seconds % 60;
-	return `${minutes}m ${remainingSeconds}s`;
+	if (ms < 1000) return `${ms}ms`
+	const seconds = Math.floor(ms / 1000)
+	if (seconds < 60) return `${(ms / 1000).toFixed(1)}s`
+	const minutes = Math.floor(seconds / 60)
+	const remainingSeconds = seconds % 60
+	return `${minutes}m ${remainingSeconds}s`
 }
 
 export interface RunReporter {
-	listener: RunEventListener;
-	summary(run: AgentRun): void;
+	listener: RunEventListener
+	summary(run: AgentRun): void
 }
 
-export type SessionReporter = RunReporter;
+export type SessionReporter = RunReporter
 
 export function createRunReporter(parentLogger?: Logger): RunReporter {
 	const log = (parentLogger ?? getRootLogger()).child({
-		component: "RunReporter",
-	});
+		component: 'RunReporter',
+	})
 
 	const listener: RunEventListener = (event: RunEvent) => {
 		switch (event.type) {
-			case "run_started":
-				log.info("Run started", {
+			case 'run_started':
+				log.info('Run started', {
 					runId: event.runId,
 					hasSystemPrompt: !!event.systemPrompt,
 					systemPromptLength: event.systemPrompt?.length ?? 0,
-				});
-				break;
+				})
+				break
 
-			case "iteration_started":
+			case 'iteration_started':
 				log.info(`Iteration ${event.iteration} started`, {
 					runId: event.runId,
 					iteration: event.iteration,
-				});
-				break;
+				})
+				break
 
-			case "iteration_completed":
+			case 'iteration_completed':
 				log.info(`Iteration ${event.iteration} completed`, {
 					runId: event.runId,
 					iteration: event.iteration,
 					hasToolCalls: event.hasToolCalls,
-				});
-				break;
+				})
+				break
 
-			case "tool_executing":
+			case 'tool_executing':
 				log.info(`Tool executing: ${event.toolName}`, {
 					runId: event.runId,
 					tool: event.toolName,
-				});
-				break;
+				})
+				break
 
-			case "tool_completed":
+			case 'tool_completed':
 				log.info(`Tool completed: ${event.toolName}`, {
 					runId: event.runId,
 					tool: event.toolName,
-				});
-				break;
+				})
+				break
 
-			case "llm_response":
-				log.info("LLM response received", {
+			case 'llm_response':
+				log.info('LLM response received', {
 					runId: event.runId,
 					hasToolCalls: event.hasToolCalls,
-				});
-				break;
+				})
+				break
 
-			case "token_usage_updated":
-				log.info("Token usage updated", {
+			case 'token_usage_updated':
+				log.info('Token usage updated', {
 					runId: event.runId,
 					promptTokens: event.usage.promptTokens,
 					completionTokens: event.usage.completionTokens,
 					totalTokens: event.usage.totalTokens,
 					totalCost: event.cost.totalCost,
-				});
-				break;
+				})
+				break
 
-			case "run_completed":
-				log.info("Run completed", { runId: event.runId });
-				break;
+			case 'run_completed':
+				log.info('Run completed', { runId: event.runId })
+				break
 
-			case "run_failed":
-				log.error("Run failed", {
+			case 'run_failed':
+				log.error('Run failed', {
 					runId: event.runId,
 					error: event.error,
-				});
-				break;
-
-			case "activity_created":
-			case "activity_updated":
-			case "plan_ready":
-			case "plan_approved":
-			case "plan_rejected":
-			case "plan_step_updated":
-			case "tool_review_requested":
-			case "tool_review_completed":
-			case "checkpoint_created":
-			case "run_paused":
-			case "run_resuming":
-				break;
-
-			case "agent_pending":
+				})
+				break
+
+			case 'activity_created':
+			case 'activity_updated':
+			case 'plan_ready':
+			case 'plan_approved':
+			case 'plan_rejected':
+			case 'plan_step_updated':
+			case 'tool_review_requested':
+			case 'tool_review_completed':
+			case 'checkpoint_created':
+			case 'run_paused':
+			case 'run_resuming':
+				break
+
+			case 'agent_pending':
 				log.info(`Agent task pending: ${event.childAgentId}`, {
 					runId: event.runId,
 					taskId: event.taskId,
 					parentAgentId: event.parentAgentId,
 					childAgentId: event.childAgentId,
 					depth: event.depth,
-				});
-				break;
+				})
+				break
 
-			case "agent_completed":
-				log.info("Agent task completed", {
+			case 'agent_completed':
+				log.info('Agent task completed', {
 					runId: event.runId,
 					taskId: event.taskId,
 					status: event.result.status,
 					iterations: event.result.iterations,
-				});
-				break;
+				})
+				break
 
-			case "agent_failed":
-				log.error("Agent task failed", {
+			case 'agent_failed':
+				log.error('Agent task failed', {
 					runId: event.runId,
 					taskId: event.taskId,
 					error: event.error,
-				});
-				break;
+				})
+				break
 
-			case "agent_canceled":
-				log.info("Agent task canceled", {
+			case 'agent_canceled':
+				log.info('Agent task canceled', {
 					runId: event.runId,
 					taskId: event.taskId,
-				});
-				break;
+				})
+				break
 
-			case "task_created":
+			case 'task_created':
 				log.info(`Task created: ${event.subject}`, {
 					runId: event.runId,
 					taskId: event.taskId,
 					status: event.status,
-				});
-				break;
+				})
+				break
 
-			case "task_updated":
+			case 'task_updated':
 				log.info(`Task updated: ${event.subject}`, {
 					runId: event.runId,
 					taskId: event.taskId,
 					status: event.status,
 					owner: event.owner,
-				});
-				break;
+				})
+				break
 
 			default: {
-				const _exhaustive: never = event;
-				throw new Error(
-					`Unhandled run event type: ${(_exhaustive as RunEvent).type}`,
-				);
+				const _exhaustive: never = event
+				throw new Error(`Unhandled run event type: ${(_exhaustive as RunEvent).type}`)
 			}
 		}
-	};
+	}
 
 	function summary(run: AgentRun): void {
-		const elapsed = (run.endedAt ?? Date.now()) - run.startedAt;
-		const { tokenUsage, costInfo, currentIteration, stopReason } = run;
+		const elapsed = (run.endedAt ?? Date.now()) - run.startedAt
+		const { tokenUsage, costInfo, currentIteration, stopReason } = run
 
-		log.info("Run summary", {
+		log.info('Run summary', {
 			runId: run.id,
 			agent: run.metadata.agentName,
 			status: run.status,
-			stopReason: stopReason ?? "unknown",
+			stopReason: stopReason ?? 'unknown',
 			iterations: currentIteration,
 			promptTokens: tokenUsage.promptTokens,
 			completionTokens: tokenUsage.completionTokens,
 			totalTokens: tokenUsage.totalTokens,
 			cost: formatCost(costInfo.totalCost),
 			duration: formatDuration(elapsed),
-		});
+		})
 	}
 
-	return { listener, summary };
+	return { listener, summary }
 }
 
-export const createSessionReporter = createRunReporter;
+export const createSessionReporter = createRunReporter

package/src/runtime/decision/fallback.ts

@@ -1,93 +1,90 @@
-import type { FallbackStrategy } from '../../types/decision/index.js'
 import type { RoutingDecision } from '../../types/agent/router.js'
+import type { FallbackStrategy } from '../../types/decision/index.js'
 import type { Logger } from '../../utils/logger.js'
 
 export class FallbackResolver {
-  private strategies: FallbackStrategy[]
-  private log: Logger
+	private strategies: FallbackStrategy[]
+	private log: Logger
 
-  constructor(strategies: FallbackStrategy[], log: Logger) {
-    this.strategies = strategies
-    this.log = log
-  }
+	constructor(strategies: FallbackStrategy[], log: Logger) {
+		this.strategies = strategies
+		this.log = log
+	}
 
-  resolve(userContent: string, validAgentIds: string[]): RoutingDecision {
-    for (const strategy of this.strategies) {
-      switch (strategy.type) {
-        case 'pattern_match': {
-          const match = this.matchPatterns(userContent, strategy.patterns)
-          if (match && validAgentIds.includes(match)) {
-            this.log.info('Fallback resolved via pattern match', { agentId: match })
-            return {
-              agentId: match,
-              confidence: 0.5,
-              reasoning: `Pattern match fallback: matched "${match}"`,
-              routingSource: 'fallback',
-            }
-          }
-          break
-        }
-        case 'fixed': {
-          if (validAgentIds.includes(strategy.agentId)) {
-            this.log.info('Fallback resolved via fixed strategy', { agentId: strategy.agentId })
-            return {
-              agentId: strategy.agentId,
-              confidence: 0,
-              reasoning: 'Fixed fallback strategy',
-              routingSource: 'fallback',
-            }
-          }
-          break
-        }
-        case 'first_route': {
-          if (validAgentIds.length > 0) {
-            const first = validAgentIds[0]!
-            this.log.info('Fallback resolved via first_route strategy', { agentId: first })
-            return {
-              agentId: first,
-              confidence: 0,
-              reasoning: 'First route fallback strategy',
-              routingSource: 'fallback',
-            }
-          }
-          break
-        }
-        default: {
-          const _exhaustive: never = strategy
-          throw new Error(`Unhandled fallback strategy: ${(_exhaustive as FallbackStrategy).type}`)
-        }
-      }
-    }
+	resolve(userContent: string, validAgentIds: string[]): RoutingDecision {
+		for (const strategy of this.strategies) {
+			switch (strategy.type) {
+				case 'pattern_match': {
+					const match = this.matchPatterns(userContent, strategy.patterns)
+					if (match && validAgentIds.includes(match)) {
+						this.log.info('Fallback resolved via pattern match', { agentId: match })
+						return {
+							agentId: match,
+							confidence: 0.5,
+							reasoning: `Pattern match fallback: matched "${match}"`,
+							routingSource: 'fallback',
+						}
+					}
+					break
+				}
+				case 'fixed': {
+					if (validAgentIds.includes(strategy.agentId)) {
+						this.log.info('Fallback resolved via fixed strategy', { agentId: strategy.agentId })
+						return {
+							agentId: strategy.agentId,
+							confidence: 0,
+							reasoning: 'Fixed fallback strategy',
+							routingSource: 'fallback',
+						}
+					}
+					break
+				}
+				case 'first_route': {
+					const first = validAgentIds[0]
+					if (first !== undefined) {
+						this.log.info('Fallback resolved via first_route strategy', { agentId: first })
+						return {
+							agentId: first,
+							confidence: 0,
+							reasoning: 'First route fallback strategy',
+							routingSource: 'fallback',
+						}
+					}
+					break
+				}
+				default: {
+					const _exhaustive: never = strategy
+					throw new Error(`Unhandled fallback strategy: ${(_exhaustive as FallbackStrategy).type}`)
+				}
+			}
+		}
 
-    this.log.error('All fallback strategies exhausted')
-    return {
-      agentId: validAgentIds[0] ?? '',
-      confidence: 0,
-      reasoning: 'All fallback strategies exhausted',
-      routingSource: 'hard_fail',
-    }
-  }
+		this.log.error('All fallback strategies exhausted')
+		return {
+			agentId: validAgentIds[0] ?? '',
+			confidence: 0,
+			reasoning: 'All fallback strategies exhausted',
+			routingSource: 'hard_fail',
+		}
+	}
 
-  private matchPatterns(
-    userContent: string,
-    patterns: Map<string, string[]>,
-  ): string | null {
-    const lower = userContent.toLowerCase()
-    let bestMatch: { agentId: string; score: number } | null = null
+	private matchPatterns(userContent: string, patterns: Map<string, string[]>): string | null {
+		const lower = userContent.toLowerCase()
+		let bestMatch: { agentId: string; score: number } | null = null
 
-    for (const [agentId, keywords] of patterns) {
-      let score = 0
-      for (const keyword of keywords) {
-        if (lower.includes(keyword.toLowerCase())) {
-          score++
-        }
-      }
+		for (const [agentId, keywords] of patterns) {
+			let score = 0
+			for (const keyword of keywords) {
+				if (lower.includes(keyword.toLowerCase())) {
+					score++
+				}
+			}
 
-      if (score > 0 && (!bestMatch || score > bestMatch.score)) {
-        bestMatch = { agentId, score }
-      }
-    }
+			if (score > 0 && (!bestMatch || score > bestMatch.score)) {
+				bestMatch = { agentId, score }
+			}
+		}
 
-    return bestMatch?.agentId ?? null
-  }
+		return bestMatch?.agentId ?? null
+	}
 }