@namzu/sdk 0.1.1 → 0.1.3

package/src/runtime/decision/parser.ts

@@ -1,150 +1,154 @@
-import { type RoutingResponse, RoutingResponseSchema, type DecisionParserConfig, type DecisionParseResult } from '../../types/decision/index.js'
+import {
+	type DecisionParseResult,
+	type DecisionParserConfig,
+	RoutingResponseSchema,
+} from '../../types/decision/index.js'
 import type { Logger } from '../../utils/logger.js'
 
 export class DecisionParser {
-  private config: DecisionParserConfig
-  private log: Logger
-
-  constructor(config: DecisionParserConfig, log: Logger) {
-    this.config = config
-    this.log = log
-  }
-
-  parse(rawContent: string | null): DecisionParseResult {
-    if (!rawContent || rawContent.trim().length === 0) {
-      return {
-        ok: true,
-        decision: {
-          agentId: this.config.fallbackAgentId,
-          confidence: 0,
-          reasoning: 'Empty LLM response',
-        },
-        source: 'fallback',
-        reason: 'empty_response',
-      }
-    }
-
-    const jsonStr = this.extractJson(rawContent)
-    if (!jsonStr) {
-      this.log.warn('Failed to extract JSON from LLM routing response', {
-        contentPreview: rawContent.slice(0, 200),
-      })
-      return {
-        ok: true,
-        decision: {
-          agentId: this.config.fallbackAgentId,
-          confidence: 0,
-          reasoning: `Could not extract JSON from response`,
-        },
-        source: 'fallback',
-        reason: 'json_extraction_failed',
-      }
-    }
-
-    let parsed: unknown
-    try {
-      parsed = JSON.parse(jsonStr)
-    } catch (err) {
-      this.log.warn('Invalid JSON in routing response', {
-        error: String(err),
-        contentPreview: jsonStr.slice(0, 200),
-      })
-      return {
-        ok: true,
-        decision: {
-          agentId: this.config.fallbackAgentId,
-          confidence: 0,
-          reasoning: `JSON parse failed: ${String(err)}`,
-        },
-        source: 'fallback',
-        reason: 'json_parse_failed',
-      }
-    }
-
-    const validation = RoutingResponseSchema.safeParse(parsed)
-    if (!validation.success) {
-      const errors = validation.error.issues
-        .map((i) => `${i.path.join('.')}: ${i.message}`)
-        .join('; ')
-
-      this.log.warn('Routing response failed schema validation', { errors })
-
-      return {
-        ok: true,
-        decision: {
-          agentId: this.config.fallbackAgentId,
-          confidence: 0,
-          reasoning: `Schema validation failed: ${errors}`,
-        },
-        source: 'fallback',
-        reason: 'schema_validation_failed',
-      }
-    }
-
-    const response = validation.data
-
-    if (!this.config.validAgentIds.includes(response.agentId)) {
-      this.log.warn('LLM returned unknown agentId', {
-        agentId: response.agentId,
-        validIds: this.config.validAgentIds,
-      })
-
-      return {
-        ok: true,
-        decision: {
-          agentId: this.config.fallbackAgentId,
-          confidence: 0,
-          reasoning: `Unknown agentId "${response.agentId}", falling back`,
-        },
-        source: 'fallback',
-        reason: 'unknown_agent_id',
-      }
-    }
-
-    if (response.confidence < this.config.minConfidence) {
-      this.log.info('Routing confidence below threshold', {
-        confidence: response.confidence,
-        threshold: this.config.minConfidence,
-        agentId: response.agentId,
-      })
-
-      return {
-        ok: true,
-        decision: {
-          agentId: this.config.fallbackAgentId,
-          confidence: response.confidence,
-          reasoning: `Confidence ${response.confidence} below threshold ${this.config.minConfidence}`,
-        },
-        source: 'fallback',
-        reason: 'low_confidence',
-      }
-    }
-
-    return {
-      ok: true,
-      decision: response,
-      source: 'parsed',
-    }
-  }
-
-  private extractJson(content: string): string | null {
-    const trimmed = content.trim()
-
-    if (trimmed.startsWith('{')) {
-      return trimmed
-    }
-
-    const codeBlockMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/)
-    if (codeBlockMatch?.[1]) {
-      return codeBlockMatch[1].trim()
-    }
-
-    const braceStart = trimmed.indexOf('{')
-    const braceEnd = trimmed.lastIndexOf('}')
-    if (braceStart !== -1 && braceEnd > braceStart) {
-      return trimmed.slice(braceStart, braceEnd + 1)
-    }
-
-    return null
-  }
+	private config: DecisionParserConfig
+	private log: Logger
+
+	constructor(config: DecisionParserConfig, log: Logger) {
+		this.config = config
+		this.log = log
+	}
+
+	parse(rawContent: string | null): DecisionParseResult {
+		if (!rawContent || rawContent.trim().length === 0) {
+			return {
+				ok: true,
+				decision: {
+					agentId: this.config.fallbackAgentId,
+					confidence: 0,
+					reasoning: 'Empty LLM response',
+				},
+				source: 'fallback',
+				reason: 'empty_response',
+			}
+		}
+
+		const jsonStr = this.extractJson(rawContent)
+		if (!jsonStr) {
+			this.log.warn('Failed to extract JSON from LLM routing response', {
+				contentPreview: rawContent.slice(0, 200),
+			})
+			return {
+				ok: true,
+				decision: {
+					agentId: this.config.fallbackAgentId,
+					confidence: 0,
+					reasoning: 'Could not extract JSON from response',
+				},
+				source: 'fallback',
+				reason: 'json_extraction_failed',
+			}
+		}
+
+		let parsed: unknown
+		try {
+			parsed = JSON.parse(jsonStr)
+		} catch (err) {
+			this.log.warn('Invalid JSON in routing response', {
+				error: String(err),
+				contentPreview: jsonStr.slice(0, 200),
+			})
+			return {
+				ok: true,
+				decision: {
+					agentId: this.config.fallbackAgentId,
+					confidence: 0,
+					reasoning: `JSON parse failed: ${String(err)}`,
+				},
+				source: 'fallback',
+				reason: 'json_parse_failed',
+			}
+		}
+
+		const validation = RoutingResponseSchema.safeParse(parsed)
+		if (!validation.success) {
+			const errors = validation.error.issues
+				.map((i) => `${i.path.join('.')}: ${i.message}`)
+				.join('; ')
+
+			this.log.warn('Routing response failed schema validation', { errors })
+
+			return {
+				ok: true,
+				decision: {
+					agentId: this.config.fallbackAgentId,
+					confidence: 0,
+					reasoning: `Schema validation failed: ${errors}`,
+				},
+				source: 'fallback',
+				reason: 'schema_validation_failed',
+			}
+		}
+
+		const response = validation.data
+
+		if (!this.config.validAgentIds.includes(response.agentId)) {
+			this.log.warn('LLM returned unknown agentId', {
+				agentId: response.agentId,
+				validIds: this.config.validAgentIds,
+			})
+
+			return {
+				ok: true,
+				decision: {
+					agentId: this.config.fallbackAgentId,
+					confidence: 0,
+					reasoning: `Unknown agentId "${response.agentId}", falling back`,
+				},
+				source: 'fallback',
+				reason: 'unknown_agent_id',
+			}
+		}
+
+		if (response.confidence < this.config.minConfidence) {
+			this.log.info('Routing confidence below threshold', {
+				confidence: response.confidence,
+				threshold: this.config.minConfidence,
+				agentId: response.agentId,
+			})
+
+			return {
+				ok: true,
+				decision: {
+					agentId: this.config.fallbackAgentId,
+					confidence: response.confidence,
+					reasoning: `Confidence ${response.confidence} below threshold ${this.config.minConfidence}`,
+				},
+				source: 'fallback',
+				reason: 'low_confidence',
+			}
+		}
+
+		return {
+			ok: true,
+			decision: response,
+			source: 'parsed',
+		}
+	}
+
+	private extractJson(content: string): string | null {
+		const trimmed = content.trim()
+
+		if (trimmed.startsWith('{')) {
+			return trimmed
+		}
+
+		const codeBlockMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/)
+		if (codeBlockMatch?.[1]) {
+			return codeBlockMatch[1].trim()
+		}
+
+		const braceStart = trimmed.indexOf('{')
+		const braceEnd = trimmed.lastIndexOf('}')
+		if (braceStart !== -1 && braceEnd > braceStart) {
+			return trimmed.slice(braceStart, braceEnd + 1)
+		}
+
+		return null
+	}
 }

package/src/runtime/query/checkpoint.ts

@@ -1,83 +1,87 @@
 import type { RunPersistence } from '../../manager/run/persistence.js'
-import type { CheckpointId, IterationCheckpoint, CheckpointSummary, ActiveNodeInfo, BranchStackEntry } from '../../types/hitl/index.js'
 import type { RunDiskStore } from '../../store/run/disk.js'
+import type {
+	ActiveNodeInfo,
+	BranchStackEntry,
+	CheckpointId,
+	CheckpointSummary,
+	IterationCheckpoint,
+} from '../../types/hitl/index.js'
 import type { AssistantMessage } from '../../types/message/index.js'
-import { generateCheckpointId } from '../../utils/id.js'
 import { buildToolResultHashes } from '../../utils/hash.js'
+import { generateCheckpointId } from '../../utils/id.js'
 
 export class CheckpointManager {
-  private store: RunDiskStore
+	private store: RunDiskStore
 
-  constructor(store: RunDiskStore) {
-    this.store = store
-  }
+	constructor(store: RunDiskStore) {
+		this.store = store
+	}
 
-  async create(
-    sessionMgr: RunPersistence,
-    iteration: number,
-    extra?: {
-      toolResults?: Array<{ toolCallId: string; toolName: string; input: unknown; output: string }>
-      branchStack?: BranchStackEntry[]
-      activeNode?: ActiveNodeInfo
-    },
-  ): Promise<IterationCheckpoint> {
-    const checkpoint: IterationCheckpoint = {
-      id: generateCheckpointId(),
-      runId: sessionMgr.id,
-      iteration,
-      messages: [...sessionMgr.messages],
-      tokenUsage: { ...sessionMgr.tokenUsage },
-      costInfo: { ...sessionMgr.costInfo },
-      guardState: {
-        iterationCount: sessionMgr.currentIteration,
-        elapsedMs: Date.now() - (sessionMgr.getSession().startedAt ?? Date.now()),
-      },
-      createdAt: Date.now(),
-      toolResultHashes: extra?.toolResults ? buildToolResultHashes(extra.toolResults) : undefined,
-      branchStack: extra?.branchStack,
-      activeNode: extra?.activeNode,
-    }
+	async create(
+		sessionMgr: RunPersistence,
+		iteration: number,
+		extra?: {
+			toolResults?: Array<{ toolCallId: string; toolName: string; input: unknown; output: string }>
+			branchStack?: BranchStackEntry[]
+			activeNode?: ActiveNodeInfo
+		},
+	): Promise<IterationCheckpoint> {
+		const checkpoint: IterationCheckpoint = {
+			id: generateCheckpointId(),
+			runId: sessionMgr.id,
+			iteration,
+			messages: [...sessionMgr.messages],
+			tokenUsage: { ...sessionMgr.tokenUsage },
+			costInfo: { ...sessionMgr.costInfo },
+			guardState: {
+				iterationCount: sessionMgr.currentIteration,
+				elapsedMs: Date.now() - (sessionMgr.getSession().startedAt ?? Date.now()),
+			},
+			createdAt: Date.now(),
+			toolResultHashes: extra?.toolResults ? buildToolResultHashes(extra.toolResults) : undefined,
+			branchStack: extra?.branchStack,
+			activeNode: extra?.activeNode,
+		}
 
-    await this.store.writeCheckpoint(checkpoint)
-    return checkpoint
-  }
+		await this.store.writeCheckpoint(checkpoint)
+		return checkpoint
+	}
 
-  async restore(checkpointId: CheckpointId): Promise<IterationCheckpoint> {
-    const checkpoint = await this.store.readCheckpoint(checkpointId)
-    if (!checkpoint) {
-      throw new Error(`Checkpoint not found: ${checkpointId}`)
-    }
-    return checkpoint
-  }
+	async restore(checkpointId: CheckpointId): Promise<IterationCheckpoint> {
+		const checkpoint = await this.store.readCheckpoint(checkpointId)
+		if (!checkpoint) {
+			throw new Error(`Checkpoint not found: ${checkpointId}`)
+		}
+		return checkpoint
+	}
 
-  async list(): Promise<IterationCheckpoint[]> {
-    return this.store.listCheckpoints()
-  }
+	async list(): Promise<IterationCheckpoint[]> {
+		return this.store.listCheckpoints()
+	}
 
-  async prune(keepLast: number): Promise<void> {
-    const all = await this.list()
-    if (all.length <= keepLast) return
+	async prune(keepLast: number): Promise<void> {
+		const all = await this.list()
+		if (all.length <= keepLast) return
 
-    const toDelete = all
-      .sort((a, b) => a.createdAt - b.createdAt)
-      .slice(0, all.length - keepLast)
+		const toDelete = all.sort((a, b) => a.createdAt - b.createdAt).slice(0, all.length - keepLast)
 
-    for (const cp of toDelete) {
-      await this.store.deleteCheckpoint(cp.id)
-    }
-  }
+		for (const cp of toDelete) {
+			await this.store.deleteCheckpoint(cp.id)
+		}
+	}
 
-  static buildSummary(sessionMgr: RunPersistence, iteration: number): CheckpointSummary {
-    const lastAssistant = [...sessionMgr.messages]
-      .reverse()
-      .find((m): m is AssistantMessage => m.role === 'assistant' && m.content !== null)
+	static buildSummary(sessionMgr: RunPersistence, iteration: number): CheckpointSummary {
+		const lastAssistant = [...sessionMgr.messages]
+			.reverse()
+			.find((m): m is AssistantMessage => m.role === 'assistant' && m.content !== null)
 
-    return {
-      iteration,
-      messageCount: sessionMgr.messages.length,
-      tokenUsage: { ...sessionMgr.tokenUsage },
-      costInfo: { ...sessionMgr.costInfo },
-      lastAssistantMessage: lastAssistant?.content ?? undefined,
-    }
-  }
+		return {
+			iteration,
+			messageCount: sessionMgr.messages.length,
+			tokenUsage: { ...sessionMgr.tokenUsage },
+			costInfo: { ...sessionMgr.costInfo },
+			lastAssistantMessage: lastAssistant?.content ?? undefined,
+		}
+	}
 }

package/src/runtime/query/context-cache.ts

@@ -1,86 +1,82 @@
+import { createHash } from 'node:crypto'
+import type { ToolRegistry } from '../../registry/tool/execute.js'
 import type { ThreadId } from '../../types/ids/index.js'
 import type { AgentPersona } from '../../types/persona/index.js'
 import type { Skill } from '../../types/skills/index.js'
-import type { ToolRegistry } from '../../registry/tool/execute.js'
 import { PromptBuilder } from './prompt.js'
-import { memoizeAsync } from '../../utils/memoize.js'
-import { createHash } from 'node:crypto'
 
 export interface ContextCacheConfig {
-  agentId: string
-  threadId: ThreadId
+	agentId: string
+	threadId: ThreadId
 }
 
 export interface PromptCacheInput {
-  systemPrompt?: string
-  persona?: AgentPersona
-  skills?: Skill[]
-  basePrompt?: string
-  tools: ToolRegistry
-  allowedTools?: string[]
+	systemPrompt?: string
+	persona?: AgentPersona
+	skills?: Skill[]
+	basePrompt?: string
+	tools: ToolRegistry
+	allowedTools?: string[]
 }
 
 export class ContextCache {
-  readonly threadId: ThreadId
-  readonly agentId: string
+	readonly threadId: ThreadId
+	readonly agentId: string
 
-  private cachedPrompt: string | undefined
-  private cachedConfigHash: string | undefined
+	private cachedPrompt: string | undefined
+	private cachedConfigHash: string | undefined
 
-  constructor(config: ContextCacheConfig) {
-    this.threadId = config.threadId
-    this.agentId = config.agentId
-  }
+	constructor(config: ContextCacheConfig) {
+		this.threadId = config.threadId
+		this.agentId = config.agentId
+	}
 
-  getSystemPrompt(input: PromptCacheInput): string {
-    const hash = this.computeConfigHash(input)
+	getSystemPrompt(input: PromptCacheInput): string {
+		const hash = this.computeConfigHash(input)
 
-    if (this.cachedPrompt && this.cachedConfigHash === hash) {
-      return this.cachedPrompt
-    }
+		if (this.cachedPrompt && this.cachedConfigHash === hash) {
+			return this.cachedPrompt
+		}
 
-    const builder = new PromptBuilder({
-      systemPrompt: input.systemPrompt,
-      persona: input.persona,
-      skills: input.skills,
-      basePrompt: input.basePrompt,
-      tools: input.tools,
-      allowedTools: input.allowedTools,
-    })
+		const builder = new PromptBuilder({
+			systemPrompt: input.systemPrompt,
+			persona: input.persona,
+			skills: input.skills,
+			basePrompt: input.basePrompt,
+			tools: input.tools,
+			allowedTools: input.allowedTools,
+		})
 
-    this.cachedPrompt = builder.build()
-    this.cachedConfigHash = hash
-    return this.cachedPrompt
-  }
+		this.cachedPrompt = builder.build()
+		this.cachedConfigHash = hash
+		return this.cachedPrompt
+	}
 
-  get configHash(): string | undefined {
-    return this.cachedConfigHash
-  }
+	get configHash(): string | undefined {
+		return this.cachedConfigHash
+	}
 
-  needsRebuild(input: PromptCacheInput): boolean {
-    if (!this.cachedConfigHash) return true
-    return this.computeConfigHash(input) !== this.cachedConfigHash
-  }
+	needsRebuild(input: PromptCacheInput): boolean {
+		if (!this.cachedConfigHash) return true
+		return this.computeConfigHash(input) !== this.cachedConfigHash
+	}
 
-  invalidate(): void {
-    this.cachedPrompt = undefined
-    this.cachedConfigHash = undefined
-  }
+	invalidate(): void {
+		this.cachedPrompt = undefined
+		this.cachedConfigHash = undefined
+	}
 
-  private computeConfigHash(input: PromptCacheInput): string {
-    const parts: string[] = [
-      this.agentId,
-      input.systemPrompt ?? '',
-      input.persona?.identity?.role ?? '',
-      input.persona?.identity?.description ?? '',
-      input.basePrompt ?? '',
-      ...(input.skills?.map(s => s.metadata.name) ?? []),
-      ...(input.allowedTools ?? []),
-    ]
+	private computeConfigHash(input: PromptCacheInput): string {
+		const parts: string[] = [
+			this.agentId,
+			input.systemPrompt ?? '',
+			input.persona?.identity?.role ?? '',
+			input.persona?.identity?.description ?? '',
+			input.basePrompt ?? '',
+			...(input.skills?.map((s) => s.metadata.name) ?? []),
+			...(input.allowedTools ?? []),
+		]
 
-    return createHash('sha256')
-      .update(parts.join('\0'))
-      .digest('hex')
-      .slice(0, 16)
-  }
+		return createHash('sha256').update(parts.join('\0')).digest('hex').slice(0, 16)
+	}
 }