@themoltnet/pi-extension 0.32.0 → 0.32.1

package/dist/index.js

@@ -1965,7 +1965,7 @@ var findLatestRuntimeSlotForAttempt = (options) => (options.client ?? client).ge
 	...options
 });
 /**
-* Delete terminal tasks in bulk. Safe mode skips live, unauthorized, missing, and protected tasks.
+* Queue asynchronous deletion of terminal tasks in bulk. By default, live, unauthorized, missing, and protected tasks are skipped. Set force: true with a reason to delete protected terminal tasks.
 */
 var batchDeleteTasks = (options) => (options.client ?? client).delete({
 	security: [
@@ -26409,14 +26409,10 @@ async function executePiTask(claimedTask, reporter, opts) {
 			});
 			return makeFailedOutput("session_setup_failed", message);
 		}
-		let llmAbort = false;
-		let llmErrorMessage = null;
-		let assistantText = "";
+		const turnState = createSessionTurnState();
 		let reporterError = null;
 		const usage = finalUsage;
 		let capAbort = null;
-		let toolUseTurnCount = 0;
-		let bashTimeoutCount = 0;
 		const maxTurns = opts.maxTurns ?? 0;
 		const maxBashTimeouts = opts.maxBashTimeouts ?? 3;
 		cancelListener = wireSessionAbort(reporter.cancelSignal, session);
@@ -26451,49 +26447,16 @@ async function executePiTask(claimedTask, reporter, opts) {
 				message
 			}));
 		};
-		session.subscribe((event) => {
-			if (event.type === "message_update") {
-				const ae = event.assistantMessageEvent;
-				if (ae.type === "text_delta") {
-					assistantText += ae.delta;
-					track(emit("text_delta", { delta: ae.delta }));
-				}
-			} else if (event.type === "tool_execution_start") track(emit("tool_call_start", { tool_name: event.toolName }));
-			else if (event.type === "tool_execution_end") {
-				track(emit("tool_call_end", {
-					tool_name: event.toolName,
-					is_error: event.isError,
-					result: event.isError ? truncateForWire(event.result) : void 0
-				}));
-				if (shouldEmitToolCallError(event)) track(emitError("tool_call_error", describeToolErrorMessage(event.result), {
-					tool: event.toolName,
-					result: truncateForWire(event.result)
-				}));
-				if (maxBashTimeouts > 0 && event.toolName === "bash" && event.isError && isBashTimeoutResult(event.result)) {
-					bashTimeoutCount += 1;
-					if (bashTimeoutCount >= maxBashTimeouts) triggerCapAbort("max_bash_timeouts_exceeded", `Aborted after ${bashTimeoutCount} bash timeouts in this attempt (cap ${maxBashTimeouts}).`);
-				}
-			} else if (event.type === "turn_end") {
-				const msg = event.message;
-				if (msg?.role === "assistant" && msg.usage) {
-					usage.inputTokens += Math.max(0, msg.usage.input ?? 0);
-					usage.outputTokens += Math.max(0, msg.usage.output ?? 0);
-					const cr = Math.max(0, msg.usage.cacheRead ?? 0);
-					const cw = Math.max(0, msg.usage.cacheWrite ?? 0);
-					if (cr) usage.cacheReadTokens = (usage.cacheReadTokens ?? 0) + cr;
-					if (cw) usage.cacheWriteTokens = (usage.cacheWriteTokens ?? 0) + cw;
-				}
-				const stopReason = msg?.stopReason ?? "end_turn";
-				track(emit("turn_end", { stop_reason: stopReason }));
-				if (maxTurns > 0 && stopReason !== "end_turn" && stopReason !== "aborted" && stopReason !== "error") {
-					toolUseTurnCount += 1;
-					if (toolUseTurnCount >= maxTurns) triggerCapAbort("max_turns_exceeded", `Aborted after ${toolUseTurnCount} tool-use turns (cap ${maxTurns}).`);
-				}
-				llmAbort = msg?.stopReason === "error";
-				if (msg?.stopReason === "error") llmErrorMessage = typeof msg.errorMessage === "string" && msg.errorMessage.length > 0 ? msg.errorMessage : null;
-				else llmErrorMessage = null;
-			}
-		});
+		session.subscribe(makeSessionEventHandler({
+			state: turnState,
+			usage,
+			maxTurns,
+			maxBashTimeouts,
+			emit,
+			emitError,
+			track,
+			triggerCapAbort
+		}));
 		let runError = null;
 		const runPrompt = (promptText) => promptWithProviderErrorRetries({
 			session: liveSession,
@@ -26501,8 +26464,8 @@ async function executePiTask(claimedTask, reporter, opts) {
 			cancelSignal: reporter.cancelSignal,
 			isCapAborted: () => capAbort !== null,
 			getProviderErrorState: () => ({
-				llmAbort,
-				llmErrorMessage
+				llmAbort: turnState.llmAbort,
+				llmErrorMessage: turnState.llmErrorMessage
 			}),
 			maxRetries: opts.maxProviderErrorRetries ?? 2,
 			baseDelayMs: opts.providerErrorRetryBaseDelayMs ?? 2e3,
@@ -26531,7 +26494,7 @@ async function executePiTask(claimedTask, reporter, opts) {
 			isStopped: () => submitRepromptStopped({
 				cancelled: reporter.cancelSignal.aborted,
 				capAborted: capAbort !== null,
-				llmAbort
+				llmAbort: turnState.llmAbort
 			}),
 			onSubmitReprompt: async (event) => {
 				await emit("info", event);
@@ -26552,62 +26515,18 @@ async function executePiTask(claimedTask, reporter, opts) {
 		let parsedOutput = null;
 		let parsedOutputCid = null;
 		let parseError = null;
-		if (!runError && !llmAbort && !cancelled && !capAbort) {
-			const captured = submitToolHandle?.getCaptured() ?? null;
-			if (captured) try {
-				parsedOutput = captured;
-				parsedOutputCid = await computeJsonCid(captured);
-				recordTaskOutputParseResult({
-					taskType: task.taskType,
-					model: opts.model,
-					code: "captured_via_tool"
-				});
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				parsedOutput = null;
-				parsedOutputCid = null;
-				parseError = {
-					code: "output_cid_compute_failed",
-					message: `Captured submit-tool output could not be canonicalized: ${message}`
-				};
-				recordTaskOutputParseResult({
-					taskType: task.taskType,
-					model: opts.model,
-					code: "output_cid_compute_failed"
-				});
-				await emit("error", {
-					message: parseError.message,
-					phase: "output_validation"
-				});
-			}
-			else if (submitToolHandle) {
-				const exhausted = submitToolHandle.getExhaustedValidationFailure();
-				parseError = exhausted ?? {
-					code: "submit_output_missing",
-					message: "Agent did not satisfy the promised submit-output criterion: no valid task submit tool call was captured before the session ended."
-				};
-				if (!exhausted) recordTaskOutputParseResult({
-					taskType: task.taskType,
-					model: opts.model,
-					code: "output_missing"
-				});
-				await emit("error", {
-					message: parseError.message,
-					phase: "output_validation"
-				});
-			} else {
-				const parsed = await parseStructuredTaskOutput(assistantText, task.taskType, {
-					model: opts.model,
-					input: task.input
-				});
-				parsedOutput = parsed.output;
-				parsedOutputCid = parsed.outputCid;
-				parseError = parsed.error;
-				if (parseError) await emit("error", {
-					message: parseError.message,
-					phase: "output_validation"
-				});
-			}
+		if (!runError && !turnState.llmAbort && !cancelled && !capAbort) {
+			const captured = await captureAttemptOutput({
+				taskType: task.taskType,
+				model: opts.model,
+				input: task.input,
+				assistantText: turnState.assistantText,
+				submitToolHandle,
+				emit
+			});
+			parsedOutput = captured.output;
+			parsedOutputCid = captured.outputCid;
+			parseError = captured.error;
 		}
 		if (cancelled) return {
 			taskId: task.id,
@@ -26638,53 +26557,266 @@ async function executePiTask(claimedTask, reporter, opts) {
 				retryable: false
 			}
 		};
-		const reporterErrorSnapshot = reporterError;
-		const status = runError || llmAbort || parseError || reporterErrorSnapshot ? "failed" : "completed";
-		const errorCode = runError?.code ?? parseError?.code ?? reporterErrorSnapshot?.code ?? (llmAbort ? "llm_api_error" : void 0);
-		const errorMessage = runError?.message ?? parseError?.message ?? reporterErrorSnapshot?.message ?? (llmAbort ? llmErrorMessage ?? "LLM API error during turn" : void 0);
-		const errorRetryable = reporterErrorSnapshot && errorCode === reporterErrorSnapshot.code && errorMessage === reporterErrorSnapshot.message ? reporterErrorSnapshot.retryable ?? false : false;
-		return {
+		return buildAttemptResult({
 			taskId: task.id,
 			attemptN,
-			status,
 			output: parsedOutput,
 			outputCid: parsedOutputCid,
 			usage,
 			durationMs: Date.now() - startTime,
-			...errorCode && errorMessage ? { error: {
-				code: errorCode,
-				message: errorMessage,
-				retryable: errorRetryable
-			} } : {}
-		};
+			runError,
+			parseError,
+			reporterError,
+			llmAbort: turnState.llmAbort,
+			llmErrorMessage: turnState.llmErrorMessage
+		});
 	} catch (err) {
 		return makeFailedOutput("executor_unexpected_error", err instanceof Error ? err.message : String(err));
 	} finally {
-		if (cancelListener) reporter.cancelSignal.removeEventListener("abort", cancelListener);
-		if (session) try {
-			session.dispose();
-		} catch {}
-		if (reporterOpen) {
-			try {
-				await reporter.finalize(finalUsage);
-			} catch (err) {
-				const detail = err instanceof Error ? err.message : String(err);
-				console.error(`executePiTask: reporter.finalize() failed for task ${task.id} attempt ${attemptN}: ${detail}`);
+		await cleanupAttempt({
+			cancelSignal: reporter.cancelSignal,
+			cancelListener,
+			session,
+			reporterOpen,
+			reporter,
+			finalUsage,
+			managed,
+			workspace,
+			taskId: task.id,
+			attemptN
+		});
+	}
+}
+function createSessionTurnState() {
+	return {
+		assistantText: "",
+		llmAbort: false,
+		llmErrorMessage: null,
+		toolUseTurnCount: 0,
+		bashTimeoutCount: 0
+	};
+}
+/**
+* Build the `AgentSession.subscribe` handler for one attempt: bridges pi
+* events to the reporter, accumulates token usage and assistant text, and
+* enforces the bash-timeout and tool-use-turn caps. Extracted from
+* `executePiTask` so this dense, branch-heavy logic is unit-tested against a
+* scripted event stream instead of only through a booted VM.
+*
+* The handler mutates `deps.state` and `deps.usage` in place; the caller reads
+* them after `session.prompt()` resolves (by which point `state.llmAbort`
+* holds the terminal turn's outcome — see the "last-turn wins" note below).
+*
+* @internal Exported for unit testing; not part of the package's public API.
+*/
+function makeSessionEventHandler(deps) {
+	const { state, usage, maxTurns, maxBashTimeouts, emit, emitError, track, triggerCapAbort } = deps;
+	return (event) => {
+		if (event.type === "message_update") {
+			const ae = event.assistantMessageEvent;
+			if (ae.type === "text_delta") {
+				state.assistantText += ae.delta;
+				track(emit("text_delta", { delta: ae.delta }));
 			}
-			try {
-				await reporter.close();
-			} catch (err) {
-				const detail = err instanceof Error ? err.message : String(err);
-				console.error(`executePiTask: reporter.close() failed for task ${task.id} attempt ${attemptN}: ${detail}`);
+		} else if (event.type === "tool_execution_start") track(emit("tool_call_start", { tool_name: event.toolName }));
+		else if (event.type === "tool_execution_end") {
+			track(emit("tool_call_end", {
+				tool_name: event.toolName,
+				is_error: event.isError,
+				result: event.isError ? truncateForWire(event.result) : void 0
+			}));
+			if (shouldEmitToolCallError(event)) track(emitError("tool_call_error", describeToolErrorMessage(event.result), {
+				tool: event.toolName,
+				result: truncateForWire(event.result)
+			}));
+			if (maxBashTimeouts > 0 && event.toolName === "bash" && event.isError && isBashTimeoutResult(event.result)) {
+				state.bashTimeoutCount += 1;
+				if (state.bashTimeoutCount >= maxBashTimeouts) triggerCapAbort("max_bash_timeouts_exceeded", `Aborted after ${state.bashTimeoutCount} bash timeouts in this attempt (cap ${maxBashTimeouts}).`);
 			}
+		} else if (event.type === "turn_end") {
+			const msg = event.message;
+			if (msg?.role === "assistant" && msg.usage) {
+				usage.inputTokens += Math.max(0, msg.usage.input ?? 0);
+				usage.outputTokens += Math.max(0, msg.usage.output ?? 0);
+				const cr = Math.max(0, msg.usage.cacheRead ?? 0);
+				const cw = Math.max(0, msg.usage.cacheWrite ?? 0);
+				if (cr) usage.cacheReadTokens = (usage.cacheReadTokens ?? 0) + cr;
+				if (cw) usage.cacheWriteTokens = (usage.cacheWriteTokens ?? 0) + cw;
+			}
+			const stopReason = msg?.stopReason ?? "end_turn";
+			track(emit("turn_end", { stop_reason: stopReason }));
+			if (maxTurns > 0 && stopReason !== "end_turn" && stopReason !== "aborted" && stopReason !== "error") {
+				state.toolUseTurnCount += 1;
+				if (state.toolUseTurnCount >= maxTurns) triggerCapAbort("max_turns_exceeded", `Aborted after ${state.toolUseTurnCount} tool-use turns (cap ${maxTurns}).`);
+			}
+			state.llmAbort = msg?.stopReason === "error";
+			if (msg?.stopReason === "error") state.llmErrorMessage = typeof msg.errorMessage === "string" && msg.errorMessage.length > 0 ? msg.errorMessage : null;
+			else state.llmErrorMessage = null;
 		}
-		if (managed) await managed.vm.close();
-		if (workspace) try {
-			workspace.cleanup();
+	};
+}
+/**
+* Resolve the attempt's structured output once the session has finished
+* cleanly (no run error / provider abort / cancel / cap). Three mutually
+* exclusive paths, in precedence order:
+*
+*   1. Submit tool captured a payload → trust it, compute its CID. A
+*      canonicalization failure becomes `output_cid_compute_failed`.
+*   2. Submit tool registered but nothing captured → the exhausted-validation
+*      failure wins if present, else `submit_output_missing` (recording the
+*      `output_missing` counter so the never-called path is observable).
+*   3. No submit tool (legacy task type) → parse the trailing assistant text.
+*
+* Extracted from `executePiTask` so this precedence — the part a refactor is
+* most likely to silently reorder — is unit-tested directly. The caller
+* still owns the guard deciding whether output capture runs at all.
+*
+* @internal Exported for unit testing; not part of the package's public API.
+*/
+async function captureAttemptOutput(deps) {
+	const { taskType, model, input, assistantText, submitToolHandle, emit } = deps;
+	const captured = submitToolHandle?.getCaptured() ?? null;
+	if (captured) try {
+		const outputCid = await computeJsonCid(captured);
+		recordTaskOutputParseResult({
+			taskType,
+			model,
+			code: "captured_via_tool"
+		});
+		return {
+			output: captured,
+			outputCid,
+			error: null
+		};
+	} catch (err) {
+		const error = {
+			code: "output_cid_compute_failed",
+			message: `Captured submit-tool output could not be canonicalized: ${err instanceof Error ? err.message : String(err)}`
+		};
+		recordTaskOutputParseResult({
+			taskType,
+			model,
+			code: "output_cid_compute_failed"
+		});
+		await emit("error", {
+			message: error.message,
+			phase: "output_validation"
+		});
+		return {
+			output: null,
+			outputCid: null,
+			error
+		};
+	}
+	if (submitToolHandle) {
+		const exhausted = submitToolHandle.getExhaustedValidationFailure();
+		const error = exhausted ?? {
+			code: "submit_output_missing",
+			message: "Agent did not satisfy the promised submit-output criterion: no valid task submit tool call was captured before the session ended."
+		};
+		if (!exhausted) recordTaskOutputParseResult({
+			taskType,
+			model,
+			code: "output_missing"
+		});
+		await emit("error", {
+			message: error.message,
+			phase: "output_validation"
+		});
+		return {
+			output: null,
+			outputCid: null,
+			error
+		};
+	}
+	const parsed = await parseStructuredTaskOutput(assistantText, taskType, {
+		model,
+		input
+	});
+	if (parsed.error) await emit("error", {
+		message: parsed.error.message,
+		phase: "output_validation"
+	});
+	return {
+		output: parsed.output,
+		outputCid: parsed.outputCid,
+		error: parsed.error
+	};
+}
+/**
+* Assemble the terminal `TaskOutput` for a clean-or-failed finish (cancel and
+* cap aborts are handled by the caller's earlier returns). Encapsulates the
+* failure-precedence ladder — runError → parseError → reporterError →
+* provider abort — so the ordering is unit-tested rather than buried in the
+* orchestrator. A provider abort with no captured diagnostic falls back to a
+* generic message.
+*
+* Errors are non-retryable EXCEPT a reporterError that both wins the ladder
+* and set `retryable: true` (a transient reporter failure, #1538).
+*
+* @internal Exported for unit testing; not part of the package's public API.
+*/
+function buildAttemptResult(args) {
+	const status = args.runError || args.llmAbort || args.parseError || args.reporterError ? "failed" : "completed";
+	const errorCode = args.runError?.code ?? args.parseError?.code ?? args.reporterError?.code ?? (args.llmAbort ? "llm_api_error" : void 0);
+	const errorMessage = args.runError?.message ?? args.parseError?.message ?? args.reporterError?.message ?? (args.llmAbort ? args.llmErrorMessage ?? "LLM API error during turn" : void 0);
+	const errorRetryable = args.reporterError && errorCode === args.reporterError.code && errorMessage === args.reporterError.message ? args.reporterError.retryable ?? false : false;
+	return {
+		taskId: args.taskId,
+		attemptN: args.attemptN,
+		status,
+		output: args.output,
+		outputCid: args.outputCid,
+		usage: args.usage,
+		durationMs: args.durationMs,
+		...errorCode && errorMessage ? { error: {
+			code: errorCode,
+			message: errorMessage,
+			retryable: errorRetryable
+		} } : {}
+	};
+}
+/**
+* Tear down one attempt's resources, in order: detach the cancel listener →
+* dispose the pi session → finalize+close the reporter → close the VM →
+* clean the workspace. Extracted from `executePiTask`'s `finally` so the
+* swallow-vs-log-vs-propagate policy is pinned by tests.
+*
+* Failure handling is deliberately asymmetric and preserved exactly:
+* `session.dispose()` throws are silently swallowed; reporter finalize/close
+* and workspace cleanup failures are logged but non-fatal (the task is about
+* to be reported anyway). `vm.close()` is the one teardown error allowed to
+* propagate: a leaked VM means a live microVM the host never reclaims, so its
+* failure must surface loudly rather than be logged and forgotten.
+*
+* @internal Exported for unit testing; not part of the package's public API.
+*/
+async function cleanupAttempt(deps) {
+	const log = deps.logError ?? ((m) => console.error(m));
+	if (deps.cancelListener) deps.cancelSignal.removeEventListener("abort", deps.cancelListener);
+	if (deps.session) try {
+		deps.session.dispose();
+	} catch {}
+	if (deps.reporterOpen) {
+		try {
+			await deps.reporter.finalize(deps.finalUsage);
 		} catch (err) {
 			const detail = err instanceof Error ? err.message : String(err);
-			console.error(`executePiTask: workspace cleanup failed for task ${task.id} attempt ${attemptN}: ${detail}`);
+			log(`executePiTask: reporter.finalize() failed for task ${deps.taskId} attempt ${deps.attemptN}: ${detail}`);
 		}
+		try {
+			await deps.reporter.close();
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			log(`executePiTask: reporter.close() failed for task ${deps.taskId} attempt ${deps.attemptN}: ${detail}`);
+		}
+	}
+	if (deps.managed) await deps.managed.vm.close();
+	if (deps.workspace) try {
+		deps.workspace.cleanup();
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		log(`executePiTask: workspace cleanup failed for task ${deps.taskId} attempt ${deps.attemptN}: ${detail}`);
 	}
 }
 function applyExecutionPlanSandboxOverrides(sandboxConfig, executionPlan) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/pi-extension",
-  "version": "0.32.0",
+  "version": "0.32.1",
   "type": "module",
   "description": "MoltNet pi extension — sandboxed tool execution in Gondolin VMs with MoltNet identity and persistent memory",
   "keywords": [
@@ -36,8 +36,8 @@
     "@earendil-works/gondolin": "^0.9.1",
     "@opentelemetry/api": "^1.9.0",
     "typebox": "^1.2.8",
-    "@themoltnet/agent-runtime": "0.34.0",
-    "@themoltnet/sdk": "0.118.0"
+    "@themoltnet/sdk": "0.119.0",
+    "@themoltnet/agent-runtime": "0.34.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.74.0",