@namzu/sdk 0.1.1 → 0.1.2

package/src/runtime/query/context.ts

@@ -1,105 +1,105 @@
-import type { AgentRunConfig } from '../../types/run/index.js'
+import { join } from 'node:path'
+import { PlanManager } from '../../manager/plan/lifecycle.js'
+import { RunPersistence } from '../../manager/run/persistence.js'
+import { ActivityStore } from '../../store/activity/memory.js'
+import { type ActivityTrackingConfig, resolveActivityTracking } from '../../types/activity/index.js'
+import type { RunId, ThreadId } from '../../types/ids/index.js'
+import type { Message } from '../../types/message/index.js'
+import type { PermissionMode } from '../../types/permission/index.js'
 import type { LLMProvider } from '../../types/provider/index.js'
+import type { AgentRunConfig } from '../../types/run/index.js'
 import type { ModelPricing } from '../../utils/cost.js'
-import type { Message } from '../../types/message/index.js'
+import { generateRunId } from '../../utils/id.js'
 import type { Logger } from '../../utils/logger.js'
-import type { RunId, ThreadId } from '../../types/ids/index.js'
-import type { PermissionMode } from '../../types/permission/index.js'
-import { type ActivityTrackingConfig, resolveActivityTracking } from '../../types/activity/index.js'
-import { RunPersistence } from '../../manager/run/persistence.js'
-import { ActivityStore } from '../../store/activity/memory.js'
-import { PlanManager } from '../../manager/plan/lifecycle.js'
 import { getRootLogger } from '../../utils/logger.js'
-import { generateRunId } from '../../utils/id.js'
-import { join } from 'node:path'
 
 export interface RunContextConfig {
-  agentId: string
-  agentName: string
-  sessionConfig: AgentRunConfig
-  provider: LLMProvider
-  workingDirectory?: string
-  pricing?: ModelPricing
-  enableActivityTracking?: boolean
-  messages: Message[]
-  signal?: AbortSignal
+	agentId: string
+	agentName: string
+	sessionConfig: AgentRunConfig
+	provider: LLMProvider
+	workingDirectory?: string
+	pricing?: ModelPricing
+	enableActivityTracking?: boolean
+	messages: Message[]
+	signal?: AbortSignal
 
-  threadId: ThreadId
+	threadId: ThreadId
 
-  runId?: RunId
+	runId?: RunId
 
-  parentRunId?: RunId
+	parentRunId?: RunId
 
-  depth?: number
+	depth?: number
 }
 
 export interface RunContext {
-  runId: RunId
-  threadId: ThreadId
-  sessionMgr: RunPersistence
-  activityStore: ActivityStore
-  planManager: PlanManager
-  abortController: AbortController
-  cwd: string
-  outputDir: string
-  permissionMode: PermissionMode
-  log: Logger
-  trackingConfig: ActivityTrackingConfig
+	runId: RunId
+	threadId: ThreadId
+	sessionMgr: RunPersistence
+	activityStore: ActivityStore
+	planManager: PlanManager
+	abortController: AbortController
+	cwd: string
+	outputDir: string
+	permissionMode: PermissionMode
+	log: Logger
+	trackingConfig: ActivityTrackingConfig
 }
 
 export class RunContextFactory {
-  static build(config: RunContextConfig): RunContext {
-    const abortController = new AbortController()
-    if (config.signal) {
-      config.signal.addEventListener('abort', () => abortController.abort(), { once: true })
-    }
+	static build(config: RunContextConfig): RunContext {
+		const abortController = new AbortController()
+		if (config.signal) {
+			config.signal.addEventListener('abort', () => abortController.abort(), { once: true })
+		}
 
-    const cwd = config.workingDirectory ?? process.cwd()
-    const permissionMode = config.sessionConfig.permissionMode ?? 'auto'
-    const runId = config.runId ?? generateRunId()
+		const cwd = config.workingDirectory ?? process.cwd()
+		const permissionMode = config.sessionConfig.permissionMode ?? 'auto'
+		const runId = config.runId ?? generateRunId()
 
-    if (!config.threadId) {
-      throw new Error('threadId is required for run persistence — all runs must belong to a thread')
-    }
-    const threadId: ThreadId = config.threadId
-    const outputDir = join(cwd, '.namzu', 'threads', threadId, 'runs')
+		if (!config.threadId) {
+			throw new Error('threadId is required for run persistence — all runs must belong to a thread')
+		}
+		const threadId: ThreadId = config.threadId
+		const outputDir = join(cwd, '.namzu', 'threads', threadId, 'runs')
 
-    const log = getRootLogger().child({
-      component: 'query',
-      agent: config.agentName,
-      runId,
-      threadId,
-    })
+		const log = getRootLogger().child({
+			component: 'query',
+			agent: config.agentName,
+			runId,
+			threadId,
+		})
 
-    const sessionMgr = new RunPersistence({
-      runId,
-      agentId: config.agentId,
-      agentName: config.agentName,
-      sessionConfig: config.sessionConfig,
-      providerId: config.provider.id,
-      outputDir,
-      pricing: config.pricing,
-      log,
-      parentRunId: config.parentRunId,
-      depth: config.depth,
-    })
+		const sessionMgr = new RunPersistence({
+			runId,
+			agentId: config.agentId,
+			agentName: config.agentName,
+			sessionConfig: config.sessionConfig,
+			providerId: config.provider.id,
+			outputDir,
+			pricing: config.pricing,
+			log,
+			parentRunId: config.parentRunId,
+			depth: config.depth,
+		})
 
-    const trackingConfig = resolveActivityTracking(permissionMode, config.enableActivityTracking)
-    const activityStore = new ActivityStore(runId, trackingConfig)
-    const planManager = new PlanManager(runId)
+		const trackingConfig = resolveActivityTracking(permissionMode, config.enableActivityTracking)
+		const activityStore = new ActivityStore(runId, trackingConfig)
+		const planManager = new PlanManager(runId)
 
-    return {
-      runId,
-      threadId,
-      sessionMgr,
-      activityStore,
-      planManager,
-      abortController,
-      cwd,
-      outputDir,
-      permissionMode,
-      log,
-      trackingConfig,
-    }
-  }
+		return {
+			runId,
+			threadId,
+			sessionMgr,
+			activityStore,
+			planManager,
+			abortController,
+			cwd,
+			outputDir,
+			permissionMode,
+			log,
+			trackingConfig,
+		}
+	}
 }

package/src/runtime/query/events.ts

@@ -1,141 +1,143 @@
-import type { RunEvent } from '../../types/run/index.js'
-import type { RunId } from '../../types/ids/index.js'
-import type { RunPersistence } from '../../manager/run/persistence.js'
-import { type ActivityEvent, type ActivityStore } from '../../store/activity/memory.js'
 import type { PlanEvent, PlanManager } from '../../manager/plan/lifecycle.js'
+import type { RunPersistence } from '../../manager/run/persistence.js'
+import type { ActivityEvent, ActivityStore } from '../../store/activity/memory.js'
+import type { RunId } from '../../types/ids/index.js'
+import type { RunEvent } from '../../types/run/index.js'
 import type { TaskEvent, TaskStore } from '../../types/task/index.js'
 
 export type EmitEvent = (event: RunEvent) => Promise<void>
 
 export class EventTranslator {
-  private pendingEvents: RunEvent[] = []
-  private sessionMgr: RunPersistence
+	private pendingEvents: RunEvent[] = []
+	private sessionMgr: RunPersistence
 
-  constructor(sessionMgr: RunPersistence) {
-    this.sessionMgr = sessionMgr
-  }
+	constructor(sessionMgr: RunPersistence) {
+		this.sessionMgr = sessionMgr
+	}
 
-  readonly emitEvent: EmitEvent = async (event: RunEvent): Promise<void> => {
-    this.pendingEvents.push(event)
-    await this.sessionMgr.getRunStore().appendEvent(event)
-  }
+	readonly emitEvent: EmitEvent = async (event: RunEvent): Promise<void> => {
+		this.pendingEvents.push(event)
+		await this.sessionMgr.getRunStore().appendEvent(event)
+	};
 
-  *drainPending(): Generator<RunEvent> {
-    while (this.pendingEvents.length > 0) {
-      yield this.pendingEvents.shift()!
-    }
-  }
+	*drainPending(): Generator<RunEvent> {
+		let event = this.pendingEvents.shift()
+		while (event !== undefined) {
+			yield event
+			event = this.pendingEvents.shift()
+		}
+	}
 
-  wireActivityStore(activityStore: ActivityStore, runId: RunId): void {
-    activityStore.on((event: ActivityEvent) => {
-      const activity = event.activity
-      if (event.type === 'activity.created') {
-        this.emitEvent({
-          type: 'activity_created',
-          runId,
-          activityId: activity.id,
-          activityType: activity.type,
-          description: activity.description,
-        })
-      } else {
-        this.emitEvent({
-          type: 'activity_updated',
-          runId,
-          activityId: activity.id,
-          status: activity.status,
-          output: activity.output,
-          error: activity.error,
-        })
-      }
-    })
-  }
+	wireActivityStore(activityStore: ActivityStore, runId: RunId): void {
+		activityStore.on((event: ActivityEvent) => {
+			const activity = event.activity
+			if (event.type === 'activity.created') {
+				this.emitEvent({
+					type: 'activity_created',
+					runId,
+					activityId: activity.id,
+					activityType: activity.type,
+					description: activity.description,
+				})
+			} else {
+				this.emitEvent({
+					type: 'activity_updated',
+					runId,
+					activityId: activity.id,
+					status: activity.status,
+					output: activity.output,
+					error: activity.error,
+				})
+			}
+		})
+	}
 
-  wireTaskStore(taskStore: TaskStore, runId: RunId): () => void {
-    const unsubscribe = taskStore.on((event: TaskEvent) => {
-      const task = event.task
+	wireTaskStore(taskStore: TaskStore, runId: RunId): () => void {
+		const unsubscribe = taskStore.on((event: TaskEvent) => {
+			const task = event.task
 
-      if (task.runId !== runId) return
-      switch (event.type) {
-        case 'task.created':
-          this.emitEvent({
-            type: 'task_created',
-            runId,
-            taskId: task.id,
-            subject: task.subject,
-            status: task.status,
-          })
-          break
-        case 'task.updated':
-        case 'task.claimed':
-        case 'task.deleted':
-          this.emitEvent({
-            type: 'task_updated',
-            runId,
-            taskId: task.id,
-            subject: task.subject,
-            status: task.status,
-            owner: task.owner,
-          })
-          break
-        default: {
-          const _exhaustive: never = event.type
-          throw new Error(`Unhandled task event type: ${_exhaustive}`)
-        }
-      }
-    })
-    return unsubscribe
-  }
+			if (task.runId !== runId) return
+			switch (event.type) {
+				case 'task.created':
+					this.emitEvent({
+						type: 'task_created',
+						runId,
+						taskId: task.id,
+						subject: task.subject,
+						status: task.status,
+					})
+					break
+				case 'task.updated':
+				case 'task.claimed':
+				case 'task.deleted':
+					this.emitEvent({
+						type: 'task_updated',
+						runId,
+						taskId: task.id,
+						subject: task.subject,
+						status: task.status,
+						owner: task.owner,
+					})
+					break
+				default: {
+					const _exhaustive: never = event.type
+					throw new Error(`Unhandled task event type: ${_exhaustive}`)
+				}
+			}
+		})
+		return unsubscribe
+	}
 
-  wirePlanManager(planManager: PlanManager, runId: RunId): void {
-    planManager.on((event: PlanEvent) => {
-      const plan = event.plan
-      switch (event.type) {
-        case 'plan.ready':
-          this.emitEvent({
-            type: 'plan_ready',
-            runId,
-            planId: plan.id,
-            title: plan.title,
-            steps: plan.steps,
-            summary: plan.summary,
-          })
-          break
-        case 'plan.approved':
-          this.emitEvent({
-            type: 'plan_approved',
-            runId,
-            planId: plan.id,
-          })
-          break
-        case 'plan.rejected':
-          this.emitEvent({
-            type: 'plan_rejected',
-            runId,
-            planId: plan.id,
-            reason: plan.rejectionReason,
-          })
-          break
-        case 'plan.step_updated':
-          if (event.step) {
-            this.emitEvent({
-              type: 'plan_step_updated',
-              runId,
-              planId: plan.id,
-              stepId: event.step.id,
-              status: event.step.status,
-            })
-          }
-          break
-        case 'plan.generating':
-        case 'plan.executing':
-        case 'plan.completed':
-        case 'plan.failed':
-          break
-        default: {
-          const _exhaustive: never = event.type
-          throw new Error(`Unhandled plan event type: ${_exhaustive}`)
-        }
-      }
-    })
-  }
+	wirePlanManager(planManager: PlanManager, runId: RunId): void {
+		planManager.on((event: PlanEvent) => {
+			const plan = event.plan
+			switch (event.type) {
+				case 'plan.ready':
+					this.emitEvent({
+						type: 'plan_ready',
+						runId,
+						planId: plan.id,
+						title: plan.title,
+						steps: plan.steps,
+						summary: plan.summary,
+					})
+					break
+				case 'plan.approved':
+					this.emitEvent({
+						type: 'plan_approved',
+						runId,
+						planId: plan.id,
+					})
+					break
+				case 'plan.rejected':
+					this.emitEvent({
+						type: 'plan_rejected',
+						runId,
+						planId: plan.id,
+						reason: plan.rejectionReason,
+					})
+					break
+				case 'plan.step_updated':
+					if (event.step) {
+						this.emitEvent({
+							type: 'plan_step_updated',
+							runId,
+							planId: plan.id,
+							stepId: event.step.id,
+							status: event.step.status,
+						})
+					}
+					break
+				case 'plan.generating':
+				case 'plan.executing':
+				case 'plan.completed':
+				case 'plan.failed':
+					break
+				default: {
+					const _exhaustive: never = event.type
+					throw new Error(`Unhandled plan event type: ${_exhaustive}`)
+				}
+			}
+		})
+	}
 }