@tangle-network/agent-runtime 0.143.0 → 0.153.2

package/dist/{environment-provider-DCBJ13VP.js → environment-provider-3eCszBEm.js}

@@ -1,8 +1,134 @@
-import { C as sameControlCoordinates, E as promptOptionsFromAgentTurnInput, T as promptFromAgentTurnInput, d as awaitAbortable } from "./retained-run-binding-Dp2e8xne.js";
-import { _ as zeroTokenUsage } from "./util-C1bv6yog.js";
-import { n as canonicalStreamEventFromSandboxEvent } from "./sandbox-events-COwCWUVB.js";
+import { F as awaitAbortable, X as promptOptionsFromAgentTurnInput, Y as promptFromAgentTurnInput, o as finalizeRuntimeOwnedPendingExecutor, q as sameControlCoordinates, r as attestRuntimeOwnedPendingExecutor, u as newExecutionAttemptId } from "./materialization-Dl9J8ek4.js";
+import { b as zeroTokenUsage } from "./util-D6ZEuBMi.js";
+import { a as isSandboxTerminalEvent, d as sandboxTerminalUsageField, n as canonicalStreamEventFromSandboxEvent, r as createSandboxToolPartState, u as sandboxProgressEvents } from "./sandbox-events-BVjstFgb.js";
+import { a as concreteProfileModel, c as profileModelExecutionSettings, o as enforceTokenLimits } from "./model-policy-Sw4ywhtL.js";
 import { AgentExactRunControlRefSchema, AgentRunCancellationRequestSchema, harnessSystemPromptIntents } from "@tangle-network/agent-interface";
+import { randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
+//#region src/runtime/supervise/abortable.ts
+/**
+* One abort race, and one abort cascade, for the supervision tree.
+*
+* Every layer that can be cancelled needs the same three things: the reason a signal
+* carries, an `AbortError` built from it, and a settle-once race between the work and
+* the signal. Written per layer, each drifts — a listener stops being removed on one
+* path, a late resolution overwrites a cancellation that already won, or a cascade
+* forwards no reason and renames every downstream death to the layer's own fallback.
+*
+* The fallback message is the only thing a layer supplies, so the error still names
+* which layer cancelled.
+*/
+/**
+* The reason a signal carries, or `fallback` when it states none.
+*
+* A cascade that drops the upstream reason turns every downstream death into its own generic
+* message: the worker's `down` record then says nothing about WHY, which makes a whole class of
+* child mortality undiagnosable from the journal alone.
+*/
+function abortReason(signal, fallback) {
+	const reason = signal.reason;
+	if (typeof reason === "string" && reason.length > 0) return reason;
+	if (reason instanceof Error && reason.name !== "AbortError" && reason.message.length > 0) return reason.message;
+	return fallback;
+}
+/** An `AbortError` carrying the signal's own string reason, or `fallback` when it states none. */
+function abortError(signal, fallback) {
+	const reason = abortReason(signal, fallback);
+	const error = new Error(typeof reason === "string" && reason.length > 0 ? reason : fallback);
+	error.name = "AbortError";
+	return error;
+}
+/**
+* Cascade N abort signals into one downstream abort that fires when ANY of them does, carrying
+* that signal's own reason ({@link abortReason}). Node-portable: `AbortSignal.any` needs >=20.3
+* and the package floor is >=20, and it would drop the reason anyway.
+*
+* The one cascade every executor uses, so a reason forwarded here reaches every layer below.
+*/
+function linkAbort(...sources) {
+	const controller = new AbortController();
+	const listeners = [];
+	const release = () => {
+		for (const { source, onAbort } of listeners) source.removeEventListener("abort", onAbort);
+		listeners.length = 0;
+	};
+	const abort = (reason) => {
+		release();
+		controller.abort(reason);
+	};
+	const alreadyAborted = sources.find((source) => source.aborted);
+	if (alreadyAborted !== void 0) {
+		controller.abort(abortReason(alreadyAborted, "aborted by parent scope"));
+		return {
+			signal: controller.signal,
+			abort,
+			release
+		};
+	}
+	for (const source of sources) {
+		const onAbort = () => abort(abortReason(source, "aborted by parent scope"));
+		listeners.push({
+			source,
+			onAbort
+		});
+		source.addEventListener("abort", onAbort, { once: true });
+	}
+	return {
+		signal: controller.signal,
+		abort,
+		release
+	};
+}
+/**
+* Settle `act()` against `signal`. The first outcome wins and the listener is always
+* removed, so neither a late resolution nor a late abort can settle the promise twice.
+* The losing promise stays observed, so a late rejection cannot surface as an unhandled
+* process error.
+*
+* The abort rejection is deferred one microtask so a result the action had ALREADY
+* produced still wins. It does not hand the race to a listener the action registers
+* from inside `act()`: this function subscribes before it calls `act()`, so its own
+* abort handler runs first and settles the promise. A caller that must let the action
+* observe the abort itself has to hold a live promise and await that instead.
+*
+* A synchronous throw from `act()` propagates as the rejection, not as an abort.
+*/
+async function runAbortable(act, signal, fallback) {
+	if (signal.aborted) throw abortError(signal, fallback);
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		const cleanup = () => signal.removeEventListener("abort", onAbort);
+		const onAbort = () => {
+			queueMicrotask(() => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				reject(abortError(signal, fallback));
+			});
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		let work;
+		try {
+			work = Promise.resolve(act());
+		} catch (error) {
+			cleanup();
+			reject(error);
+			return;
+		}
+		work.then((value) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(value);
+		}, (error) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(error);
+		});
+	});
+}
+//#endregion
 //#region src/runtime/tangle-sandbox-exact-process-provider.ts
 const exactProcessProviderMarker = "agent-runtime.exact-process-provider";
 const exactProcessEgressMarker = "agent-runtime.exact-process-egress";
@@ -483,32 +609,96 @@ function providerAsExecutor(provider, options = {}) {
 	return (spec, ctx) => createProviderExecutor(provider, spec.profile, ctx, options);
 }
 function createProviderExecutor(provider, profile, ctx, options) {
-	const controller = new AbortController();
-	const abortIfSignalled = () => {
-		if (ctx.signal.aborted) controller.abort();
-	};
-	abortIfSignalled();
-	if (!ctx.signal.aborted) ctx.signal.addEventListener("abort", abortIfSignalled, { once: true });
+	const controller = linkAbort(ctx.signal);
 	let environment;
 	let artifact;
-	return {
-		runtime: options.runtime ?? provider.name,
+	const runtime = options.runtime ?? provider.name;
+	const createProfile = options.profileForCreate?.(profile) ?? profile;
+	const executionId = ctx.node?.nodeId ?? `provider-run-${randomUUID()}`;
+	const attemptId = ctx.node?.attemptId ?? newExecutionAttemptId(executionId);
+	const providerModel = concreteProfileModel(createProfile);
+	const tokenLimits = enforceTokenLimits(profileModelExecutionSettings(createProfile, `providerAsExecutor(${provider.name})`).tokenLimits, "provider", `providerAsExecutor(${provider.name})`);
+	const plannedDeclaration = {
+		effectiveProfile: createProfile,
+		backend: provider.name,
+		model: providerModel ? {
+			status: "known",
+			id: providerModel
+		} : {
+			status: "unknown",
+			reason: "provider environment selected its default model"
+		},
+		execution: {
+			kind: "environment",
+			id: executionId
+		},
+		materializer: "environment-provider-create",
+		plan: {
+			kind: "agent-environment",
+			provider: provider.name,
+			destroyOnSettle: options.destroyOnSettle ?? true,
+			requireTerminalEvent: options.requireTerminalEvent ?? true,
+			tokenLimits,
+			environmentId: null
+		}
+	};
+	const plannedBinding = {
+		attemptId,
+		binding: {
+			provider: provider.name,
+			executionId,
+			model: providerModel ?? null
+		},
+		descriptor: {
+			kind: "agent-environment",
+			transport: "provider",
+			backend: provider.name
+		}
+	};
+	let executor;
+	executor = {
+		runtime,
 		execute(task, signal) {
 			return streamProviderExecutor({
 				provider,
 				profile,
+				createProfile,
 				task,
 				signal,
 				controller,
 				options,
 				onEnvironment: (env) => {
 					environment = env;
+					finalizeRuntimeOwnedPendingExecutor(executor, {
+						...plannedDeclaration,
+						execution: {
+							kind: "environment",
+							id: env.id
+						},
+						plan: {
+							...plannedDeclaration.plan,
+							environmentId: env.id
+						}
+					}, plannedBinding);
 				},
 				onArtifact: (next) => {
 					artifact = next;
 				}
 			});
 		},
+		async cancel(request) {
+			controller.abort();
+			return {
+				status: "unknown",
+				effect: "cancel_requested",
+				observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				detail: `providerAsExecutor(${provider.name}): the streamed turn carries no durable run reference, so the provider acknowledged nothing`,
+				evidence: {
+					operationId: request.operationId,
+					...environment ? { environmentId: environment.id } : {}
+				}
+			};
+		},
 		async teardown(_grace) {
 			controller.abort();
 			await environment?.destroy?.();
@@ -519,14 +709,14 @@ function createProviderExecutor(provider, profile, ctx, options) {
 			return artifact;
 		}
 	};
+	return attestRuntimeOwnedPendingExecutor(executor, runtime, plannedDeclaration, plannedBinding);
 }
 async function* streamProviderExecutor(args) {
 	const started = Date.now();
-	const linked = mergeAbortSignals(args.signal, args.controller.signal);
-	const createProfile = args.options.profileForCreate?.(args.profile) ?? args.profile;
+	const linked = linkAbort(args.signal, args.controller.signal).signal;
 	const environment = await args.provider.create({
 		...args.options.defaults ?? {},
-		profile: createProfile,
+		profile: args.createProfile,
 		signal: linked
 	});
 	args.onEnvironment(environment);
@@ -537,12 +727,17 @@ async function* streamProviderExecutor(args) {
 	let text = "";
 	let terminal = false;
 	try {
+		const toolParts = createSandboxToolPartState();
 		for await (const event of environment.stream({
 			...turn,
 			signal: linked
 		})) {
 			events.push(event);
 			text += textFromEnvironmentEvent(event);
+			for (const progress of sandboxProgressEvents(sandboxEventFromEnvironmentEvent(event), toolParts)) yield {
+				kind: "progress",
+				progress
+			};
 			const usage = usageFromEnvironmentEvent(event);
 			if (usage.input || usage.output) {
 				tokens.input += usage.input;
@@ -557,7 +752,9 @@ async function* streamProviderExecutor(args) {
 				usd += usage.usd;
 				yield {
 					kind: "cost",
-					usd: usage.usd
+					usdKnown: false,
+					usd: usage.usd,
+					provenance: "uncaptured"
 				};
 			}
 			if (isTerminalEnvironmentEvent(event)) terminal = true;
@@ -569,6 +766,7 @@ async function* streamProviderExecutor(args) {
 			iterations: 1,
 			tokens,
 			usd,
+			usdKnown: false,
 			ms: Date.now() - started
 		};
 		args.onArtifact({
@@ -1113,7 +1311,7 @@ function isTerminalEnvironmentEvent(event) {
 	return normalized?.type === "status" && (normalized.status === "completed" || normalized.status === "failed");
 }
 function isTerminalEventShape(type, data) {
-	if (type === "result" || type === "done" || type === "final") return true;
+	if (isSandboxTerminalEvent(type)) return true;
 	if (type.endsWith(".completed") || type.endsWith(".failed")) return true;
 	if (type !== "status") return false;
 	return data.status === "completed" || data.status === "failed" || data.status === "cancelled";
@@ -1121,8 +1319,9 @@ function isTerminalEventShape(type, data) {
 function isUsageType(type) {
 	return type === "llm_call" || type === "usage" || type === "cost.usage";
 }
+/** A terminal event whose usage rides `data.usage` — the nested shape this transport unwraps. */
 function isNestedUsageType(type) {
-	return type === "message.completed" || type === "result" || type === "final";
+	return isSandboxTerminalEvent(type) && sandboxTerminalUsageField(type) === "usage";
 }
 function usageFromEnvironmentEvent(event) {
 	const usage = event.usage ?? tokenUsageFromData(event.data);
@@ -1330,21 +1529,6 @@ function defaultTangleSandboxCapabilities(options) {
 		confidential: true
 	};
 }
-function mergeAbortSignals(a, b) {
-	const controller = new AbortController();
-	const reasonOf = (signal) => {
-		const reason = signal.reason;
-		if (typeof reason === "string" && reason.length > 0) return reason;
-		if (reason instanceof Error && reason.name !== "AbortError" && reason.message.length > 0) return reason.message;
-		return "aborted by parent scope";
-	};
-	if (a.aborted || b.aborted) controller.abort(reasonOf(a.aborted ? a : b));
-	else {
-		a.addEventListener("abort", () => controller.abort(reasonOf(a)), { once: true });
-		b.addEventListener("abort", () => controller.abort(reasonOf(b)), { once: true });
-	}
-	return controller.signal;
-}
 function contentRef(prefix, value) {
 	let str;
 	try {
@@ -1381,6 +1565,6 @@ function hasExec(box) {
 	return typeof box.exec === "function";
 }
 //#endregion
-export { sandboxClientAsProvider as a, resolveAgentEnvironmentProvider as i, providerAsExecutor as n, createTangleSandboxExactProcessProvider as o, providerAsSandboxClient as r, createAgentEnvironmentProviderRegistry as t };
+export { sandboxClientAsProvider as a, linkAbort as c, resolveAgentEnvironmentProvider as i, runAbortable as l, providerAsExecutor as n, createTangleSandboxExactProcessProvider as o, providerAsSandboxClient as r, abortError as s, createAgentEnvironmentProviderRegistry as t };
 
-//# sourceMappingURL=environment-provider-DCBJ13VP.js.map
+//# sourceMappingURL=environment-provider-3eCszBEm.js.map