@namzu/sdk 0.1.1 → 0.1.2

package/src/agents/PipelineAgent.ts

@@ -1,165 +1,160 @@
-import type { RunEventListener } from '../types/run/index.js'
 import type {
-  PipelineAgentConfig,
-  PipelineAgentResult,
-  PipelineStepResult,
-  AgentInput,
-  AgentMetadata,
-  StepContext,
+	AgentInput,
+	AgentMetadata,
+	PipelineAgentConfig,
+	PipelineAgentResult,
+	PipelineStepResult,
+	StepContext,
 } from '../types/agent/index.js'
-import { AbstractAgent } from './AbstractAgent.js'
 import { EMPTY_TOKEN_USAGE } from '../types/common/index.js'
+import type { RunEventListener } from '../types/run/index.js'
 import { ZERO_COST } from '../utils/cost.js'
 import { toErrorMessage } from '../utils/error.js'
+import { AbstractAgent } from './AbstractAgent.js'
 
 export class PipelineAgent extends AbstractAgent<PipelineAgentConfig, PipelineAgentResult> {
-  readonly type = 'pipeline' as const
-
-  constructor(metadata: Omit<AgentMetadata, 'type' | 'capabilities'>) {
-    super({
-      ...metadata,
-      type: 'pipeline',
-      capabilities: {
-        supportsTools: false,
-        supportsStreaming: false,
-        supportsConcurrency: false,
-        supportsSubAgents: false,
-      },
-    })
-  }
-
-  async run(
-    input: AgentInput,
-    config: PipelineAgentConfig,
-    listener?: RunEventListener,
-  ): Promise<PipelineAgentResult> {
-    const startTime = Date.now()
-    const runId = this.createRunId()
-    const stepResults: PipelineStepResult[] = []
-    const previousResults = new Map<string, unknown>()
-    let completedSteps = 0
-
-    await this.emitEvent({ type: 'run_started', runId }, listener)
-
-    let currentInput: unknown = input.messages
-      .filter((m) => m.role === 'user')
-      .map((m) => m.content)
-      .filter((c): c is string => c !== null)
-      .join('\n')
-
-    for (let i = 0; i < config.steps.length; i++) {
-      const step = config.steps[i]
-      const stepStart = Date.now()
-
-      if (this.abortController.signal.aborted) {
-        stepResults.push({
-          stepName: step.name,
-          status: 'skipped',
-          durationMs: 0,
-        })
-        continue
-      }
-
-      await this.emitEvent(
-        { type: 'iteration_started', runId, iteration: i + 1 },
-        listener,
-      )
-
-      const context: StepContext = {
-        runId,
-        stepIndex: i,
-        totalSteps: config.steps.length,
-        previousResults,
-        provider: config.provider,
-        signal: this.abortController.signal,
-        env: config.env ?? {},
-      }
-
-      try {
-        if (step.validate && !step.validate(currentInput)) {
-          throw new Error(`Validation failed for step "${step.name}"`)
-        }
-
-        const output = await step.execute(currentInput, context)
-        previousResults.set(step.name, output)
-        currentInput = output
-        completedSteps++
-
-        stepResults.push({
-          stepName: step.name,
-          status: 'completed',
-          output,
-          durationMs: Date.now() - stepStart,
-        })
-      } catch (err) {
-        const errorMsg = toErrorMessage(err)
-
-        stepResults.push({
-          stepName: step.name,
-          status: 'failed',
-          error: errorMsg,
-          durationMs: Date.now() - stepStart,
-        })
-
-        if (step.rollback) {
-          try {
-            await step.rollback(currentInput, context)
-          } catch (rollbackErr) {
-            this.log.error(`Rollback failed for step "${step.name}"`, {
-              error: toErrorMessage(rollbackErr),
-            })
-          }
-        }
-
-        if (!config.continueOnError) {
-          await this.emitEvent(
-            { type: 'run_failed', runId, error: errorMsg },
-            listener,
-          )
-
-          return {
-            runId,
-            status: 'failed',
-            stopReason: 'error',
-            usage: { ...EMPTY_TOKEN_USAGE },
-            cost: { ...ZERO_COST },
-            iterations: i + 1,
-            durationMs: Date.now() - startTime,
-            messages: input.messages,
-            lastError: errorMsg,
-            stepResults,
-            completedSteps,
-            totalSteps: config.steps.length,
-          }
-        }
-      }
-    }
-
-    const finalStatus = completedSteps === config.steps.length ? 'completed' : 'failed'
-    const lastOutput = stepResults[stepResults.length - 1]?.output
-
-    await this.emitEvent(
-      {
-        type: 'run_completed',
-        runId,
-        result: typeof lastOutput === 'string' ? lastOutput : JSON.stringify(lastOutput),
-      },
-      listener,
-    )
-
-    return {
-      runId,
-      status: finalStatus,
-      stopReason: 'end_turn',
-      usage: { ...EMPTY_TOKEN_USAGE },
-      cost: { ...ZERO_COST },
-      iterations: config.steps.length,
-      durationMs: Date.now() - startTime,
-      messages: input.messages,
-      result: typeof lastOutput === 'string' ? lastOutput : JSON.stringify(lastOutput),
-      stepResults,
-      completedSteps,
-      totalSteps: config.steps.length,
-    }
-  }
+	readonly type = 'pipeline' as const
+
+	constructor(metadata: Omit<AgentMetadata, 'type' | 'capabilities'>) {
+		super({
+			...metadata,
+			type: 'pipeline',
+			capabilities: {
+				supportsTools: false,
+				supportsStreaming: false,
+				supportsConcurrency: false,
+				supportsSubAgents: false,
+			},
+		})
+	}
+
+	async run(
+		input: AgentInput,
+		config: PipelineAgentConfig,
+		listener?: RunEventListener,
+	): Promise<PipelineAgentResult> {
+		const startTime = Date.now()
+		const runId = this.createRunId()
+		const stepResults: PipelineStepResult[] = []
+		const previousResults = new Map<string, unknown>()
+		let completedSteps = 0
+
+		await this.emitEvent({ type: 'run_started', runId }, listener)
+
+		let currentInput: unknown = input.messages
+			.filter((m) => m.role === 'user')
+			.map((m) => m.content)
+			.filter((c): c is string => c !== null)
+			.join('\n')
+
+		for (let i = 0; i < config.steps.length; i++) {
+			const step = config.steps[i]
+			if (!step) throw new Error(`Pipeline step at index ${i} is undefined`)
+			const stepStart = Date.now()
+
+			if (this.abortController.signal.aborted) {
+				stepResults.push({
+					stepName: step.name,
+					status: 'skipped',
+					durationMs: 0,
+				})
+				continue
+			}
+
+			await this.emitEvent({ type: 'iteration_started', runId, iteration: i + 1 }, listener)
+
+			const context: StepContext = {
+				runId,
+				stepIndex: i,
+				totalSteps: config.steps.length,
+				previousResults,
+				provider: config.provider,
+				signal: this.abortController.signal,
+				env: config.env ?? {},
+			}
+
+			try {
+				if (step.validate && !step.validate(currentInput)) {
+					throw new Error(`Validation failed for step "${step.name}"`)
+				}
+
+				const output = await step.execute(currentInput, context)
+				previousResults.set(step.name, output)
+				currentInput = output
+				completedSteps++
+
+				stepResults.push({
+					stepName: step.name,
+					status: 'completed',
+					output,
+					durationMs: Date.now() - stepStart,
+				})
+			} catch (err) {
+				const errorMsg = toErrorMessage(err)
+
+				stepResults.push({
+					stepName: step.name,
+					status: 'failed',
+					error: errorMsg,
+					durationMs: Date.now() - stepStart,
+				})
+
+				if (step.rollback) {
+					try {
+						await step.rollback(currentInput, context)
+					} catch (rollbackErr) {
+						this.log.error(`Rollback failed for step "${step.name}"`, {
+							error: toErrorMessage(rollbackErr),
+						})
+					}
+				}
+
+				if (!config.continueOnError) {
+					await this.emitEvent({ type: 'run_failed', runId, error: errorMsg }, listener)
+
+					return {
+						runId,
+						status: 'failed',
+						stopReason: 'error',
+						usage: { ...EMPTY_TOKEN_USAGE },
+						cost: { ...ZERO_COST },
+						iterations: i + 1,
+						durationMs: Date.now() - startTime,
+						messages: input.messages,
+						lastError: errorMsg,
+						stepResults,
+						completedSteps,
+						totalSteps: config.steps.length,
+					}
+				}
+			}
+		}
+
+		const finalStatus = completedSteps === config.steps.length ? 'completed' : 'failed'
+		const lastOutput = stepResults[stepResults.length - 1]?.output
+
+		await this.emitEvent(
+			{
+				type: 'run_completed',
+				runId,
+				result: typeof lastOutput === 'string' ? lastOutput : JSON.stringify(lastOutput),
+			},
+			listener,
+		)
+
+		return {
+			runId,
+			status: finalStatus,
+			stopReason: 'end_turn',
+			usage: { ...EMPTY_TOKEN_USAGE },
+			cost: { ...ZERO_COST },
+			iterations: config.steps.length,
+			durationMs: Date.now() - startTime,
+			messages: input.messages,
+			result: typeof lastOutput === 'string' ? lastOutput : JSON.stringify(lastOutput),
+			stepResults,
+			completedSteps,
+			totalSteps: config.steps.length,
+		}
+	}
 }

package/src/agents/ReactiveAgent.ts

@@ -1,97 +1,101 @@
-import type { RunEventListener } from '../types/run/index.js'
-import type { AssistantMessage } from '../types/message/index.js'
+import { drainQuery } from '../runtime/query/index.js'
 import type {
-  ReactiveAgentConfig,
-  ReactiveAgentResult,
-  AgentInput,
-  AgentMetadata,
+	AgentInput,
+	AgentMetadata,
+	ReactiveAgentConfig,
+	ReactiveAgentResult,
 } from '../types/agent/index.js'
+import type { AssistantMessage } from '../types/message/index.js'
+import type { RunEventListener } from '../types/run/index.js'
 import { AbstractAgent } from './AbstractAgent.js'
-import { drainQuery } from '../runtime/query/index.js'
 
 export class ReactiveAgent extends AbstractAgent<ReactiveAgentConfig, ReactiveAgentResult> {
-  readonly type = 'reactive' as const
+	readonly type = 'reactive' as const
+
+	constructor(metadata: Omit<AgentMetadata, 'type' | 'capabilities'>) {
+		super({
+			...metadata,
+			type: 'reactive',
+			capabilities: {
+				supportsTools: true,
+				supportsStreaming: true,
+				supportsConcurrency: false,
+				supportsSubAgents: false,
+			},
+		})
+	}
 
-  constructor(metadata: Omit<AgentMetadata, 'type' | 'capabilities'>) {
-    super({
-      ...metadata,
-      type: 'reactive',
-      capabilities: {
-        supportsTools: true,
-        supportsStreaming: true,
-        supportsConcurrency: false,
-        supportsSubAgents: false,
-      },
-    })
-  }
+	async run(
+		input: AgentInput,
+		config: ReactiveAgentConfig,
+		listener?: RunEventListener,
+	): Promise<ReactiveAgentResult> {
+		const startTime = Date.now()
 
-  async run(
-    input: AgentInput,
-    config: ReactiveAgentConfig,
-    listener?: RunEventListener,
-  ): Promise<ReactiveAgentResult> {
-    const startTime = Date.now()
+		if (!config.threadId) {
+			throw new Error('ReactiveAgent.run requires a threadId in config')
+		}
 
-    const session = await drainQuery(
-      {
-        systemPrompt: config.systemPrompt,
-        persona: config.persona,
-        skills: config.skills,
-        basePrompt: config.basePrompt,
-        provider: config.provider,
-        tools: config.tools,
-        sessionConfig: {
-          model: config.model,
-          tokenBudget: config.tokenBudget,
-          timeoutMs: config.timeoutMs,
-          maxIterations: config.maxIterations,
-          temperature: config.temperature,
-          maxResponseTokens: config.maxResponseTokens,
-          costLimitUsd: config.costLimitUsd,
-          permissionMode: config.permissionMode,
-          env: config.env,
-        },
-        agentId: this.metadata.id,
-        agentName: this.metadata.name,
-        workingDirectory: input.workingDirectory,
-        threadId: config.threadId!,
-        parentRunId: config.parentRunId,
-        depth: config.depth,
-        contextLevel: config.contextLevel,
-        messages: input.messages,
-        signal: input.signal,
-        taskStore: input.taskStore,
-        runtimeToolOverrides: input.runtimeToolOverrides,
-      },
-      listener,
-    )
+		const session = await drainQuery(
+			{
+				systemPrompt: config.systemPrompt,
+				persona: config.persona,
+				skills: config.skills,
+				basePrompt: config.basePrompt,
+				provider: config.provider,
+				tools: config.tools,
+				sessionConfig: {
+					model: config.model,
+					tokenBudget: config.tokenBudget,
+					timeoutMs: config.timeoutMs,
+					maxIterations: config.maxIterations,
+					temperature: config.temperature,
+					maxResponseTokens: config.maxResponseTokens,
+					costLimitUsd: config.costLimitUsd,
+					permissionMode: config.permissionMode,
+					env: config.env,
+				},
+				agentId: this.metadata.id,
+				agentName: this.metadata.name,
+				workingDirectory: input.workingDirectory,
+				threadId: config.threadId,
+				parentRunId: config.parentRunId,
+				depth: config.depth,
+				contextLevel: config.contextLevel,
+				messages: input.messages,
+				signal: input.signal,
+				taskStore: input.taskStore,
+				runtimeToolOverrides: input.runtimeToolOverrides,
+			},
+			listener,
+		)
 
-    let toolCallCount = 0
-    for (const msg of session.messages) {
-      if (msg.role === 'assistant') {
-        const assistantMsg = msg as AssistantMessage
-        if (assistantMsg.toolCalls) {
-          toolCallCount += assistantMsg.toolCalls.length
-        }
-      }
-    }
+		let toolCallCount = 0
+		for (const msg of session.messages) {
+			if (msg.role === 'assistant') {
+				const assistantMsg = msg as AssistantMessage
+				if (assistantMsg.toolCalls) {
+					toolCallCount += assistantMsg.toolCalls.length
+				}
+			}
+		}
 
-    return {
-      runId: session.id,
-      status: session.status,
-      stopReason: session.stopReason,
-      usage: session.tokenUsage,
-      cost: session.costInfo,
-      iterations: session.currentIteration,
-      durationMs: Date.now() - startTime,
-      messages: session.messages,
-      result: session.result,
-      lastError: session.lastError,
-      toolCallCount,
-    }
-  }
+		return {
+			runId: session.id,
+			status: session.status,
+			stopReason: session.stopReason,
+			usage: session.tokenUsage,
+			cost: session.costInfo,
+			iterations: session.currentIteration,
+			durationMs: Date.now() - startTime,
+			messages: session.messages,
+			result: session.result,
+			lastError: session.lastError,
+			toolCallCount,
+		}
+	}
 
-  async cancel(): Promise<void> {
-    this.abortController.abort()
-  }
+	override async cancel(): Promise<void> {
+		this.abortController.abort()
+	}
 }