@tangle-network/agent-runtime 0.193.1 → 0.195.0

package/dist/{environment-provider-DEwsolvi.js → environment-provider-Dr-wfnHg.js}

@@ -1,6 +1,4 @@
-import { I as awaitAbortable, J as sameControlCoordinates, X as promptFromAgentTurnInput, Z as promptOptionsFromAgentTurnInput, o as finalizeRuntimeOwnedPendingExecutor, r as attestRuntimeOwnedPendingExecutor, u as newExecutionAttemptId } from "./materialization-CekWK6OO.js";
-import { n as detachedSnapshot } from "./snapshot-CTAf4uuA.js";
-import { x as zeroTokenUsage } from "./util-mCNUeboW.js";
+import { $ as promptOptionsFromAgentTurnInput, D as detachedSnapshot, Q as promptFromAgentTurnInput, R as awaitAbortable, X as sameControlCoordinates, o as finalizeRuntimeOwnedPendingExecutor, r as attestRuntimeOwnedPendingExecutor, u as newExecutionAttemptId } from "./materialization-vZssF9Nx.js";
 import { d as sandboxProgressEvents, f as sandboxTerminalUsageField, n as canonicalStreamEventFromSandboxEvent, o as isSandboxTerminalEvent, r as createSandboxToolPartState } from "./sandbox-events-DWeQRWxg.js";
 import { a as concreteProfileModel, c as profileModelExecutionSettings, o as enforceTokenLimits } from "./model-policy-Wf2MxXJ9.js";
 import { AgentExactRunControlRefSchema, AgentInteractiveSessionRefSchema, AgentInteractiveSessionStartSchema, AgentRunCancellationRequestSchema, WorkspaceRequestSchema, agentInteractiveSessionRefMatchesStart, canonicalCandidateDigest, canonicalWorkspaceCwd, harnessSystemPromptIntents, workspaceCwdPathForBase } from "@tangle-network/agent-interface";
@@ -33,7 +31,7 @@ function abortReason(signal, fallback) {
 	return fallback;
 }
 /** An `AbortError` carrying the signal's own string reason, or `fallback` when it states none. */
-function abortError(signal, fallback) {
+function abortError$1(signal, fallback) {
 	const reason = abortReason(signal, fallback);
 	const error = new Error(typeof reason === "string" && reason.length > 0 ? reason : fallback);
 	error.name = "AbortError";
@@ -95,7 +93,7 @@ function linkAbort(...sources) {
 * 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);
+	if (signal.aborted) throw abortError$1(signal, fallback);
 	return await new Promise((resolve, reject) => {
 		let settled = false;
 		const cleanup = () => signal.removeEventListener("abort", onAbort);
@@ -104,7 +102,7 @@ async function runAbortable(act, signal, fallback) {
 				if (settled) return;
 				settled = true;
 				cleanup();
-				reject(abortError(signal, fallback));
+				reject(abortError$1(signal, fallback));
 			});
 		};
 		signal.addEventListener("abort", onAbort, { once: true });
@@ -130,6 +128,422 @@ async function runAbortable(act, signal, fallback) {
 	});
 }
 //#endregion
+//#region src/runtime/util.ts
+/**
+* Best-effort sandbox delete. Skips instances without a `delete` (test fakes);
+* swallows errors (the platform reaps on expiry). Returns `false` when delete
+* threw, `true` otherwise, so callers can surface a leak if they choose.
+*/
+async function deleteBoxSafe(box) {
+	if (!box || typeof box.delete !== "function") return true;
+	try {
+		await box.delete();
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Short base36 id for trace correlation. Not cryptographic, not collision-free. */
+function randomSuffix(len = 8) {
+	return Math.random().toString(36).slice(2, 2 + len);
+}
+/** Collision-resistant id for sandbox naming (find-by-name recovery must be unique). */
+function randomUuid() {
+	return crypto.randomUUID();
+}
+/** Construct an AbortError. Downstream code pattern-matches on `err.name`. */
+function abortError() {
+	const err = /* @__PURE__ */ new Error("aborted");
+	err.name = "AbortError";
+	return err;
+}
+/** Throw an AbortError. */
+function throwAbort() {
+	throw abortError();
+}
+/** Throw if the signal is already aborted; otherwise no-op. */
+function throwIfAborted$1(signal) {
+	if (signal?.aborted) throw abortError();
+}
+/** True for any error whose `name` is `AbortError` (the cross-kernel abort contract). */
+function isAbortError(err) {
+	return err instanceof Error && err.name === "AbortError";
+}
+/**
+* Sleep that resolves early on abort and always clears its timer so it never
+* keeps the event loop alive. Resolves (does not reject) on abort — callers
+* re-check the signal explicitly after the sleep.
+*/
+function sleep(ms, signal) {
+	return new Promise((resolve) => {
+		if (signal?.aborted) {
+			resolve();
+			return;
+		}
+		let onAbort;
+		const timer = setTimeout(() => {
+			if (onAbort && signal) signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		if (signal) {
+			onAbort = () => {
+				clearTimeout(timer);
+				resolve();
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+		}
+	});
+}
+/**
+* Race a promise against a timeout. Resolves with the value if it settles in
+* time, otherwise resolves with `undefined`. Always clears the timer.
+*/
+function withTimeout(promise, ms) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => resolve(void 0), ms);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, () => {
+			clearTimeout(timer);
+			resolve(void 0);
+		});
+	});
+}
+/**
+* `JSON.stringify` with a `String()` fallback on throw (cyclic / non-JSON).
+* Strings pass through unstringified so a preview of a string output is the
+* string itself, not a quoted re-encoding.
+*/
+function stringifySafe(value, opts = {}) {
+	let s;
+	try {
+		if (typeof value === "string") s = value;
+		else s = (opts.pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value)) ?? String(value);
+	} catch {
+		s = String(value);
+	}
+	if (opts.max !== void 0 && s.length > opts.max) return `${s.slice(0, opts.max)}…`;
+	return s;
+}
+/** A fresh zero token-usage accumulator. */
+function zeroTokenUsage() {
+	return {
+		input: 0,
+		output: 0
+	};
+}
+/**
+* Sum the catalog-priced part of a dollar total across spends, as a field to spread.
+*
+* Returns nothing when no input carried one. A fold of pure provider receipts must not gain a
+* `usdEstimated: 0`, which would read as "this runtime checked and priced none" on a path that
+* never prices at all.
+*/
+function usdEstimatedOf(...spends) {
+	let total = 0;
+	let priced = false;
+	for (const spend of spends) {
+		if (spend.usdEstimated === void 0) continue;
+		priced = true;
+		total += spend.usdEstimated;
+	}
+	return priced ? { usdEstimated: total } : {};
+}
+/** A conserved spend with every channel at zero and no completeness claim on it. */
+function zeroSpend() {
+	return {
+		iterations: 0,
+		tokens: zeroTokenUsage(),
+		usd: 0,
+		ms: 0
+	};
+}
+/**
+* The spend of work that HAPPENED and reported no usage receipt.
+*
+* Not the same value as {@link zeroSpend} even though both carry `{0,0}` tokens and `$0`. A bare
+* zero asserts a MEASUREMENT — "this ran and cost nothing" — and every consumer downstream reads it
+* that way: the pool keeps reporting `readout().tokensKnown === true`, the journal totals stay
+* clean, the OTEL span records a priced zero, and a caller's token-denominated ceiling can never
+* fire no matter how much the work really burned. A ceiling that cannot fire is worse than no
+* ceiling, because it reads as protection.
+*
+* `tokensKnown` is the marker the substrate already threads end to end for exactly this case
+* (`budget.ts`, `otel-spans.ts`, `spawn-journal.ts`, `supervisor.ts`): the work is recorded, the
+* zero is labelled a floor rather than a total, and every rollup that touches it reports its
+* balance as a ceiling rather than a measurement. Use this — never a bare zero — whenever a runtime
+* cannot see what its worker spent.
+*
+* The same rule applies to dollars. A dollar-capped run must refuse an executor whose billed spend
+* is unknowable; `budgetExempt` does not authorize Runtime to relabel unknown spend as a measured
+* zero. Callers that require dollar accounting must use a backend with a trusted billing receipt.
+*/
+function unmeteredSpend(ms) {
+	return {
+		iterations: 0,
+		tokens: zeroTokenUsage(),
+		tokensKnown: false,
+		usd: 0,
+		usdKnown: false,
+		ms
+	};
+}
+/** Copy a conserved spend without dropping a completeness marker or the catalog-priced part. */
+function cloneSpend(spend) {
+	return {
+		iterations: spend.iterations,
+		tokens: cloneTokenUsage(spend.tokens),
+		...spend.tokensKnown === false ? { tokensKnown: false } : {},
+		usd: spend.usd,
+		...spend.usdKnown === false ? { usdKnown: false } : {},
+		...spend.usdEstimated !== void 0 ? { usdEstimated: spend.usdEstimated } : {},
+		ms: spend.ms,
+		...boxMinutesOf(spend)
+	};
+}
+/**
+* Sum two conserved spends per channel. Tokens and dollars never fold into each other, an
+* incomplete input keeps the sum incomplete on that channel, and the catalog-priced part of the
+* dollar total is summed separately so `usd - usdEstimated` still names what a provider billed.
+*/
+function addSpend(a, b) {
+	const tokens = cloneTokenUsage(a.tokens);
+	addTokenUsage(tokens, b.tokens);
+	return {
+		iterations: a.iterations + b.iterations,
+		tokens,
+		...a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {},
+		usd: a.usd + b.usd,
+		...a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {},
+		...usdEstimatedOf(a, b),
+		ms: a.ms + b.ms,
+		...boxMinutesOf(a, b),
+		...tokensProvenanceOf(a, b)
+	};
+}
+/**
+* Fold the token-provenance channel across spends, as a field to spread.
+*
+* Returns nothing when no contributor stated one, because ABSENT already means "the executor's own
+* live stream", which is what every path reported before a harness store was readable. A
+* contributor that stated one and a contributor that did not therefore disagree, and the sum is
+* `'mixed'` — the honest answer for a tree whose spend came from two kinds of receipt.
+*/
+function tokensProvenanceOf(...spends) {
+	let folded;
+	let sawStated = false;
+	for (const spend of spends) {
+		const stated = spend.tokensProvenance ?? "stream-receipt";
+		if (spend.tokensProvenance !== void 0) sawStated = true;
+		folded = folded === void 0 || folded === stated ? stated : "mixed";
+	}
+	return !sawStated || folded === void 0 || folded === "stream-receipt" ? {} : { tokensProvenance: folded };
+}
+/**
+* Fold the platform box-time channel across spends, as a field to spread.
+*
+* Returns nothing when no input carried the channel, so a fold over router or cli-bridge work —
+* which runs no box at all — never gains a `boxMinutesProvenance: 'uncaptured'` that would claim
+* a box ran and went unmetered.
+*
+* Three rules, one per field:
+*  - `boxMinutes` sums the numbers that are present, and stays ABSENT when none is. A missing
+*    measurement never enters the sum as a zero.
+*  - `boxMinutesKnown` is sticky-false, like `tokensKnown`: one contributor that could not state
+*    its box time makes the whole sum a floor.
+*  - `boxMinutesProvenance` degrades. `'observed'` survives only when every contributor that
+*    carried a number was observed; one derived number makes the sum `'estimated'`; no number at
+*    all is `'uncaptured'`.
+*/
+function boxMinutesOf(...spends) {
+	const present = spends.filter((spend) => spend.boxMinutesProvenance !== void 0);
+	if (present.length === 0) return {};
+	let minutes = 0;
+	let sawNumber = false;
+	let known = true;
+	let observedOnly = true;
+	for (const spend of present) {
+		if (typeof spend.boxMinutes === "number" && Number.isFinite(spend.boxMinutes)) {
+			minutes += spend.boxMinutes;
+			sawNumber = true;
+			if (spend.boxMinutesProvenance !== "observed") observedOnly = false;
+		}
+		if (spend.boxMinutesKnown !== true) known = false;
+	}
+	return {
+		...sawNumber ? { boxMinutes: roundBoxMinutes(minutes) } : {},
+		boxMinutesKnown: known,
+		boxMinutesProvenance: sawNumber ? observedOnly ? "observed" : "estimated" : "uncaptured"
+	};
+}
+/**
+* Box minutes at four decimals — a tenth of a second.
+*
+* Fine enough that a box alive for two seconds reports `0.0333` instead of a zero that would read
+* as a measured free box, and coarse enough that summing floats does not print
+* `1.5000000000000002`.
+*/
+function roundBoxMinutes(minutes) {
+	return Number(minutes.toFixed(4));
+}
+/** Copy a token subtotal without dropping optional provider cache telemetry. */
+function cloneTokenUsage(usage) {
+	const cacheBreakdownUnknown = usage.cacheBreakdownKnown === false || usage.input > 0 && !hasClassifiedCacheBreakdown(usage);
+	return {
+		input: usage.input,
+		output: usage.output,
+		...usage.tokensKnown === false ? { tokensKnown: false } : {},
+		...usage.freshInput !== void 0 ? { freshInput: usage.freshInput } : {},
+		...usage.cacheRead !== void 0 ? { cacheRead: usage.cacheRead } : {},
+		...usage.cacheWrite !== void 0 ? { cacheWrite: usage.cacheWrite } : {},
+		...cacheBreakdownUnknown ? { cacheBreakdownKnown: false } : {}
+	};
+}
+/** True only when every positive prompt token has a consistent cache classification. */
+function hasCompleteCacheBreakdown(usage) {
+	if (usage.cacheBreakdownKnown === false) return false;
+	return hasClassifiedCacheBreakdown(usage);
+}
+function hasClassifiedCacheBreakdown(usage) {
+	if (usage.input === 0) return true;
+	if (usage.freshInput === void 0 || usage.cacheRead === void 0 || usage.cacheWrite === void 0) return false;
+	return usage.freshInput + usage.cacheRead + usage.cacheWrite === usage.input;
+}
+/**
+* The token charge for one observation: every token counted ONCE, at the moment it first enters
+* the context — `input − cacheRead + output`.
+*
+* `input` is a rolled-up prompt total that re-counts a cached prefix on every turn that reads it,
+* so charging `input` makes a 100K prefix read 40 times cost 4.1M for content authored once. A
+* cache read is content that was already charged when it was written, so it is the one class the
+* charge subtracts. Under a complete split the result is exactly `freshInput + cacheWrite`. No
+* price weight is involved: this counts work, and money is a separate channel.
+*
+* The subtraction form is what makes the charge ADDITIVE. `input` and `cacheRead` both accumulate
+* through `addTokenUsage`, so the charge on an aggregate equals the sum of the charges on the
+* records that built it — including an aggregate that mixes classified and unclassified turns,
+* where the unclassified remainder is charged in full and only the reported cache reads are
+* credited. A form that read `freshInput + cacheWrite` directly loses that: one unclassified turn
+* would drop the whole aggregate to `input + output` and over-charge every classified turn with it.
+*
+* The one arithmetic guarantee: a set of classes that does not FIT inside the prompt total it
+* partitions credits nothing, so the charge is never below `output` and a class that overflows its
+* own total buys no tokens. It is not a guarantee against a provider that reports a cache read it
+* never served — that provider can under-report `input` just as easily, and the token channel is an
+* accounting unit, not a trust boundary. Prompt tokens the provider left unclassified are charged
+* in full, so a spend with no readable split charges an upper bound on newly-presented work rather
+* than a measurement, and every caller that enforces a ceiling must report the difference
+* (`BudgetPool` does it through `readout().cacheBreakdownKnown`).
+*/
+function chargedTokens(usage) {
+	return usage.input - creditedCacheRead(usage) + usage.output;
+}
+/** `cacheRead` if the reported classes fit inside `input`, else nothing. */
+function creditedCacheRead(usage) {
+	const { cacheRead } = usage;
+	if (cacheRead === void 0) return 0;
+	return classifiedTotal(usage, cacheRead) > usage.input ? 0 : cacheRead;
+}
+function classifiedTotal(usage, cacheRead) {
+	return (usage.freshInput ?? 0) + cacheRead + (usage.cacheWrite ?? 0);
+}
+/**
+* Translate one provider prompt-cache report into the prompt token classes `addTokenUsage` folds
+* and `chargedTokens` credits.
+*
+* The input is the open `promptCache` record an `llm_call` carries, keyed by the `PromptCacheUsage`
+* vocabulary (`readTokens`, `writeTokens`). Providers report that vocabulary unevenly, and the
+* three outcomes are different facts that must not collapse into one another:
+*
+*  - **Nothing reported** — no classes and no marker. The caller's own unknown handling decides,
+*    because a provider that says nothing about caching has not said the split is unknowable.
+*  - **Read and write both reported, and fitting inside `input`** — a complete partition, so
+*    `freshInput` is the remainder and the split is known.
+*  - **One counter reported, or classes that overflow `input`** — the counters that ARE measured
+*    pass through and `cacheBreakdownKnown` is false. A read with no write counter (OpenAI reports
+*    no write) still credits the read it measured, while declaring the rest unclassified so the
+*    charge stays a declared upper bound. An overflowing claim buys nothing: it cannot be a
+*    partition of a total it exceeds.
+*
+* A counter the provider did not report stays absent. A zero would claim the provider measured no
+* cache, which is a different fact from a provider that did not report.
+*/
+function promptCacheTokenClasses(input, promptCache) {
+	if (promptCache === void 0) return {};
+	const read = tokenCount(promptCache.readTokens);
+	const write = tokenCount(promptCache.writeTokens);
+	if (read === void 0 && write === void 0) return {};
+	if (input === void 0 || (read ?? 0) + (write ?? 0) > input) return { cacheBreakdownKnown: false };
+	if (read !== void 0 && write !== void 0) return {
+		freshInput: input - read - write,
+		cacheRead: read,
+		cacheWrite: write
+	};
+	return {
+		...read !== void 0 ? { cacheRead: read } : {},
+		...write !== void 0 ? { cacheWrite: write } : {},
+		cacheBreakdownKnown: false
+	};
+}
+function tokenCount(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+/**
+* Add the observed subtotal into `acc`; token and cache incompleteness are sticky.
+*
+* A delta whose classes do not FIT inside its own `input` contributes its prompt total and NO
+* classes. Folding them in would hide the overflow: the accumulator's larger `input` can absorb a
+* class total that overflowed the one delta that reported it, and `chargedTokens` would then credit
+* at the aggregate a cache read it refuses at the record. That is the one way the charge could come
+* out below the sum of the charges on the records that built it.
+*/
+function addTokenUsage(acc, delta) {
+	acc.input += delta.input ?? 0;
+	acc.output += delta.output ?? 0;
+	if (delta.tokensKnown === false) acc.tokensKnown = false;
+	const input = delta.input ?? 0;
+	const fits = classifiedTotal(delta, delta.cacheRead ?? 0) <= input;
+	if (fits) {
+		if (delta.freshInput !== void 0) acc.freshInput = (acc.freshInput ?? 0) + delta.freshInput;
+		if (delta.cacheRead !== void 0) acc.cacheRead = (acc.cacheRead ?? 0) + delta.cacheRead;
+		if (delta.cacheWrite !== void 0) acc.cacheWrite = (acc.cacheWrite ?? 0) + delta.cacheWrite;
+	}
+	const classified = fits && delta.freshInput !== void 0 && delta.cacheRead !== void 0 && delta.cacheWrite !== void 0 && delta.freshInput + delta.cacheRead + delta.cacheWrite === input;
+	if (delta.cacheBreakdownKnown === false || input > 0 && !classified) acc.cacheBreakdownKnown = false;
+}
+/**
+* Map `items` through `fn` with at most `limit` calls in flight at once,
+* preserving input order in the result. On the first `fn` rejection no NEW
+* items are picked up; already-in-flight calls are awaited, then the first
+* error is rethrown. `limit` is clamped to ≥ 1.
+*
+* Used where a burst of provisioning (e.g. forking N child boxes) must respect
+* the loop's concurrency bound instead of firing all N at once.
+*/
+async function mapWithConcurrency(items, limit, fn) {
+	const bound = Math.max(1, Math.floor(limit));
+	const results = new Array(items.length);
+	let next = 0;
+	let failed = false;
+	const worker = async () => {
+		while (!failed) {
+			const i = next;
+			next += 1;
+			if (i >= items.length) return;
+			try {
+				results[i] = await fn(items[i], i);
+			} catch (err) {
+				failed = true;
+				throw err;
+			}
+		}
+	};
+	const workerCount = Math.min(bound, items.length);
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+	return results;
+}
+//#endregion
 //#region src/runtime/tangle-sandbox-exact-process-provider.ts
 const exactProcessProviderMarker = "agent-runtime.exact-process-provider";
 const exactProcessEgressMarker = "agent-runtime.exact-process-egress";
@@ -1764,6 +2178,6 @@ function hasExec(box) {
 	return typeof box.exec === "function";
 }
 //#endregion
-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 };
+export { runAbortable as A, throwIfAborted$1 as C, zeroTokenUsage as D, zeroSpend as E, abortError$1 as O, throwAbort as S, withTimeout as T, randomSuffix as _, sandboxClientAsProvider as a, sleep as b, addTokenUsage as c, cloneTokenUsage as d, deleteBoxSafe as f, promptCacheTokenClasses as g, mapWithConcurrency as h, resolveAgentEnvironmentProvider as i, linkAbort as k, chargedTokens as l, isAbortError as m, providerAsExecutor as n, createTangleSandboxExactProcessProvider as o, hasCompleteCacheBreakdown as p, providerAsSandboxClient as r, addSpend as s, createAgentEnvironmentProviderRegistry as t, cloneSpend as u, randomUuid as v, unmeteredSpend as w, stringifySafe as x, roundBoxMinutes as y };
 
-//# sourceMappingURL=environment-provider-DEwsolvi.js.map
+//# sourceMappingURL=environment-provider-Dr-wfnHg.js.map