@namzu/sdk 0.1.1 → 0.1.2

package/src/runtime/query/executor.ts

@@ -1,34 +1,34 @@
-import type { ToolRegistry } from "../../registry/tool/execute.js";
-import type { ActivityStore } from "../../store/activity/memory.js";
-import type { RunId } from "../../types/ids/index.js";
-import { type Message, createToolMessage } from "../../types/message/index.js";
-import type { PermissionMode } from "../../types/permission/index.js";
-import type { ChatCompletionResponse } from "../../types/provider/index.js";
-import type { RunEvent } from "../../types/run/index.js";
-import type { ToolContext } from "../../types/tool/index.js";
-import type { Logger } from "../../utils/logger.js";
-
-export type EmitEvent = (event: RunEvent) => Promise<void>;
+import type { ToolRegistry } from '../../registry/tool/execute.js'
+import type { ActivityStore } from '../../store/activity/memory.js'
+import type { RunId } from '../../types/ids/index.js'
+import { type Message, createToolMessage } from '../../types/message/index.js'
+import type { PermissionMode } from '../../types/permission/index.js'
+import type { ChatCompletionResponse } from '../../types/provider/index.js'
+import type { RunEvent } from '../../types/run/index.js'
+import type { ToolContext } from '../../types/tool/index.js'
+import type { Logger } from '../../utils/logger.js'
+
+export type EmitEvent = (event: RunEvent) => Promise<void>
 
 export interface ToolExecutorConfig {
-	tools: ToolRegistry;
-	runId: RunId;
-	workingDirectory: string;
-	permissionMode: PermissionMode;
-	env: Record<string, string>;
-	abortSignal: AbortSignal;
+	tools: ToolRegistry
+	runId: RunId
+	workingDirectory: string
+	permissionMode: PermissionMode
+	env: Record<string, string>
+	abortSignal: AbortSignal
 }
 
 export interface ToolExecutionBatch {
-	messages: Message[];
-	results: Array<{ toolCallId: string; output: string }>;
+	messages: Message[]
+	results: Array<{ toolCallId: string; output: string }>
 }
 
 export class ToolExecutor {
-	private config: ToolExecutorConfig;
-	private activityStore: ActivityStore;
-	private emitEvent: EmitEvent;
-	private log: Logger;
+	private config: ToolExecutorConfig
+	private activityStore: ActivityStore
+	private emitEvent: EmitEvent
+	private log: Logger
 
 	constructor(
 		config: ToolExecutorConfig,
@@ -36,37 +36,33 @@ export class ToolExecutor {
 		emitEvent: EmitEvent,
 		log: Logger,
 	) {
-		this.config = config;
-		this.activityStore = activityStore;
-		this.emitEvent = emitEvent;
-		this.log = log;
+		this.config = config
+		this.activityStore = activityStore
+		this.emitEvent = emitEvent
+		this.log = log
 	}
 
-	async executeBatch(
-		response: ChatCompletionResponse,
-	): Promise<ToolExecutionBatch> {
-		const toolCalls = response.message.toolCalls;
+	async executeBatch(response: ChatCompletionResponse): Promise<ToolExecutionBatch> {
+		const toolCalls = response.message.toolCalls
 		if (!toolCalls) {
-			return { messages: [], results: [] };
+			return { messages: [], results: [] }
 		}
 
 		this.log.debug('Executing tool batch', {
 			runId: this.config.runId,
 			toolCount: toolCalls.length,
 			tools: toolCalls.map((tc) => tc.function.name),
-		});
+		})
 
-		const toolContext = this.buildToolContext();
+		const toolContext = this.buildToolContext()
 
 		const results = await Promise.all(
 			toolCalls.map((toolCall) => this.executeSingle(toolCall, toolContext)),
-		);
+		)
 
-		const messages: Message[] = results.map((r) =>
-			createToolMessage(r.output, r.toolCallId),
-		);
+		const messages: Message[] = results.map((r) => createToolMessage(r.output, r.toolCallId))
 
-		return { messages, results };
+		return { messages, results }
 	}
 
 	private buildToolContext(): ToolContext {
@@ -82,58 +78,54 @@ export class ToolExecutor {
 				workingDirectory: this.config.workingDirectory,
 			},
 			toolRegistry: this.config.tools,
-		};
+		}
 	}
 
 	private async executeSingle(
 		toolCall: {
-			id: string;
-			type: string;
-			function: { name: string; arguments: string };
+			id: string
+			type: string
+			function: { name: string; arguments: string }
 		},
 		toolContext: ToolContext,
 	): Promise<{ toolCallId: string; output: string }> {
-		const toolName = toolCall.function.name;
-		let input: unknown;
+		const toolName = toolCall.function.name
+		let input: unknown
 
 		try {
-			input = JSON.parse(toolCall.function.arguments);
+			input = JSON.parse(toolCall.function.arguments)
 		} catch {
 			return {
 				toolCallId: toolCall.id,
 				output: `Error: Invalid JSON in tool arguments for "${toolName}"`,
-			};
+			}
 		}
 
 		const activity = this.activityStore.create({
-			type: "tool_call",
+			type: 'tool_call',
 			description: toolName,
 			input,
 			toolName,
 			toolCallId: toolCall.id,
-		});
+		})
 		if (activity) {
-			this.activityStore.start(activity.id);
+			this.activityStore.start(activity.id)
 		}
 
 		await this.emitEvent({
-			type: "tool_executing",
+			type: 'tool_executing',
 			runId: this.config.runId,
 			toolName,
 			input,
-		});
+		})
 
-		const startMs = Date.now();
-		const result = await this.config.tools.execute(
-			toolName,
-			input,
-			toolContext,
-		);
-		const durationMs = Date.now() - startMs;
+		const startMs = Date.now()
+		const result = await this.config.tools.execute(toolName, input, toolContext)
+		const durationMs = Date.now() - startMs
 
 		const output = result.success
 			? result.output
-			: `Error: ${result.error ?? "Tool execution failed"}`;
+			: `Error: ${result.error ?? 'Tool execution failed'}`
 
 		if (result.success) {
 			this.log.debug('Tool executed successfully', {
@@ -141,31 +133,31 @@ export class ToolExecutor {
 				tool: toolName,
 				durationMs,
 				outputLength: output.length,
-			});
+			})
 		} else {
 			this.log.warn('Tool execution failed', {
 				runId: this.config.runId,
 				tool: toolName,
 				durationMs,
 				error: result.error ?? 'unknown',
-			});
+			})
 		}
 
 		if (activity) {
 			if (result.success) {
-				this.activityStore.complete(activity.id, output);
+				this.activityStore.complete(activity.id, output)
 			} else {
-				this.activityStore.fail(activity.id, result.error ?? "Tool execution failed");
+				this.activityStore.fail(activity.id, result.error ?? 'Tool execution failed')
 			}
 		}
 
 		await this.emitEvent({
-			type: "tool_completed",
+			type: 'tool_completed',
 			runId: this.config.runId,
 			toolName,
 			result: output,
-		});
+		})
 
-		return { toolCallId: toolCall.id, output };
+		return { toolCallId: toolCall.id, output }
 	}
 }

package/src/runtime/query/guard.ts

@@ -1,71 +1,68 @@
-import type { StopReason, LimitCheckerConfig } from '../../types/run/index.js'
 import type { RunPersistence } from '../../manager/run/persistence.js'
-import { type LimitCheckResult, checkLimitsDetailed, buildLimitConfig } from '../../run/LimitChecker.js'
+import { buildLimitConfig, checkLimitsDetailed } from '../../run/LimitChecker.js'
+import type { LimitCheckerConfig, StopReason } from '../../types/run/index.js'
 
 export interface GuardConfig {
-  tokenBudget: number
-  timeoutMs: number
-  costLimitUsd?: number
-  maxIterations?: number
+	tokenBudget: number
+	timeoutMs: number
+	costLimitUsd?: number
+	maxIterations?: number
 }
 
 export interface GuardCheckResult {
-  shouldStop: boolean
-  forceFinalize: boolean
-  stopReason?: StopReason
-  isCancelled: boolean
+	shouldStop: boolean
+	forceFinalize: boolean
+	stopReason?: StopReason
+	isCancelled: boolean
 }
 
 export class GuardCoordinator {
-  private limitConfig: LimitCheckerConfig
-  private startTime: number
+	private limitConfig: LimitCheckerConfig
+	private startTime: number
 
-  constructor(config: GuardConfig) {
-    this.limitConfig = buildLimitConfig(
-      config.tokenBudget,
-      config.timeoutMs,
-      config.costLimitUsd,
-      config.maxIterations,
-    )
-    this.startTime = Date.now()
-  }
+	constructor(config: GuardConfig) {
+		this.limitConfig = buildLimitConfig(
+			config.tokenBudget,
+			config.timeoutMs,
+			config.costLimitUsd,
+			config.maxIterations,
+		)
+		this.startTime = Date.now()
+	}
 
-  beforeIteration(
-    sessionMgr: RunPersistence,
-    abortSignal: AbortSignal,
-  ): GuardCheckResult {
-    const limitState = {
-      aborted: abortSignal.aborted,
-      totalTokens: sessionMgr.tokenUsage.totalTokens,
-      totalCost: sessionMgr.costInfo.totalCost,
-      currentIteration: sessionMgr.currentIteration,
-      startTime: this.startTime,
-    }
+	beforeIteration(sessionMgr: RunPersistence, abortSignal: AbortSignal): GuardCheckResult {
+		const limitState = {
+			aborted: abortSignal.aborted,
+			totalTokens: sessionMgr.tokenUsage.totalTokens,
+			totalCost: sessionMgr.costInfo.totalCost,
+			currentIteration: sessionMgr.currentIteration,
+			startTime: this.startTime,
+		}
 
-    const limitResult = checkLimitsDetailed(this.limitConfig, limitState)
+		const limitResult = checkLimitsDetailed(this.limitConfig, limitState)
 
-    if (limitResult.type === 'hard_stop') {
-      return {
-        shouldStop: true,
-        forceFinalize: false,
-        stopReason: limitResult.reason,
-        isCancelled: limitResult.reason === 'cancelled',
-      }
-    }
+		if (limitResult.type === 'hard_stop') {
+			return {
+				shouldStop: true,
+				forceFinalize: false,
+				stopReason: limitResult.reason,
+				isCancelled: limitResult.reason === 'cancelled',
+			}
+		}
 
-    if (limitResult.type === 'warning') {
-      return {
-        shouldStop: false,
-        forceFinalize: true,
-        stopReason: limitResult.reason,
-        isCancelled: false,
-      }
-    }
+		if (limitResult.type === 'warning') {
+			return {
+				shouldStop: false,
+				forceFinalize: true,
+				stopReason: limitResult.reason,
+				isCancelled: false,
+			}
+		}
 
-    return {
-      shouldStop: false,
-      forceFinalize: false,
-      isCancelled: false,
-    }
-  }
+		return {
+			shouldStop: false,
+			forceFinalize: false,
+			isCancelled: false,
+		}
+	}
 }