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

package/dist/{sandbox-BwIaQcE7.js → sandbox-DM-VD8ja.js}

@@ -1,10 +1,164 @@
-import { a as uploadChunked, c as combineAbortSignals, d as applyRequestedModel, f as assertCurrentBackendType, i as sessionHeaders, l as encodePromptForWire, n as normalizeSessionInfo, o as SANDBOX_PROXY_REQUEST_MAX_BYTES, p as normalizeRuntimeBackendConfig, r as appendSessionIdQuery, t as SandboxRuntimeApi } from "./runtime-api-CK-4S7oA.js";
+import { a as uploadChunked, c as combineAbortSignals, d as applyRequestedModel, f as assertCurrentBackendType, h as deriveAgentResultOutcome, i as sessionHeaders, l as encodePromptForWire, m as createAgentRunOutcomeTracker, n as normalizeSessionInfo, o as SANDBOX_PROXY_REQUEST_MAX_BYTES, p as normalizeRuntimeBackendConfig, r as appendSessionIdQuery, t as SandboxRuntimeApi } from "./runtime-api-TVLbV10b.js";
 import { a as NetworkError, c as QuotaError, d as StateError, f as TimeoutError, l as SandboxError, m as parseErrorResponse, n as CapabilityError, o as NotFoundError, p as ValidationError, t as AuthError, u as ServerError } from "./errors-C6kn-3zt.js";
 import { AgentExactRunControlRefSchema, AgentRunCancellationAcknowledgementSchema, AgentRunCancellationRequestSchema, InteractionAcknowledgementSchema, InteractionBindingSchema, InteractionRequestSchema, InteractionResponseCommandSchema, InteractionResponseSchema, agentRunCancellationAcknowledgementMatchesRequest, canonicalCandidateDigest, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { z } from "zod";
 import { readTokenCostUsd, readTokenUsage } from "@tangle-network/agent-core";
+//#region ../../../packages/sse-core/dist/index.js
+/**
+* Incremental SSE frame parser. Feed decoded text via `push()`; call
+* `flush()` when the stream ends.
+*/
+var SSEFrameParser = class {
+	buffer = "";
+	frameEvent = "";
+	frameId;
+	frameDataLines = null;
+	bomChecked = false;
+	/**
+	* Append a decoded text chunk and return every frame the chunk
+	* completes. Frame state survives across calls: one frame can
+	* straddle any number of chunks.
+	*/
+	push(chunk) {
+		let text = chunk;
+		if (!this.bomChecked && text.length > 0) {
+			this.bomChecked = true;
+			if (text.charCodeAt(0) === 65279) text = text.slice(1);
+		}
+		this.buffer += text;
+		const lines = this.buffer.split("\n");
+		this.buffer = lines.pop() ?? "";
+		return this.processLines(lines);
+	}
+	/**
+	* End-of-stream: process the unterminated trailing line, then
+	* dispatch a dangling frame that never got its blank line.
+	* Well-behaved servers end frames with "\n\n", but some close early.
+	*/
+	flush() {
+		const rest = this.buffer;
+		this.buffer = "";
+		const frames = rest.length > 0 ? this.processLines([rest]) : [];
+		const dangling = this.dispatch();
+		if (dangling) frames.push(dangling);
+		return frames;
+	}
+	processLines(lines) {
+		const frames = [];
+		for (const rawLine of lines) {
+			const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+			if (line === "") {
+				const frame = this.dispatch();
+				if (frame) frames.push(frame);
+				continue;
+			}
+			if (line.startsWith(":")) continue;
+			if (line.startsWith("data:")) {
+				let value = line.slice(5);
+				if (value.startsWith(" ")) value = value.slice(1);
+				if (this.frameDataLines === null) this.frameDataLines = [];
+				this.frameDataLines.push(value);
+				continue;
+			}
+			if (line.startsWith("event:")) {
+				this.frameEvent = line.slice(6).trim();
+				continue;
+			}
+			if (line.startsWith("id:")) this.frameId = line.slice(3).trim();
+		}
+		return frames;
+	}
+	/**
+	* Dispatch the accumulated frame. A frame with no `data:` field (an
+	* `event:`/`id:`-only frame, or a bare comment) produces nothing, and
+	* its field state is consumed and reset either way.
+	*/
+	dispatch() {
+		const dataLines = this.frameDataLines;
+		const frame = dataLines ? {
+			event: this.frameEvent,
+			data: dataLines.join("\n"),
+			id: this.frameId || void 0
+		} : null;
+		this.frameEvent = "";
+		this.frameId = void 0;
+		this.frameDataLines = null;
+		return frame;
+	}
+};
+/**
+* Read a streaming SSE response body into parsed frames.
+*
+* @throws `TypeError` when the body is missing.
+* @throws `DOMException` with `name === "AbortError"` on cancellation —
+*   including the WHATWG-fetch variant where an aborted body resolves
+*   `done: true` instead of rejecting the read.
+*/
+async function* streamSSEFrames(body, options) {
+	if (!body) throw new TypeError("SSE stream has no response body");
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	const parser = new SSEFrameParser();
+	const { signal } = options ?? {};
+	let completed = false;
+	try {
+		for (;;) {
+			if (signal?.aborted) throw new DOMException("SSE stream aborted", "AbortError");
+			const { done, value } = await reader.read();
+			if (done) {
+				if (signal?.aborted) throw new DOMException("SSE stream aborted", "AbortError");
+				break;
+			}
+			for (const frame of parser.push(decoder.decode(value, { stream: true }))) yield frame;
+		}
+		for (const frame of parser.push(decoder.decode())) yield frame;
+		for (const frame of parser.flush()) yield frame;
+		completed = true;
+	} finally {
+		if (!completed) await reader.cancel().catch(() => void 0);
+		reader.releaseLock();
+	}
+}
+//#endregion
 //#region src/lib/sse-parser.ts
 /**
+* SSE Stream Parser
+*
+* EventSource stream parsing for SDK consumers. Framing — buffering
+* chunk-straddling frames, LF/CRLF terminators, multi-line `data:` joins,
+* comment heartbeats, BOM — lives in `@tangle-network/sse-core`, the one
+* wire-format implementation shared across the repo (bundled into this
+* package's dist, so the SDK stays dependency-free at runtime). This
+* module owns the SDK's payload contract on top of it: JSON parsing, the
+* `"message"` default event type, and the malformed-frame policy. Used by
+* `Sandbox.streamBatch` and by the web dashboard's batch page; exported
+* so downstream surfaces don't maintain their own copies.
+*
+* Guarantees:
+*   - Correctly buffers frames that straddle chunk boundaries.
+*   - Accepts LF- and CRLF-terminated streams interchangeably.
+*   - Joins multi-line `data:` per the spec (dispatch joins with
+*     "\n" before JSON parse).
+*   - Defaults event type to `"message"` when a frame carries
+*     `data:` but no `event:` field (SSE spec §9.2.6 step 3).
+*   - Surfaces optional `id:` so callers can implement reconnection.
+*   - Flushes a dangling event when the stream closes without a
+*     terminating blank line (well-behaved servers emit `\n\n`, but
+*     some close early).
+*   - Throws `AbortError` when the caller-supplied signal fires, so
+*     consumers can distinguish "ran to completion" from "cancelled"
+*     without peeking at signal state.
+*   - Rejects malformed JSON by default. Callers handling recoverable output
+*     streams can explicitly warn and skip one invalid frame.
+*
+* What it does NOT do:
+*   - CR-only (legacy Mac) line terminators. No known emitter uses
+*     them; supporting them would risk splitting payloads that
+*     legitimately contain CR.
+*   - Retry/reconnect (caller's responsibility).
+*   - Event-type filtering (caller's responsibility).
+*/
+/**
 * Parse a streaming SSE response body into an async iterable of
 * structured events.
 *
@@ -12,81 +166,31 @@ import { readTokenCostUsd, readTokenUsage } from "@tangle-network/agent-core";
 * @throws `DOMException` with `name === "AbortError"` on cancellation.
 */
 async function* parseSSEStream(body, options) {
-	if (!body) throw new TypeError("SSE stream has no response body");
-	const reader = body.getReader();
-	const decoder = new TextDecoder();
 	const { signal, invalidEvent = "throw" } = options ?? {};
-	let buffer = "";
-	let currentEvent = "";
-	let dataLines = [];
-	let currentId = "";
-	let completed = false;
-	const flush = function* () {
-		if (dataLines.length === 0) {
-			currentEvent = "";
-			currentId = "";
-			return;
-		}
-		const effectiveEvent = currentEvent || "message";
-		const joined = dataLines.join("\n");
+	for await (const frame of streamSSEFrames(body, { signal })) {
+		const effectiveEvent = frame.event || "message";
 		let data;
 		try {
-			data = JSON.parse(joined);
+			data = JSON.parse(frame.data);
 		} catch (error) {
 			if (invalidEvent === "warn-and-skip") {
-				console.warn(`[sandbox-sdk] Malformed SSE JSON for event "${effectiveEvent}": ${joined.slice(0, 200)}`);
-				currentEvent = "";
-				dataLines = [];
-				currentId = "";
-				return;
+				console.warn(`[sandbox-sdk] Malformed SSE JSON for event "${effectiveEvent}": ${frame.data.slice(0, 200)}`);
+				continue;
 			}
 			throw new SyntaxError(`Malformed SSE JSON for event "${effectiveEvent}"`, { cause: error });
 		}
 		if (typeof data !== "object" || data === null || Array.isArray(data)) {
 			if (invalidEvent === "warn-and-skip") {
 				console.warn(`[sandbox-sdk] SSE event "${effectiveEvent}" data must be a JSON object`);
-				currentEvent = "";
-				dataLines = [];
-				currentId = "";
-				return;
+				continue;
 			}
 			throw new TypeError(`SSE event "${effectiveEvent}" data must be a JSON object`);
 		}
 		yield {
 			type: effectiveEvent,
 			data,
-			id: currentId || void 0
+			id: frame.id
 		};
-		currentEvent = "";
-		dataLines = [];
-		currentId = "";
-	};
-	const processLine = (line) => {
-		if (line.startsWith("event:")) currentEvent = line.slice(6).trim();
-		else if (line.startsWith("data:")) dataLines.push(line.slice(5).trim());
-		else if (line.startsWith("id:")) currentId = line.slice(3).trim();
-	};
-	try {
-		while (true) {
-			if (signal?.aborted) throw new DOMException("SSE stream aborted", "AbortError");
-			const { done, value } = await reader.read();
-			if (done) {
-				if (signal?.aborted) throw new DOMException("SSE stream aborted", "AbortError");
-				break;
-			}
-			buffer += decoder.decode(value, { stream: true });
-			const lines = buffer.split(/\r?\n/);
-			buffer = lines.pop() ?? "";
-			for (const line of lines) if (line === "") yield* flush();
-			else processLine(line);
-		}
-		buffer += decoder.decode();
-		if (buffer.length > 0) processLine(buffer);
-		yield* flush();
-		completed = true;
-	} finally {
-		if (!completed) await reader.cancel().catch(() => void 0);
-		reader.releaseLock();
 	}
 }
 //#endregion
@@ -736,7 +840,7 @@ async function submitSandboxInteractionCommand(transport, sessionId, command, op
 /**
 * The text carried by a single event, or `undefined` when the event carries no
 * text payload. Mirrors the event shapes the sidecar/OpenCode runtime emits:
-*  - `result`     — the terminal event; final text under `finalText`/`response`/
+*  - `result`     — the final response summary; text under `finalText`/`response`/
 *                   `output`/`content`/`text`.
 *  - `token`      — an incremental token; text under `value`/`delta`/`text`/
 *                   `content`.
@@ -1907,153 +2011,6 @@ function runtimeFilesystemPath(endpoint, path) {
 	const encodedPath = segments.map(encodeURIComponent).join("/");
 	return `${endpoint}/${isAbsolute ? "/" : ""}${encodedPath}`;
 }
-/**
-* Single source of truth for a run's outcome, shared by
-* `prompt`/`task`/`_sessionResult`/turn settling. A run succeeds only when it
-* reached a terminal event, raised no run-level error, hit no approval gate,
-* left no unanswered question, and recorded no failed (`isError`) tool. A
-* tool-only turn with no text succeeds unless the server enforces visible-output
-* requirements; a turn whose tool failed (even if narrated around) fails.
-*/
-function deriveOutcome(inputs) {
-	if (inputs.plan) return {
-		status: "awaiting_plan_decision",
-		success: false,
-		error: "Agent is awaiting a durable plan decision"
-	};
-	if (inputs.question) return {
-		status: "awaiting_question",
-		success: false,
-		error: inputs.runError ?? "Agent is awaiting an answer to a question"
-	};
-	if (inputs.approval) return {
-		status: "blocked_on_approval",
-		success: false,
-		error: inputs.runError ?? inputs.approval.message ?? "Agent is blocked on a hub approval"
-	};
-	if (inputs.runError) return {
-		status: "failed",
-		success: false,
-		error: inputs.runError,
-		errorCode: inputs.runErrorCode
-	};
-	const failedTool = inputs.toolInvocations?.find((t) => t.isError === true);
-	if (failedTool) return {
-		status: "failed",
-		success: false,
-		error: `Tool "${failedTool.toolName}" failed`
-	};
-	if (!inputs.terminalReached) return {
-		status: "failed",
-		success: false,
-		error: "Agent stream ended without a terminal event"
-	};
-	return {
-		status: "success",
-		success: true
-	};
-}
-function readAwaitingPlan(data) {
-	const direct = data.plan;
-	const outcome = data.outcome;
-	const candidate = direct && typeof direct === "object" ? direct : outcome && typeof outcome === "object" && outcome.type === "awaiting_plan_decision" ? outcome.plan : void 0;
-	if (!candidate || typeof candidate !== "object") return void 0;
-	const plan = candidate;
-	if (typeof plan.id !== "string" || typeof plan.revision !== "number" || typeof plan.body !== "string" || typeof plan.submittedAt !== "string") return;
-	return plan;
-}
-function readPlanFromEvent(event) {
-	return event.type === "result" || event.type === "done" || event.type === "plan.submitted" ? readAwaitingPlan(event.data) : void 0;
-}
-/** Read tool invocations off a `result` event payload. */
-function readToolInvocations(data) {
-	const raw = data.toolInvocations;
-	return Array.isArray(raw) ? raw : void 0;
-}
-/** Hub error code surfaced when a write tool hits an approval gate. */
-const HUB_APPROVAL_CODE = "HUB_APPROVAL_REQUIRED";
-/** Best-effort string view of an arbitrary tool result for signal matching. */
-function stringifyToolResult(result) {
-	if (typeof result === "string") return result;
-	try {
-		return JSON.stringify(result) ?? "";
-	} catch {
-		return String(result);
-	}
-}
-/**
-* Walk a tool result for an `approval` object and return its `id`/`connectionId`.
-* The in-sandbox hub bridge carries these in `structuredContent.details.approval`,
-* but the exact nesting depends on how the backend serialized the MCP result, so
-* search defensively. Returns `undefined` when not present — the id is then
-* surfaced honestly as `undefined`, never invented.
-*/
-function findApprovalDetails(value, depth = 0) {
-	if (depth > 6 || value === null || typeof value !== "object") return void 0;
-	const obj = value;
-	const approval = obj.approval;
-	if (approval && typeof approval === "object") {
-		const a = approval;
-		return {
-			...typeof a.id === "string" ? { id: a.id } : {},
-			...typeof a.connectionId === "string" ? { connectionId: a.connectionId } : {}
-		};
-	}
-	for (const v of Object.values(obj)) {
-		const found = findApprovalDetails(v, depth + 1);
-		if (found) return found;
-	}
-}
-/** Find a human-readable `message` string anywhere in a tool result. */
-function findResultMessage(value, depth = 0) {
-	if (depth > 6 || value === null || typeof value !== "object") return void 0;
-	const obj = value;
-	if (typeof obj.message === "string" && obj.message.length > 0) return obj.message;
-	for (const v of Object.values(obj)) {
-		const found = findResultMessage(v, depth + 1);
-		if (found) return found;
-	}
-}
-/**
-* Detect a hub approval gate among a run's tool invocations: a failed tool whose
-* result carries `HUB_APPROVAL_REQUIRED`. Returns the approval id/connectionId
-* when the structured signal survived serialization, else just the message — so
-* the run can settle as `blocked_on_approval` even when the id is unrecoverable.
-*/
-function detectHubApproval(toolInvocations) {
-	if (!toolInvocations) return void 0;
-	for (const tool of toolInvocations) {
-		if (tool.isError !== true) continue;
-		if (!stringifyToolResult(tool.result).includes(HUB_APPROVAL_CODE)) continue;
-		const approval = findApprovalDetails(tool.result);
-		const message = findResultMessage(tool.result) ?? "Hub action requires approval";
-		return {
-			...approval?.id ? { approvalId: approval.id } : {},
-			...approval?.connectionId ? { connectionId: approval.connectionId } : {},
-			message
-		};
-	}
-}
-/** Read an `interaction` event (kind `question`) into an awaiting-question requirement. */
-function readQuestionEvent(data) {
-	const request = data.request;
-	if (!request || request.kind !== "question" || typeof request.id !== "string") return;
-	return {
-		questionId: request.id,
-		questions: questionsFromAnswerSpec(request)
-	};
-}
-/** Reconstruct the prompt/options shape from a question interaction's answerSpec. */
-function questionsFromAnswerSpec(request) {
-	return request.answerSpec.fields.map((field) => field.type === "select" ? {
-		question: field.label,
-		options: field.options.map((o) => ({
-			label: o.label,
-			description: o.description
-		})),
-		multiSelect: field.multi === true
-	} : { question: field.label });
-}
 function isProfileNotCachedError(err) {
 	return err instanceof SandboxError && err.code === "PROFILE_NOT_CACHED";
 }
@@ -2841,16 +2798,11 @@ var SandboxInstance = class SandboxInstance {
 		await this.ensureRunning();
 		const startTime = Date.now();
 		let responseText;
-		let runError;
-		let runErrorCode;
+		const outcomeTracker = createAgentRunOutcomeTracker();
 		let executionId = options?.lastEventId ? options.executionId : void 0;
 		let traceId;
 		let usage;
 		let costUsd;
-		let toolInvocations;
-		let question;
-		let plan;
-		let terminalReached = false;
 		const controller = new AbortController();
 		try {
 			const signal = options?.signal ? combineAbortSignals([options.signal, controller.signal]) : controller.signal;
@@ -2858,6 +2810,7 @@ var SandboxInstance = class SandboxInstance {
 				...options,
 				signal
 			})) {
+				outcomeTracker.observe(event);
 				responseText = applySandboxEventText(responseText, event);
 				const eventExecutionId = event.data.executionId;
 				if (typeof eventExecutionId === "string" && eventExecutionId.length > 0) executionId = eventExecutionId;
@@ -2865,26 +2818,9 @@ var SandboxInstance = class SandboxInstance {
 					usage = readTokenUsage(event.data) ?? usage;
 					costUsd = readTokenCostUsd(event.data) ?? costUsd;
 				}
-				plan = readPlanFromEvent(event) ?? plan;
-				if (event.type === "result") toolInvocations = readToolInvocations(event.data) ?? toolInvocations;
-				if (event.type === "result" || event.type === "done") terminalReached = true;
-				if (event.type === "interaction") question = readQuestionEvent(event.data) ?? question;
 				if (event.type === "trace.id") traceId = event.data.traceId;
-				if (event.type === "error") {
-					runError = event.data.message;
-					runErrorCode = event.data.code;
-				}
 			}
-			const approval = detectHubApproval(toolInvocations);
-			const outcome = deriveOutcome({
-				terminalReached,
-				runError,
-				runErrorCode,
-				toolInvocations,
-				approval,
-				question,
-				plan
-			});
+			const outcome = outcomeTracker.finish();
 			return {
 				success: outcome.success,
 				status: outcome.status,
@@ -2892,10 +2828,11 @@ var SandboxInstance = class SandboxInstance {
 				response: responseText,
 				error: outcome.error,
 				errorCode: outcome.errorCode,
-				toolInvocations,
-				approval,
-				question,
-				plan,
+				toolInvocations: outcome.toolInvocations,
+				approval: outcome.approval,
+				interaction: outcome.interaction,
+				question: outcome.question,
+				plan: outcome.plan,
 				traceId,
 				durationMs: Date.now() - startTime,
 				usage,
@@ -2924,15 +2861,13 @@ var SandboxInstance = class SandboxInstance {
 	* Stream events from an agent prompt.
 	* Use this for real-time updates during agent execution.
 	*
-	* Guarantees a terminal event on every non-cancelled path: a clean run
-	* ends with the runtime's `result`/`done`; a failure (pre-stream HTTP
-	* error, mid-stream network drop, timeout, or reconnect exhaustion) is
-	* surfaced as an in-band `error` event followed by a synthetic `done`,
-	* never a thrown generator. Caller-initiated cancellation (aborting
-	* `options.signal`) ends the stream silently with no synthetic terminal.
+	* Guarantees terminal completion on every non-cancelled path. A clean run
+	* emits a `result` summary and ends with `done`. A failure is an in-band
+	* `error` followed by `done`, never a thrown generator. Caller cancellation
+	* ends the stream silently with no synthetic terminal.
 	*
 	* Automatically reconnects via the runtime event replay endpoint if the
-	* SSE stream drops before a terminal event (`result` or `done`) is
+	* SSE stream drops before a terminal event (`done` or `error`) is
 	* received. Reconnection is transparent — replayed events that were
 	* already yielded (based on event ID tracking) are deduplicated.
 	*/
@@ -3015,7 +2950,7 @@ var SandboxInstance = class SandboxInstance {
 				try {
 					for await (const event of this.streamPromptInner(message, options, { forceFullProfile: profileResendAttempted })) {
 						yieldedThisAttempt = true;
-						if (event.type === "result" || event.type === "done") receivedTerminal = true;
+						if (event.type === "done") receivedTerminal = true;
 						if (event.type === "execution.started" && event.data.executionId) executionId = event.data.executionId;
 						const sid = event.data.sessionId;
 						if (typeof sid === "string" && sid.length > 0) sessionId = sid;
@@ -3174,7 +3109,7 @@ var SandboxInstance = class SandboxInstance {
 			if (event.type === "execution.started" && event.data?.executionId) executionId = event.data.executionId;
 			const eventSessionId = event.data?.sessionId;
 			if (typeof eventSessionId === "string" && eventSessionId.length > 0) sessionId = eventSessionId;
-			if (event.type === "result" || event.type === "done") {
+			if (event.type === "done" || event.type === "error") {
 				receivedTerminal = true;
 				logStreamCheckpoint("terminal_event", {
 					eventType: event.type,
@@ -3244,6 +3179,7 @@ var SandboxInstance = class SandboxInstance {
 										sessionId,
 										executionId,
 										status: info.status,
+										...info.status === "completed" ? { outcome: { type: "completed" } } : {},
 										replayUnavailable: true
 									}
 								};
@@ -3268,7 +3204,7 @@ var SandboxInstance = class SandboxInstance {
 					if (event.id) lastEventId = event.id;
 					const eventSessionId = event.data?.sessionId;
 					if (typeof eventSessionId === "string" && eventSessionId.length > 0) sessionId = eventSessionId;
-					if (event.type === "result" || event.type === "done") {
+					if (event.type === "done" || event.type === "error") {
 						receivedTerminal = true;
 						logStreamCheckpoint("terminal_event", {
 							eventType: event.type,
@@ -4578,37 +4514,16 @@ var SandboxInstance = class SandboxInstance {
 		};
 	}
 	async *parseProcessLogStream(response) {
-		const reader = response.body?.getReader();
-		if (!reader) throw new NetworkError("No response body");
-		const decoder = new TextDecoder();
-		let buffer = "";
-		let currentEvent = "";
-		let currentData = "";
-		try {
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				buffer += decoder.decode(value, { stream: true });
-				const lines = buffer.split("\n");
-				buffer = lines.pop() ?? "";
-				for (const line of lines) if (line.startsWith("event:")) currentEvent = line.slice(6).trim();
-				else if (line.startsWith("data:")) currentData = line.slice(5).trim();
-				else if (line === "" && currentEvent && currentData) {
-					if (currentEvent === "stdout" || currentEvent === "stderr") try {
-						const parsed = JSON.parse(currentData);
-						yield {
-							type: currentEvent,
-							data: parsed.data,
-							timestamp: parsed.timestamp
-						};
-					} catch {}
-					else if (currentEvent === "exit") return;
-					currentEvent = "";
-					currentData = "";
-				}
-			}
-		} finally {
-			reader.releaseLock();
+		if (!response.body) throw new NetworkError("No response body");
+		for await (const event of parseSSEStream(response.body, { invalidEvent: "warn-and-skip" })) {
+			if (event.type === "exit") return;
+			if (event.type !== "stdout" && event.type !== "stderr") continue;
+			if (typeof event.data.data !== "string" || typeof event.data.timestamp !== "number") continue;
+			yield {
+				type: event.type,
+				data: event.data.data,
+				timestamp: event.data.timestamp
+			};
 		}
 	}
 	/**
@@ -6367,7 +6282,7 @@ var SandboxInstance = class SandboxInstance {
 		}
 		for await (const event of this.parseSSEStream(response, opts?.signal)) {
 			yield event;
-			const turnTerminal = event.type === "result" || event.type === "done" || event.type === "error";
+			const turnTerminal = event.type === "done" || event.type === "error";
 			if ((stopOnTurnTerminal || opts?.executionId !== void 0) && turnTerminal) return;
 		}
 	}
@@ -6386,7 +6301,7 @@ var SandboxInstance = class SandboxInstance {
 		}
 		for await (const event of this.parseSSEStream(response)) {
 			yield event;
-			if (event.type === "result" || event.type === "done" || event.type === "error") return;
+			if (event.type === "done" || event.type === "error") return;
 		}
 	}
 	/** @internal — invoked by SandboxSession.result(). */
@@ -6408,20 +6323,13 @@ var SandboxInstance = class SandboxInstance {
 		}
 		let resultExecutionId = executionId;
 		let response;
-		let runError;
-		let runErrorCode;
+		const outcomeTracker = createAgentRunOutcomeTracker();
 		let traceId;
 		let usage;
 		let costUsd;
-		let toolInvocations;
-		let question;
-		let plan;
-		let terminalReached = false;
-		const events = options?.executionId ? this._executionEvents(id, executionId) : this._sessionEvents(id, {
-			since: "0",
-			executionId
-		}, true);
+		const events = this._executionEvents(id, executionId);
 		for await (const event of events) {
+			outcomeTracker.observe(event);
 			response = applySandboxEventText(response, event);
 			if (event.type === "result" || event.type === "done") {
 				const data = event.data;
@@ -6429,33 +6337,10 @@ var SandboxInstance = class SandboxInstance {
 				usage = readTokenUsage(data) ?? usage;
 				costUsd = readTokenCostUsd(data) ?? costUsd;
 			}
-			plan = readPlanFromEvent(event) ?? plan;
-			if (event.type === "result") {
-				const data = event.data;
-				toolInvocations = readToolInvocations(data) ?? toolInvocations;
-			}
-			if (event.type === "interaction") question = readQuestionEvent(event.data) ?? question;
 			if (event.type === "trace.id") traceId = event.data.traceId;
-			if (event.type === "error") {
-				const data = event.data;
-				runError = data.message;
-				runErrorCode = data.code;
-			}
-			if (event.type === "done" || event.type === "result") {
-				terminalReached = true;
-				break;
-			}
+			if (event.type === "done" || event.type === "error") break;
 		}
-		const approval = detectHubApproval(toolInvocations);
-		const outcome = deriveOutcome({
-			terminalReached,
-			runError,
-			runErrorCode,
-			toolInvocations,
-			approval,
-			question,
-			plan
-		});
+		const outcome = outcomeTracker.finish();
 		return {
 			success: outcome.success,
 			status: outcome.status,
@@ -6463,10 +6348,11 @@ var SandboxInstance = class SandboxInstance {
 			response,
 			error: outcome.error,
 			errorCode: outcome.errorCode,
-			toolInvocations,
-			approval,
-			question,
-			plan,
+			toolInvocations: outcome.toolInvocations,
+			approval: outcome.approval,
+			interaction: outcome.interaction,
+			question: outcome.question,
+			plan: outcome.plan,
 			traceId,
 			durationMs: Date.now() - startTime,
 			usage,
@@ -6760,21 +6646,16 @@ function isSessionInFlight(info) {
 	return info.status === "queued" && !isSessionAwaitingFirstTurn(info);
 }
 function settleTurnDrive(result) {
-	const plan = readAwaitingPlan(result);
-	if (plan) return {
+	const outcome = deriveAgentResultOutcome(result);
+	if (outcome.status === "awaiting_plan_decision" && outcome.plan) return {
 		state: "awaiting_plan_decision",
-		plan,
+		plan: outcome.plan,
 		result
 	};
 	const text = typeof result.text === "string" ? result.text : typeof result.response === "string" ? result.response : void 0;
-	const status = typeof result.status === "string" ? result.status : deriveOutcome({
-		terminalReached: true,
-		runError: typeof result.error === "string" ? result.error : void 0,
-		toolInvocations: Array.isArray(result.toolInvocations) ? result.toolInvocations : void 0
-	}).status;
-	if (status !== "success") return {
+	if (outcome.status !== "success") return {
 		state: "failed",
-		error: typeof result.error === "string" && result.error.length > 0 ? result.error : `turn ${status}`
+		error: outcome.error ?? `turn ${outcome.status}`
 	};
 	const usage = readTokenUsage(result);
 	return {