@tangle-network/sandbox 0.30.1 → 0.30.2-develop.20260820100122.dc85046

package/dist/openai/index.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 //#region src/openai/hooks.ts
 /**
 * Sequential hook composer. Hooks run in registration order; `block` and
@@ -379,6 +380,101 @@ var InMemoryResponseStore = class {
 	}
 };
 //#endregion
+//#region src/openai/terminal.ts
+const SUCCESS_OUTCOMES = new Set([
+	"success",
+	"succeeded",
+	"completed",
+	"done"
+]);
+const ResponseErrorCodeSchema = z.enum([
+	"empty_image_file",
+	"failed_to_download_image",
+	"image_content_policy_violation",
+	"image_file_not_found",
+	"image_file_too_large",
+	"image_parse_error",
+	"image_too_large",
+	"image_too_small",
+	"invalid_base64_image",
+	"invalid_image",
+	"invalid_image_format",
+	"invalid_image_mode",
+	"invalid_image_url",
+	"invalid_prompt",
+	"rate_limit_exceeded",
+	"server_error",
+	"unsupported_image_media_type",
+	"vector_store_timeout"
+]);
+const OPENAI_MISSING_TERMINAL_REASON = "stream ended without a terminal event";
+const OPENAI_MALFORMED_TERMINAL_REASON = "malformed terminal event";
+const OpenAITerminalEventSchema = z.object({
+	type: z.enum(["done", "error"]),
+	outcome: z.string().optional(),
+	status: z.string().optional(),
+	success: z.boolean().optional(),
+	error: z.string().optional(),
+	message: z.string().optional()
+}).passthrough();
+function responseError(reason) {
+	const normalized = reason.trim().toLowerCase().replace(/[\s-]+/g, "_");
+	const parsedCode = ResponseErrorCodeSchema.safeParse(normalized);
+	return {
+		code: parsedCode.success ? parsedCode.data : normalized === "rate_limit" || normalized === "rate_limited" ? "rate_limit_exceeded" : normalized === "invalid_prompt_format" ? "invalid_prompt" : "server_error",
+		message: reason
+	};
+}
+function failure(reason) {
+	return {
+		status: "failed",
+		error: responseError(reason),
+		reason
+	};
+}
+function terminalOutcome(event) {
+	if (event.outcome?.trim()) return event.outcome.trim().toLowerCase();
+	if (event.status?.trim()) return event.status.trim().toLowerCase();
+	if (event.success === false) return "failure";
+	return "success";
+}
+function terminalReason(event, fallback) {
+	if (event.error && event.error.length > 0) return event.error;
+	if (event.message && event.message.length > 0) return event.message;
+	return fallback;
+}
+/**
+* Classify one top-level OpenAI-adapter event.
+*
+* `TangleSSEEvent` is not the nested `SandboxEvent` protocol. This function
+* reads only fields on the supplied event itself.
+*/
+function classifyOpenAITerminal(event) {
+	if (event.type !== "done" && event.type !== "error") return null;
+	const parsed = OpenAITerminalEventSchema.safeParse(event);
+	if (!parsed.success) return failure(OPENAI_MALFORMED_TERMINAL_REASON);
+	if (parsed.data.type === "done") {
+		const outcome = terminalOutcome(parsed.data);
+		return SUCCESS_OUTCOMES.has(outcome) ? {
+			status: "completed",
+			error: null
+		} : failure(terminalReason(parsed.data, outcome));
+	}
+	return failure(terminalReason(parsed.data, "stream error"));
+}
+/**
+* Classify a complete collected stream. Any failure takes precedence.
+*/
+function classifyOpenAITerminalEvents(events) {
+	let terminal = null;
+	for (const event of events) {
+		const current = classifyOpenAITerminal(event);
+		if (!current) continue;
+		if (current.status === "failed" || terminal === null) terminal = current;
+	}
+	return terminal;
+}
+//#endregion
 //#region src/openai/runs.ts
 const TERMINAL_STATUSES = new Set([
 	"completed",
@@ -425,21 +521,6 @@ function readToolCallFromFrame(event) {
 		requiresAction: false
 	};
 }
-function readTerminal(event) {
-	if (event.type === "done") {
-		const outcome = typeof event.outcome === "string" && event.outcome || "success";
-		if (outcome === "success" || outcome === "completed" || outcome === "succeeded" || outcome === "done") return { status: "completed" };
-		return {
-			status: "failed",
-			reason: typeof event.error === "string" ? event.error : outcome
-		};
-	}
-	if (event.type === "error") return {
-		status: "failed",
-		reason: typeof event.message === "string" && event.message || typeof event.error === "string" && event.error || "stream error"
-	};
-	return null;
-}
 /**
 * Internal queue helper: an async iterable backed by a bounded
 * pending-list with a settle promise that resolves whenever a new
@@ -649,7 +730,7 @@ var Run = class {
 					if (handled === "requires_action") return;
 					continue;
 				}
-				const terminal = readTerminal(event);
+				const terminal = classifyOpenAITerminal(event);
 				if (terminal) {
 					if (terminal.status === "completed") {
 						this.transition("completed");
@@ -658,7 +739,7 @@ var Run = class {
 						this.transition("failed");
 						this.queue.push({
 							type: "failed",
-							reason: terminal.reason ?? "unknown failure"
+							reason: terminal.reason
 						});
 					}
 					this.queue.close();
@@ -666,8 +747,11 @@ var Run = class {
 				}
 			}
 			if (!isTerminal(this._status)) {
-				this.transition("completed");
-				this.queue.push({ type: "completed" });
+				this.transition("failed");
+				this.queue.push({
+					type: "failed",
+					reason: OPENAI_MISSING_TERMINAL_REASON
+				});
 				this.queue.close();
 			}
 		} catch (err) {
@@ -1038,6 +1122,43 @@ function usageFromTokens(usage) {
 		output_tokens_details: { reasoning_tokens: 0 }
 	};
 }
+function terminalResponse(event, ctx, terminal) {
+	const tokens = event.type === "done" ? readUsage(event) : null;
+	return {
+		id: ctx.runId,
+		object: "response",
+		created_at: ctx.createdAt,
+		output_text: "",
+		error: terminal.error,
+		incomplete_details: null,
+		instructions: null,
+		metadata: null,
+		model: ctx.modelId,
+		output: [],
+		parallel_tool_calls: false,
+		temperature: null,
+		tool_choice: "auto",
+		tools: [],
+		top_p: null,
+		status: terminal.status,
+		usage: tokens ? usageFromTokens(tokens) : emptyResponseUsage()
+	};
+}
+function terminalResponseEvent(event, ctx, extras) {
+	const terminal = classifyOpenAITerminal(event);
+	if (!terminal) return null;
+	const response = terminalResponse(event, ctx, terminal);
+	if (terminal.status === "failed") return {
+		type: "response.failed",
+		sequence_number: nextSeq(extras),
+		response
+	};
+	return {
+		type: "response.completed",
+		sequence_number: nextSeq(extras),
+		response
+	};
+}
 function sandboxEventToResponsesEvent(event, ctx) {
 	const extras = getResponsesExtras(ctx);
 	switch (event.type) {
@@ -1089,48 +1210,8 @@ function sandboxEventToResponsesEvent(event, ctx) {
 				sequence_number: nextSeq(extras)
 			};
 		}
-		case "error": {
-			const outputIndex = extras.messageOutputIndex ?? 0;
-			return {
-				type: "response.output_item.done",
-				item: {
-					type: "message",
-					id: `msg_${ctx.runId}`,
-					role: "assistant",
-					status: "incomplete",
-					content: []
-				},
-				output_index: outputIndex,
-				sequence_number: nextSeq(extras)
-			};
-		}
-		case "done": {
-			const tokens = readUsage(event);
-			const usage = tokens ? usageFromTokens(tokens) : emptyResponseUsage();
-			return {
-				type: "response.completed",
-				sequence_number: nextSeq(extras),
-				response: {
-					id: ctx.runId,
-					object: "response",
-					created_at: ctx.createdAt,
-					output_text: "",
-					error: null,
-					incomplete_details: null,
-					instructions: null,
-					metadata: null,
-					model: ctx.modelId,
-					output: [],
-					parallel_tool_calls: false,
-					temperature: null,
-					tool_choice: "auto",
-					tools: [],
-					top_p: null,
-					status: "completed",
-					usage
-				}
-			};
-		}
+		case "error":
+		case "done": return terminalResponseEvent(event, ctx, extras);
 		default: return null;
 	}
 }
@@ -1705,11 +1786,10 @@ function normalizeResponsesWebSearchForTangleRouter(req, options = {}) {
 	} : req;
 }
 function readNativeWebSearchParameters(tool) {
-	const input = tool;
 	const result = {};
-	const searchContextSize = input.search_context_size ?? input.searchContextSize;
+	const searchContextSize = ("search_context_size" in tool ? tool.search_context_size : void 0) ?? ("searchContextSize" in tool ? tool.searchContextSize : void 0);
 	if (searchContextSize === "low" || searchContextSize === "medium" || searchContextSize === "high") result.search_context_size = searchContextSize;
-	const userLocation = input.user_location ?? input.userLocation;
+	const userLocation = ("user_location" in tool ? tool.user_location : void 0) ?? ("userLocation" in tool ? tool.userLocation : void 0);
 	if (userLocation && typeof userLocation === "object") result.user_location = userLocation;
 	return result;
 }
@@ -1726,7 +1806,7 @@ function buildResponseShell(args) {
 		object: "response",
 		created_at: args.createdAt,
 		output_text: outputText,
-		error: null,
+		error: args.terminal?.error ?? null,
 		incomplete_details: null,
 		instructions: args.instructions ?? null,
 		metadata: null,
@@ -1737,7 +1817,7 @@ function buildResponseShell(args) {
 		tool_choice: "auto",
 		tools: [],
 		top_p: null,
-		status: "completed",
+		status: args.terminal?.status ?? "completed",
 		usage: args.usage,
 		previous_response_id: args.previousResponseId ?? null
 	};
@@ -1757,4 +1837,4 @@ function createTranslatorContext(init) {
 	};
 }
 //#endregion
-export { EmbeddingValidationError, HookChain, InMemoryResponseStore, ResponsesValidationError, Run, actionRateLimitHook, assembleResponseOutput, auditLogHook, buildResponseShell, costCapHook, createTranslatorContext, destructiveActionGuardHook, egressPolicyHook, normalizeResponsesWebSearchForTangleRouter, openaiMessagesToSandboxInput, outcomeToFinishReason, resolvePreviousResponseId, runEvents, sandboxEventToChatChunk, sandboxEventToCompletionChunk, sandboxEventToResponsesEvent, screenshotRedactionHook, usageFromEvents, validateEmbeddingRequest, validateResponsesRequest };
+export { EmbeddingValidationError, HookChain, InMemoryResponseStore, ResponsesValidationError, Run, actionRateLimitHook, assembleResponseOutput, auditLogHook, buildResponseShell, classifyOpenAITerminal, classifyOpenAITerminalEvents, costCapHook, createTranslatorContext, destructiveActionGuardHook, egressPolicyHook, normalizeResponsesWebSearchForTangleRouter, openaiMessagesToSandboxInput, outcomeToFinishReason, resolvePreviousResponseId, runEvents, sandboxEventToChatChunk, sandboxEventToCompletionChunk, sandboxEventToResponsesEvent, screenshotRedactionHook, usageFromEvents, validateEmbeddingRequest, validateResponsesRequest };

package/dist/{runtime-api-CK-4S7oA.js → runtime-api-TVLbV10b.js}

@@ -1,5 +1,5 @@
 import { a as NetworkError, c as QuotaError, f as TimeoutError, l as SandboxError, m as parseErrorResponse, n as CapabilityError, p as ValidationError, u as ServerError } from "./errors-C6kn-3zt.js";
-import { AgentExactRunControlRefSchema, agentProfileSchema, harnessTypeSchema } from "@tangle-network/agent-interface";
+import { AgentExactRunControlRefSchema, AgentExecutionOutcomeSchema, DurablePlanSchema, InteractionRequestSchema, agentProfileSchema, harnessTypeSchema } from "@tangle-network/agent-interface";
 import { z } from "zod";
 //#region ../../../packages/runtime-contracts/dist/backend-types.js
 /**
@@ -57,6 +57,392 @@ function parseBackendType(value) {
 	return value;
 }
 //#endregion
+//#region src/agent-run-outcome-inspection.ts
+const HUB_APPROVAL_REQUIRED = "HUB_APPROVAL_REQUIRED";
+const MAX_SERIALIZED_TOOL_VALUE_BYTES = 4 * 1024 * 1024;
+function parseInteraction(value) {
+	const parsed = InteractionRequestSchema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+}
+function parsePlan(value) {
+	const parsed = DurablePlanSchema.safeParse(value);
+	return parsed.success ? parsed.data : void 0;
+}
+function parseToolInvocations(value) {
+	if (!Array.isArray(value)) return void 0;
+	const result = [];
+	for (const entry of value) {
+		const tool = plainRecord(entry);
+		const toolName = readString(tool?.toolName);
+		if (!tool || !toolName || tool.isError !== void 0 && typeof tool.isError !== "boolean") return;
+		const invocation = { toolName };
+		const input = tool.input ?? tool.arguments;
+		if (input !== void 0) {
+			const copied = copyJsonValue(input);
+			if (!copied.success) return void 0;
+			invocation.input = copied.value;
+		}
+		if (tool.result !== void 0) {
+			const copied = copyJsonValue(tool.result);
+			if (!copied.success) return void 0;
+			invocation.result = copied.value;
+		}
+		if (typeof tool.isError === "boolean") invocation.isError = tool.isError;
+		result.push(invocation);
+	}
+	return result;
+}
+function inspectToolOutcomes(toolInvocations) {
+	let approval;
+	for (const tool of toolInvocations ?? []) {
+		if (tool.isError !== true) continue;
+		const inspection = inspectToolResult(tool.result);
+		if (!inspection.approvalCode) continue;
+		if (approval) return { malformed: true };
+		approval = { message: inspection.message ?? "Hub action requires approval" };
+		if (inspection.approvalId) approval.approvalId = inspection.approvalId;
+		if (inspection.connectionId) approval.connectionId = inspection.connectionId;
+	}
+	const result = { malformed: false };
+	if (approval) result.approval = approval;
+	return result;
+}
+function inspectToolResult(value) {
+	let root = value;
+	if (typeof value === "string") try {
+		root = JSON.parse(value);
+	} catch {
+		return { approvalCode: false };
+	}
+	const record = plainRecord(root);
+	if (!record) return { approvalCode: false };
+	const structuredContent = plainRecord(record.structuredContent);
+	const envelope = record.code === HUB_APPROVAL_REQUIRED ? record : structuredContent?.code === HUB_APPROVAL_REQUIRED ? structuredContent : void 0;
+	if (!envelope) return { approvalCode: false };
+	const approval = plainRecord(plainRecord(envelope.details)?.approval) ?? plainRecord(envelope.approval);
+	const result = { approvalCode: true };
+	const message = readString(envelope.message);
+	const approvalId = readString(approval?.id);
+	const connectionId = readString(approval?.connectionId);
+	if (message) result.message = message;
+	if (approvalId) result.approvalId = approvalId;
+	if (connectionId) result.connectionId = connectionId;
+	return result;
+}
+/** Copy a provider value into a bounded JSON-only value safe for public output. */
+function copyJsonValue(value) {
+	try {
+		const serialized = JSON.stringify(value);
+		if (serialized === void 0 || new TextEncoder().encode(serialized).byteLength > MAX_SERIALIZED_TOOL_VALUE_BYTES) return { success: false };
+		return {
+			success: true,
+			value: JSON.parse(serialized)
+		};
+	} catch {
+		return { success: false };
+	}
+}
+function questionFromInteraction(request) {
+	return {
+		questionId: request.id,
+		questions: request.answerSpec.fields.map((field) => field.type === "select" ? {
+			question: field.label,
+			options: field.options.map((option) => {
+				const value = { label: option.label };
+				if (option.description) value.description = option.description;
+				return value;
+			}),
+			multiSelect: field.multi === true
+		} : { question: field.label })
+	};
+}
+function normalizeStatus(value) {
+	return readString(value)?.toLowerCase().replaceAll("-", "_");
+}
+function readString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readError(value) {
+	if (!value) return void 0;
+	const direct = readString(value.error);
+	if (direct) return direct;
+	return readString(plainRecord(value.error)?.message) ?? readString(value.message);
+}
+function plainRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+//#endregion
+//#region src/agent-run-outcome.ts
+const FAILURE_STATUSES = new Set([
+	"canceled",
+	"cancelled",
+	"error",
+	"errored",
+	"failed",
+	"failure",
+	"timed_out",
+	"timeout"
+]);
+const SUCCESS_STATUSES = new Set([
+	"completed",
+	"done",
+	"ok",
+	"success"
+]);
+const WAIT_STATUSES = new Map([
+	["awaiting_interaction", "interaction"],
+	["awaiting_plan_decision", "plan"],
+	["awaiting_question", "question"],
+	["blocked_on_approval", "approval"]
+]);
+/** Track one run and settle its outcome only after its event stream ends. */
+function createAgentRunOutcomeTracker() {
+	const state = createOutcomeState();
+	let result;
+	return {
+		observe(event) {
+			if (result) throw new Error("Agent run outcome tracker is already finished");
+			observeEvent(state, event);
+		},
+		finish() {
+			result ??= settleOutcome(state);
+			return result;
+		}
+	};
+}
+/** Settle a complete in-memory event sequence with the streaming tracker. */
+function deriveAgentRunOutcome(events) {
+	const tracker = createAgentRunOutcomeTracker();
+	for (const event of events) tracker.observe(event);
+	return tracker.finish();
+}
+/** Settle one completed result record without treating live result frames as terminal. */
+function deriveAgentResultOutcome(result) {
+	const state = createOutcomeState();
+	observeOutcomeFrame(state, "result", result, true);
+	return settleOutcome(state);
+}
+function createOutcomeState() {
+	return {
+		terminalReached: false,
+		terminalStatuses: /* @__PURE__ */ new Set(),
+		malformed: false
+	};
+}
+function observeEvent(state, event) {
+	try {
+		if (!event || typeof event !== "object") {
+			state.malformed = true;
+			return;
+		}
+		const type = typeof event.type === "string" ? event.type : "";
+		const data = plainRecord(event.data);
+		if (!type || !data) {
+			state.malformed = true;
+			return;
+		}
+		if (type === "error") {
+			state.runError ??= readError(data) ?? "Agent execution failed";
+			state.runErrorCode ??= readString(data.code);
+		}
+		if (type === "interaction") observeInteraction(state, data);
+		if (type === "interaction.cancel") observeInteractionCancel(state, data);
+		if (type === "plan.submitted") observePlan(state, data);
+		if (type === "result") observeOutcomeFrame(state, type, data, false);
+		if (type === "done") observeOutcomeFrame(state, type, data, true);
+	} catch {
+		state.malformed = true;
+	}
+}
+function observeInteraction(state, data) {
+	const request = parseInteraction(data.request);
+	if (!request) {
+		state.malformed = true;
+		return;
+	}
+	retainInteraction(state, request);
+}
+function observeInteractionCancel(state, data) {
+	const id = readString(data.id);
+	if (!id) {
+		state.malformed = true;
+		return;
+	}
+	if (state.interaction?.id === id) state.interaction = void 0;
+}
+function observePlan(state, data) {
+	const plan = parsePlan(data.plan);
+	if (!plan) {
+		state.malformed = true;
+		return;
+	}
+	retainPlan(state, plan);
+}
+function observeOutcomeFrame(state, type, data, terminal) {
+	if (terminal) state.terminalReached = true;
+	if (data.success !== void 0 && typeof data.success !== "boolean") state.malformed = true;
+	if (typeof data.success === "boolean") {
+		if (state.terminalSuccess !== void 0 && state.terminalSuccess !== data.success) state.malformed = true;
+		state.terminalSuccess = data.success;
+	}
+	if (type === "done" || data.outcome !== void 0) {
+		if (!AgentExecutionOutcomeSchema.safeParse(data.outcome).success) state.malformed = true;
+	}
+	const outcome = plainRecord(data.outcome);
+	const nestedResult = plainRecord(data.result);
+	for (const value of [
+		data.status,
+		outcome?.type,
+		outcome?.status,
+		nestedResult?.status
+	]) {
+		if (value === void 0) continue;
+		const status = normalizeStatus(value);
+		if (status) state.terminalStatuses.add(status);
+		else state.malformed = true;
+	}
+	state.terminalError ??= readError(data) ?? readError(outcome) ?? readError(nestedResult);
+	state.terminalErrorCode ??= readString(data.errorCode) ?? readString(data.code) ?? readString(outcome?.errorCode) ?? readString(outcome?.code) ?? readString(nestedResult?.errorCode) ?? readString(nestedResult?.code);
+	const interactionCandidate = data.interaction ?? nestedResult?.interaction;
+	if (interactionCandidate !== void 0) {
+		const interaction = parseInteraction(interactionCandidate);
+		if (interaction) retainInteraction(state, interaction);
+		else state.malformed = true;
+	}
+	const planCandidate = data.plan ?? (outcome?.type === "awaiting_plan_decision" ? outcome.plan : void 0) ?? (nestedResult?.status === "awaiting_plan_decision" ? nestedResult.plan : void 0);
+	if (planCandidate !== void 0) {
+		const plan = parsePlan(planCandidate);
+		if (plan) retainPlan(state, plan);
+		else state.malformed = true;
+	}
+	const invocationCandidate = data.toolInvocations ?? nestedResult?.toolInvocations;
+	if (invocationCandidate !== void 0) {
+		const invocations = parseToolInvocations(invocationCandidate);
+		if (invocations) retainToolInvocations(state, invocations);
+		else state.malformed = true;
+	}
+	const toolOutcome = inspectToolOutcomes(state.toolInvocations);
+	if (toolOutcome.malformed) state.malformed = true;
+	state.approval = toolOutcome.approval;
+}
+function settleOutcome(state) {
+	const common = outcomeDetails(state);
+	if (state.runError) return failed(state.runError, state.runErrorCode, common);
+	const statusGroups = classifyStatuses(state.terminalStatuses);
+	if (statusGroups.failure) return failed(state.terminalError ?? `Agent execution ended with status ${statusGroups.failure}`, state.terminalErrorCode, common);
+	if (!state.terminalReached) return failed("Agent stream ended without a terminal event", void 0, common);
+	if (state.malformed || statusGroups.unknown || statusGroups.conflicting) return failed("Agent terminal outcome is malformed", void 0, common);
+	const wait = selectWait(state);
+	if (wait.error) return failed(wait.error, void 0, common);
+	if (statusGroups.wait && statusGroups.wait !== wait.kind) return failed("Agent terminal wait does not match its response request", void 0, common);
+	if (state.terminalSuccess === false && !wait.kind) return failed(state.terminalError ?? "Agent execution failed", state.terminalErrorCode, common);
+	if (state.terminalError && !statusGroups.wait) return failed(state.terminalError, state.terminalErrorCode, common);
+	if (wait.kind) return waitingOutcome(wait.kind, state, common);
+	return {
+		success: true,
+		status: "success",
+		...common
+	};
+}
+function classifyStatuses(statuses) {
+	let failure;
+	let wait;
+	let success = false;
+	let unknown = false;
+	let conflicting = false;
+	for (const status of statuses) if (FAILURE_STATUSES.has(status)) failure ??= status;
+	else if (SUCCESS_STATUSES.has(status)) success = true;
+	else if (WAIT_STATUSES.has(status)) {
+		const next = WAIT_STATUSES.get(status);
+		if (!next) continue;
+		if (wait && wait !== next) conflicting = true;
+		wait = next;
+	} else unknown = true;
+	if (failure && (wait || success)) conflicting = true;
+	return {
+		failure,
+		wait,
+		success,
+		unknown,
+		conflicting
+	};
+}
+function selectWait(state) {
+	const kinds = [];
+	if (state.plan) kinds.push("plan");
+	if (state.approval) kinds.push("approval");
+	if (state.interaction) kinds.push(state.interaction.kind === "question" ? "question" : "interaction");
+	if (kinds.length > 1) return { error: "Agent terminal outcome contains conflicting response requests" };
+	return { kind: kinds[0] };
+}
+function waitingOutcome(kind, state, common) {
+	if (kind === "plan") return {
+		success: false,
+		status: "awaiting_plan_decision",
+		error: "Agent is awaiting a durable plan decision",
+		...common
+	};
+	if (kind === "approval") return {
+		success: false,
+		status: "blocked_on_approval",
+		error: state.approval?.message ?? "Agent is awaiting approval",
+		...common
+	};
+	if (kind === "question") return {
+		success: false,
+		status: "awaiting_question",
+		error: "Agent is awaiting an answer",
+		...common
+	};
+	return {
+		success: false,
+		status: "awaiting_interaction",
+		error: "Agent is awaiting a response",
+		...common
+	};
+}
+function outcomeDetails(state) {
+	const question = state.interaction?.kind === "question" ? questionFromInteraction(state.interaction) : void 0;
+	const details = {};
+	if (state.toolInvocations) details.toolInvocations = state.toolInvocations;
+	if (state.approval) details.approval = state.approval;
+	if (state.interaction) details.interaction = state.interaction;
+	if (question) details.question = question;
+	if (state.plan) details.plan = state.plan;
+	return details;
+}
+function failed(error, errorCode, common) {
+	const outcome = {
+		success: false,
+		status: "failed",
+		error,
+		...common
+	};
+	if (errorCode) outcome.errorCode = errorCode;
+	return outcome;
+}
+function retainPlan(state, plan) {
+	if (state.plan && (state.plan.id !== plan.id || state.plan.revision !== plan.revision || state.plan.title !== plan.title || state.plan.body !== plan.body || state.plan.submittedAt !== plan.submittedAt)) {
+		state.malformed = true;
+		return;
+	}
+	state.plan = plan;
+}
+function retainInteraction(state, interaction) {
+	if (state.interaction && state.interaction.requestDigest !== interaction.requestDigest) {
+		state.malformed = true;
+		return;
+	}
+	state.interaction = interaction;
+}
+function retainToolInvocations(state, invocations) {
+	if (state.toolInvocations && JSON.stringify(state.toolInvocations) !== JSON.stringify(invocations)) {
+		state.malformed = true;
+		return;
+	}
+	state.toolInvocations = invocations;
+}
+//#endregion
 //#region src/backend-config.ts
 function assertCurrentBackendType(value, field = "backend.type") {
 	const parsed = backendTypeSchema.safeParse(value);
@@ -825,4 +1211,4 @@ function normalizeSessionInfo(raw) {
 	};
 }
 //#endregion
-export { uploadChunked as a, combineAbortSignals as c, applyRequestedModel as d, assertCurrentBackendType as f, parseBackendType as h, sessionHeaders as i, encodePromptForWire as l, backendTypeSchema as m, normalizeSessionInfo as n, SANDBOX_PROXY_REQUEST_MAX_BYTES as o, normalizeRuntimeBackendConfig as p, appendSessionIdQuery as r, FILE_DECODED_WRITE_MAX_BYTES as s, SandboxRuntimeApi as t, encodeTextForWire as u };
+export { backendTypeSchema as _, uploadChunked as a, combineAbortSignals as c, applyRequestedModel as d, assertCurrentBackendType as f, deriveAgentRunOutcome as g, deriveAgentResultOutcome as h, sessionHeaders as i, encodePromptForWire as l, createAgentRunOutcomeTracker as m, normalizeSessionInfo as n, SANDBOX_PROXY_REQUEST_MAX_BYTES as o, normalizeRuntimeBackendConfig as p, appendSessionIdQuery as r, FILE_DECODED_WRITE_MAX_BYTES as s, SandboxRuntimeApi as t, encodeTextForWire as u, parseBackendType as v };