@tangle-network/sandbox 0.30.1 → 0.30.2-solve.20260820075055.6e03f65

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 };

package/dist/runtime.d.ts

@@ -1,5 +1,6 @@
-import { Fi as TaskSessionInfo, Gr as SandboxTerminalCreateOptions, Hr as SandboxRuntimeHealth, Jr as SandboxTerminalRequestOptions, Kr as SandboxTerminalInfo, Lr as SandboxPortBinding, Mi as TaskSessionChanges, N as CreateSessionOptions, Ni as TaskSessionCommitResult, P as CreateTaskSessionOptions, Qi as WriteFileOptions, Vn as RenameOptions, _i as SessionMessage, _t as FileWriteResult, ci as SendSessionMessageRequest, gt as FileUsageResult, ht as FileUsageOptions, li as SentSessionMessage, mi as SessionInfo, mt as FileTreeResult, nn as ListMessagesOptions, ot as FileReadBatchOptions, pt as FileTreeOptions, qi as UploadProgress, qr as SandboxTerminalManager, si as SendSessionMessageOptions, st as FileReadBatchResult, ut as FileRenameResult, v as ChunkedUploadOptions, w as CommitTaskSessionOptions, y as ChunkedUploadResult } from "./types-Qn3x7R8O.js";
+import { $r as SandboxTerminalRequestOptions, Bi as TaskSessionInfo, C as ChunkedUploadResult, Hr as SandboxPortBinding, Kn as RenameOptions, L as CreateSessionOptions, Li as TaskSessionChanges, O as CommitTaskSessionOptions, Qi as UploadProgress, Qr as SandboxTerminalManager, R as CreateTaskSessionOptions, Ri as TaskSessionCommitResult, S as ChunkedUploadOptions, Si as SessionMessage, St as FileWriteResult, Xr as SandboxTerminalCreateOptions, Zr as SandboxTerminalInfo, bt as FileUsageOptions, dt as FileReadBatchOptions, fi as SendSessionMessageOptions, ft as FileReadBatchResult, ht as FileRenameResult, mi as SentSessionMessage, pi as SendSessionMessageRequest, qr as SandboxRuntimeHealth, ra as WriteFileOptions, sn as ListMessagesOptions, vt as FileTreeOptions, xt as FileUsageResult, yi as SessionInfo, yt as FileTreeResult } from "./types-D_ykdqn6.js";
 import { a as NetworkError, c as QuotaError, d as SandboxFailureDetail, f as ServerError, h as ValidationError, i as FileWriteConflictError, l as SandboxError, m as TimeoutError, n as CapabilityError, o as NotFoundError, p as StateError, s as PartialFailureError, t as AuthError, u as SandboxErrorJson } from "./errors-Bdy5jXzc.js";
+import { a as deriveAgentRunOutcome, i as deriveAgentResultOutcome, n as AgentRunOutcomeTracker, r as createAgentRunOutcomeTracker, t as AgentRunOutcome } from "./agent-run-outcome-TwIC-Ccd.js";
 
 //#region src/lib/chunked-upload.d.ts
 /** The transport a caller wires this module to — {@link SandboxInstance.runtimeFetch}
@@ -103,4 +104,4 @@ declare class SandboxRuntimeClient extends SandboxRuntimeApi {
 }
 declare function createSandboxRuntimeClient(config: SandboxRuntimeClientConfig): SandboxRuntimeClient;
 //#endregion
-export { AuthError, CapabilityError, type ChunkedUploadOptions, type ChunkedUploadResult, type ChunkedUploadTransport, type FileReadBatchOptions, type FileReadBatchResult, type FileRenameResult, type FileTreeOptions, type FileTreeResult, FileWriteConflictError, type FileWriteResult, type ListMessagesOptions, NetworkError, NotFoundError, PartialFailureError, QuotaError, type RenameOptions, SandboxError, type SandboxErrorJson, type SandboxFailureDetail, SandboxRuntimeClient, type SandboxRuntimeClientConfig, type SandboxRuntimeHealth, type SandboxTerminalCreateOptions, type SandboxTerminalInfo, type SandboxTerminalManager, type SandboxTerminalRequestOptions, ServerError, type SessionMessage, StateError, TimeoutError, type UploadProgress, ValidationError, type WriteFileOptions, createSandboxRuntimeClient, uploadChunked };
+export { type AgentRunOutcome, type AgentRunOutcomeTracker, AuthError, CapabilityError, type ChunkedUploadOptions, type ChunkedUploadResult, type ChunkedUploadTransport, type FileReadBatchOptions, type FileReadBatchResult, type FileRenameResult, type FileTreeOptions, type FileTreeResult, FileWriteConflictError, type FileWriteResult, type ListMessagesOptions, NetworkError, NotFoundError, PartialFailureError, QuotaError, type RenameOptions, SandboxError, type SandboxErrorJson, type SandboxFailureDetail, SandboxRuntimeClient, type SandboxRuntimeClientConfig, type SandboxRuntimeHealth, type SandboxTerminalCreateOptions, type SandboxTerminalInfo, type SandboxTerminalManager, type SandboxTerminalRequestOptions, ServerError, type SessionMessage, StateError, TimeoutError, type UploadProgress, ValidationError, type WriteFileOptions, createAgentRunOutcomeTracker, createSandboxRuntimeClient, deriveAgentResultOutcome, deriveAgentRunOutcome, uploadChunked };

package/dist/runtime.js

@@ -1,4 +1,4 @@
-import { a as uploadChunked, c as combineAbortSignals, t as SandboxRuntimeApi } from "./runtime-api-CK-4S7oA.js";
+import { a as uploadChunked, c as combineAbortSignals, g as deriveAgentRunOutcome, h as deriveAgentResultOutcome, m as createAgentRunOutcomeTracker, t as SandboxRuntimeApi } from "./runtime-api-TVLbV10b.js";
 import { a as NetworkError, c as QuotaError, d as StateError, f as TimeoutError, i as FileWriteConflictError, l as SandboxError, n as CapabilityError, o as NotFoundError, p as ValidationError, s as PartialFailureError, t as AuthError, u as ServerError } from "./errors-C6kn-3zt.js";
 //#region src/runtime-client.ts
 const DEFAULT_RUNTIME_TIMEOUT_MS = 3e4;
@@ -80,4 +80,4 @@ function createSandboxRuntimeClient(config) {
 	return new SandboxRuntimeClient(config);
 }
 //#endregion
-export { AuthError, CapabilityError, FileWriteConflictError, NetworkError, NotFoundError, PartialFailureError, QuotaError, SandboxError, SandboxRuntimeClient, ServerError, StateError, TimeoutError, ValidationError, createSandboxRuntimeClient, uploadChunked };
+export { AuthError, CapabilityError, FileWriteConflictError, NetworkError, NotFoundError, PartialFailureError, QuotaError, SandboxError, SandboxRuntimeClient, ServerError, StateError, TimeoutError, ValidationError, createAgentRunOutcomeTracker, createSandboxRuntimeClient, deriveAgentResultOutcome, deriveAgentRunOutcome, uploadChunked };