@namzu/sdk 0.1.1 → 0.1.2

package/src/runtime/query/iteration/phases/checkpoint.ts

@@ -1,37 +1,29 @@
-import type { RunEvent } from "../../../../types/run/index.js";
-import { CheckpointManager } from "../../checkpoint.js";
-import type { IterationContext, PhaseSignal } from "./context.js";
-import { handleHITLDecision } from "./context.js";
+import type { RunEvent } from '../../../../types/run/index.js'
+import { CheckpointManager } from '../../checkpoint.js'
+import type { IterationContext, PhaseSignal } from './context.js'
+import { handleHITLDecision } from './context.js'
 
 export async function* runIterationCheckpoint(
 	ctx: IterationContext,
 	iterationNum: number,
 ): AsyncGenerator<RunEvent, PhaseSignal> {
-	const iterCheckpoint = await ctx.checkpointMgr.create(
-		ctx.sessionMgr,
-		iterationNum,
-	);
+	const iterCheckpoint = await ctx.checkpointMgr.create(ctx.sessionMgr, iterationNum)
 
 	await ctx.emitEvent({
-		type: "checkpoint_created",
+		type: 'checkpoint_created',
 		runId: ctx.sessionMgr.id,
 		checkpointId: iterCheckpoint.id,
 		iteration: iterationNum,
-	});
-	yield* ctx.drainPending();
+	})
+	yield* ctx.drainPending()
 
-	const summary = CheckpointManager.buildSummary(ctx.sessionMgr, iterationNum);
+	const summary = CheckpointManager.buildSummary(ctx.sessionMgr, iterationNum)
 	const iterDecision = await ctx.resumeHandler({
-		type: "iteration_checkpoint",
+		type: 'iteration_checkpoint',
 		runId: ctx.sessionMgr.id,
 		checkpointId: iterCheckpoint.id,
 		summary,
-	});
+	})
 
-	return yield* handleHITLDecision(
-		ctx,
-		iterDecision,
-		iterCheckpoint.id,
-		"iteration_checkpoint",
-	);
+	return yield* handleHITLDecision(ctx, iterDecision, iterCheckpoint.id, 'iteration_checkpoint')
 }

package/src/runtime/query/iteration/phases/context.ts

@@ -1,25 +1,18 @@
-import type { PlanManager } from "../../../../manager/plan/lifecycle.js";
-import type { RunPersistence } from "../../../../manager/run/persistence.js";
-import type { ToolRegistry } from "../../../../registry/tool/execute.js";
-import type { ActivityStore } from "../../../../store/activity/memory.js";
-import type { TaskGateway, TaskHandle } from "../../../../types/agent/gateway.js";
-import type {
-	HITLResumeDecision,
-	ResumeHandler,
-} from "../../../../types/hitl/index.js";
-import type { TaskId } from "../../../../types/ids/index.js";
-import type { TaskStore } from "../../../../types/task/index.js";
-import type { LLMProvider } from "../../../../types/provider/index.js";
-import type {
-	AgentRunConfig,
-	RunEvent,
-	StopReason,
-} from "../../../../types/run/index.js";
-import type { Logger } from "../../../../utils/logger.js";
-import type { CheckpointManager } from "../../checkpoint.js";
-import type { EmitEvent } from "../../events.js";
-import type { ToolExecutor } from "../../executor.js";
-import type { GuardCoordinator } from "../../guard.js";
+import type { PlanManager } from '../../../../manager/plan/lifecycle.js'
+import type { RunPersistence } from '../../../../manager/run/persistence.js'
+import type { ToolRegistry } from '../../../../registry/tool/execute.js'
+import type { ActivityStore } from '../../../../store/activity/memory.js'
+import type { TaskGateway, TaskHandle } from '../../../../types/agent/gateway.js'
+import type { HITLResumeDecision, ResumeHandler } from '../../../../types/hitl/index.js'
+import type { TaskId } from '../../../../types/ids/index.js'
+import type { LLMProvider } from '../../../../types/provider/index.js'
+import type { AgentRunConfig, RunEvent } from '../../../../types/run/index.js'
+import type { TaskStore } from '../../../../types/task/index.js'
+import type { Logger } from '../../../../utils/logger.js'
+import type { CheckpointManager } from '../../checkpoint.js'
+import type { EmitEvent } from '../../events.js'
+import type { ToolExecutor } from '../../executor.js'
+import type { GuardCoordinator } from '../../guard.js'
 
 export interface LaunchedTaskMeta {
 	readonly agentId: string
@@ -28,32 +21,32 @@ export interface LaunchedTaskMeta {
 }
 
 export interface IterationContext {
-	readonly provider: LLMProvider;
-	readonly sessionConfig: AgentRunConfig;
-	readonly tools: ToolRegistry;
-	readonly allowedTools?: string[];
-	readonly sessionMgr: RunPersistence;
-	readonly toolExecutor: ToolExecutor;
-	readonly guard: GuardCoordinator;
-	readonly activityStore: ActivityStore;
-	readonly emitEvent: EmitEvent;
-	readonly drainPending: () => Generator<RunEvent>;
-	readonly abortController: AbortController;
-	readonly log: Logger;
-	readonly resumeHandler: ResumeHandler;
-	readonly checkpointMgr: CheckpointManager;
-	readonly planManager: PlanManager;
+	readonly provider: LLMProvider
+	readonly sessionConfig: AgentRunConfig
+	readonly tools: ToolRegistry
+	readonly allowedTools?: string[]
+	readonly sessionMgr: RunPersistence
+	readonly toolExecutor: ToolExecutor
+	readonly guard: GuardCoordinator
+	readonly activityStore: ActivityStore
+	readonly emitEvent: EmitEvent
+	readonly drainPending: () => Generator<RunEvent>
+	readonly abortController: AbortController
+	readonly log: Logger
+	readonly resumeHandler: ResumeHandler
+	readonly checkpointMgr: CheckpointManager
+	readonly planManager: PlanManager
 
-	readonly taskGateway?: TaskGateway;
+	readonly taskGateway?: TaskGateway
 
-	readonly taskStore?: TaskStore;
+	readonly taskStore?: TaskStore
 
-	readonly pendingNotifications: TaskHandle[];
+	readonly pendingNotifications: TaskHandle[]
 
-	readonly launchedTasks: Map<TaskId, LaunchedTaskMeta>;
+	readonly launchedTasks: Map<TaskId, LaunchedTaskMeta>
 }
 
-export type PhaseSignal = "continue" | "stop";
+export type PhaseSignal = 'continue' | 'stop'
 
 export async function* handleHITLDecision(
 	ctx: IterationContext,
@@ -62,56 +55,54 @@ export async function* handleHITLDecision(
 	context: string,
 ): AsyncGenerator<RunEvent, PhaseSignal> {
 	switch (decision.action) {
-		case "pause": {
+		case 'pause': {
 			await ctx.emitEvent({
-				type: "run_paused",
+				type: 'run_paused',
 				runId: ctx.sessionMgr.id,
 				checkpointId: checkpointId as `cp_${string}`,
 				reason: decision.reason,
-			});
-			yield* ctx.drainPending();
-			ctx.sessionMgr.setStopReason("paused");
+			})
+			yield* ctx.drainPending()
+			ctx.sessionMgr.setStopReason('paused')
 			ctx.log.info(`Session paused at ${context}`, {
 				sessionId: ctx.sessionMgr.id,
 				reason: decision.reason,
-			});
-			return "stop";
+			})
+			return 'stop'
 		}
-		case "abort": {
-			ctx.sessionMgr.setStopReason("cancelled");
-			ctx.sessionMgr.markCancelled();
+		case 'abort': {
+			ctx.sessionMgr.setStopReason('cancelled')
+			ctx.sessionMgr.markCancelled()
 			ctx.log.info(`Session aborted at ${context}`, {
 				sessionId: ctx.sessionMgr.id,
 				reason: decision.reason,
-			});
-			return "stop";
+			})
+			return 'stop'
 		}
-		case "reject_plan": {
-			ctx.sessionMgr.setStopReason("plan_rejected");
-			ctx.log.info("Plan rejected by user", {
+		case 'reject_plan': {
+			ctx.sessionMgr.setStopReason('plan_rejected')
+			ctx.log.info('Plan rejected by user', {
 				sessionId: ctx.sessionMgr.id,
 				feedback: decision.feedback,
-			});
-			return "stop";
+			})
+			return 'stop'
 		}
-		case "approve_plan": {
+		case 'approve_plan': {
 			if (ctx.planManager.active) {
-				ctx.planManager.approve();
-				ctx.planManager.startExecution();
+				ctx.planManager.approve()
+				ctx.planManager.startExecution()
 			}
-			ctx.log.info("Plan approved by user", { sessionId: ctx.sessionMgr.id });
-			return "continue";
+			ctx.log.info('Plan approved by user', { sessionId: ctx.sessionMgr.id })
+			return 'continue'
 		}
-		case "continue":
-		case "approve_tools":
-		case "modify_tools":
-		case "reject_tools":
-			return "continue";
+		case 'continue':
+		case 'approve_tools':
+		case 'modify_tools':
+		case 'reject_tools':
+			return 'continue'
 		default: {
-			const _exhaustive: never = decision;
-			throw new Error(
-				`Unhandled HITL decision: ${(_exhaustive as HITLResumeDecision).action}`,
-			);
+			const _exhaustive: never = decision
+			throw new Error(`Unhandled HITL decision: ${(_exhaustive as HITLResumeDecision).action}`)
 		}
 	}
 }

package/src/runtime/query/iteration/phases/index.ts

@@ -1,6 +1,6 @@
-export type { IterationContext, PhaseSignal } from "./context.js";
-export { handleHITLDecision } from "./context.js";
-export { runPlanGate } from "./plan.js";
-export { runToolReview } from "./tool-review.js";
-export type { ToolReviewOutcome } from "./tool-review.js";
-export { runIterationCheckpoint } from "./checkpoint.js";
+export type { IterationContext, PhaseSignal } from './context.js'
+export { handleHITLDecision } from './context.js'
+export { runPlanGate } from './plan.js'
+export { runToolReview } from './tool-review.js'
+export type { ToolReviewOutcome } from './tool-review.js'
+export { runIterationCheckpoint } from './checkpoint.js'

package/src/runtime/query/iteration/phases/plan.ts

@@ -1,27 +1,25 @@
-import type { RunEvent } from "../../../../types/run/index.js";
-import type { IterationContext, PhaseSignal } from "./context.js";
-import { handleHITLDecision } from "./context.js";
+import type { RunEvent } from '../../../../types/run/index.js'
+import type { IterationContext, PhaseSignal } from './context.js'
+import { handleHITLDecision } from './context.js'
 
-export async function* runPlanGate(
-	ctx: IterationContext,
-): AsyncGenerator<RunEvent, PhaseSignal> {
-	if (!ctx.planManager.active || ctx.planManager.active.status !== "ready") {
-		return "continue";
+export async function* runPlanGate(ctx: IterationContext): AsyncGenerator<RunEvent, PhaseSignal> {
+	if (!ctx.planManager.active || ctx.planManager.active.status !== 'ready') {
+		return 'continue'
 	}
 
-	const planCheckpoint = await ctx.checkpointMgr.create(ctx.sessionMgr, 0);
+	const planCheckpoint = await ctx.checkpointMgr.create(ctx.sessionMgr, 0)
 
 	await ctx.emitEvent({
-		type: "checkpoint_created",
+		type: 'checkpoint_created',
 		runId: ctx.sessionMgr.id,
 		checkpointId: planCheckpoint.id,
 		iteration: 0,
-	});
-	yield* ctx.drainPending();
+	})
+	yield* ctx.drainPending()
 
-	const plan = ctx.planManager.active;
+	const plan = ctx.planManager.active
 	const planDecision = await ctx.resumeHandler({
-		type: "plan_approval",
+		type: 'plan_approval',
 		runId: ctx.sessionMgr.id,
 		checkpointId: planCheckpoint.id,
 		plan: {
@@ -36,12 +34,7 @@ export async function* runPlanGate(
 			})),
 			summary: plan.summary,
 		},
-	});
+	})
 
-	return yield* handleHITLDecision(
-		ctx,
-		planDecision,
-		planCheckpoint.id,
-		"plan_gate",
-	);
+	return yield* handleHITLDecision(ctx, planDecision, planCheckpoint.id, 'plan_gate')
 }

package/src/runtime/query/iteration/phases/tool-review.ts

@@ -1,177 +1,168 @@
-import { createUserMessage } from "../../../../types/message/index.js";
-import type { ChatCompletionResponse } from "../../../../types/provider/index.js";
-import type { RunEvent } from "../../../../types/run/index.js";
-import type { IterationContext } from "./context.js";
+import { createUserMessage } from '../../../../types/message/index.js'
+import type { ChatCompletionResponse } from '../../../../types/provider/index.js'
+import type { RunEvent } from '../../../../types/run/index.js'
+import type { IterationContext } from './context.js'
 
-export type ToolReviewOutcome = "executed" | "rejected" | "stop";
+export type ToolReviewOutcome = 'executed' | 'rejected' | 'stop'
 
 export async function* runToolReview(
 	ctx: IterationContext,
 	response: ChatCompletionResponse,
 	iterationNum: number,
 ): AsyncGenerator<RunEvent, ToolReviewOutcome> {
-	const toolCalls = response.message.toolCalls!;
+	const toolCalls = response.message.toolCalls
+	if (!toolCalls || toolCalls.length === 0) {
+		return 'executed'
+	}
 
 	const toolCallSummaries = toolCalls.map((tc) => {
-		let input: unknown;
+		let input: unknown
 		try {
-			input = JSON.parse(tc.function.arguments);
+			input = JSON.parse(tc.function.arguments)
 		} catch {
-			input = tc.function.arguments;
+			input = tc.function.arguments
 		}
-		const tool = ctx.tools.get(tc.function.name);
-		const isDestructive = tool?.isDestructive
-			? tool.isDestructive(input)
-			: false;
+		const tool = ctx.tools.get(tc.function.name)
+		const isDestructive = tool?.isDestructive ? tool.isDestructive(input) : false
 
 		return {
 			id: tc.id,
 			name: tc.function.name,
 			input,
 			isDestructive,
-		};
-	});
+		}
+	})
 
-	const reviewCheckpoint = await ctx.checkpointMgr.create(
-		ctx.sessionMgr,
-		iterationNum,
-	);
+	const reviewCheckpoint = await ctx.checkpointMgr.create(ctx.sessionMgr, iterationNum)
 
 	await ctx.emitEvent({
-		type: "tool_review_requested",
+		type: 'tool_review_requested',
 		runId: ctx.sessionMgr.id,
 		toolCalls: toolCallSummaries,
 		iteration: iterationNum,
-	});
-	yield* ctx.drainPending();
+	})
+	yield* ctx.drainPending()
 
 	const reviewDecision = await ctx.resumeHandler({
-		type: "tool_review",
+		type: 'tool_review',
 		runId: ctx.sessionMgr.id,
 		checkpointId: reviewCheckpoint.id,
 		toolCalls: toolCallSummaries,
-	});
+	})
 
 	switch (reviewDecision.action) {
-		case "reject_tools": {
+		case 'reject_tools': {
 			await ctx.emitEvent({
-				type: "tool_review_completed",
+				type: 'tool_review_completed',
 				runId: ctx.sessionMgr.id,
-				decision: "rejected",
-			});
-			yield* ctx.drainPending();
-
-			const feedback =
-				reviewDecision.feedback || "User rejected the tool calls";
-			ctx.sessionMgr.pushMessage(
-				createUserMessage(`[SYSTEM] Tool calls rejected: ${feedback}`),
-			);
-			return "rejected";
+				decision: 'rejected',
+			})
+			yield* ctx.drainPending()
+
+			const feedback = reviewDecision.feedback || 'User rejected the tool calls'
+			ctx.sessionMgr.pushMessage(createUserMessage(`[SYSTEM] Tool calls rejected: ${feedback}`))
+			return 'rejected'
 		}
 
-		case "modify_tools": {
+		case 'modify_tools': {
 			await ctx.emitEvent({
-				type: "tool_review_completed",
+				type: 'tool_review_completed',
 				runId: ctx.sessionMgr.id,
-				decision: "modified",
-			});
-			yield* ctx.drainPending();
+				decision: 'modified',
+			})
+			yield* ctx.drainPending()
 
 			for (const mod of reviewDecision.modifications) {
-				if (mod.action === "modify" && mod.modifiedInput !== undefined) {
-					const tc = toolCalls.find((t) => t.id === mod.toolCallId);
+				if (mod.action === 'modify' && mod.modifiedInput !== undefined) {
+					const tc = toolCalls.find((t) => t.id === mod.toolCallId)
 					if (tc) {
-						tc.function.arguments = JSON.stringify(mod.modifiedInput);
+						tc.function.arguments = JSON.stringify(mod.modifiedInput)
 					}
 				}
 			}
 
 			const deniedIds = new Set(
-				reviewDecision.modifications
-					.filter((m) => m.action === "deny")
-					.map((m) => m.toolCallId),
-			);
-			const filteredToolCalls = toolCalls.filter((tc) => !deniedIds.has(tc.id));
+				reviewDecision.modifications.filter((m) => m.action === 'deny').map((m) => m.toolCallId),
+			)
+			const filteredToolCalls = toolCalls.filter((tc) => !deniedIds.has(tc.id))
 
 			if (filteredToolCalls.length === 0) {
-				ctx.sessionMgr.pushMessage(
-					createUserMessage("[SYSTEM] All tool calls were denied by user"),
-				);
-				return "rejected";
+				ctx.sessionMgr.pushMessage(createUserMessage('[SYSTEM] All tool calls were denied by user'))
+				return 'rejected'
 			}
 
 			const batch = await ctx.toolExecutor.executeBatch({
 				...response,
 				message: { ...response.message, toolCalls: filteredToolCalls },
-			});
+			})
 			for (const msg of batch.messages) {
-				ctx.sessionMgr.pushMessage(msg);
+				ctx.sessionMgr.pushMessage(msg)
 			}
-			return "executed";
+			return 'executed'
 		}
 
-		case "pause": {
+		case 'pause': {
 			await ctx.emitEvent({
-				type: "tool_review_completed",
+				type: 'tool_review_completed',
 				runId: ctx.sessionMgr.id,
-				decision: "rejected",
-			});
+				decision: 'rejected',
+			})
 			await ctx.emitEvent({
-				type: "run_paused",
+				type: 'run_paused',
 				runId: ctx.sessionMgr.id,
 				checkpointId: reviewCheckpoint.id,
 				reason: reviewDecision.reason,
-			});
-			yield* ctx.drainPending();
-			ctx.sessionMgr.setStopReason("paused");
-			return "stop";
+			})
+			yield* ctx.drainPending()
+			ctx.sessionMgr.setStopReason('paused')
+			return 'stop'
 		}
 
-		case "abort": {
+		case 'abort': {
 			await ctx.emitEvent({
-				type: "tool_review_completed",
+				type: 'tool_review_completed',
 				runId: ctx.sessionMgr.id,
-				decision: "rejected",
-			});
-			yield* ctx.drainPending();
-			ctx.sessionMgr.setStopReason("cancelled");
-			ctx.sessionMgr.markCancelled();
-			return "stop";
+				decision: 'rejected',
+			})
+			yield* ctx.drainPending()
+			ctx.sessionMgr.setStopReason('cancelled')
+			ctx.sessionMgr.markCancelled()
+			return 'stop'
 		}
 
-		case "approve_tools":
-		case "continue": {
+		case 'approve_tools':
+		case 'continue': {
 			await ctx.emitEvent({
-				type: "tool_review_completed",
+				type: 'tool_review_completed',
 				runId: ctx.sessionMgr.id,
-				decision: "approved",
-			});
-			yield* ctx.drainPending();
+				decision: 'approved',
+			})
+			yield* ctx.drainPending()
 
-			const batch = await ctx.toolExecutor.executeBatch(response);
+			const batch = await ctx.toolExecutor.executeBatch(response)
 			for (const msg of batch.messages) {
-				ctx.sessionMgr.pushMessage(msg);
+				ctx.sessionMgr.pushMessage(msg)
 			}
-			return "executed";
+			return 'executed'
 		}
 
-		case "approve_plan":
-		case "reject_plan": {
-			ctx.log.warn("Unexpected plan decision during tool review", {
+		case 'approve_plan':
+		case 'reject_plan': {
+			ctx.log.warn('Unexpected plan decision during tool review', {
 				action: reviewDecision.action,
-			});
-			const batch = await ctx.toolExecutor.executeBatch(response);
+			})
+			const batch = await ctx.toolExecutor.executeBatch(response)
 			for (const msg of batch.messages) {
-				ctx.sessionMgr.pushMessage(msg);
+				ctx.sessionMgr.pushMessage(msg)
 			}
-			return "executed";
+			return 'executed'
 		}
 
 		default: {
-			const _exhaustive: never = reviewDecision;
+			const _exhaustive: never = reviewDecision
 			throw new Error(
 				`Unhandled tool review decision: ${(_exhaustive as { action: string }).action}`,
-			);
+			)
 		}
 	}
 }