@tangle-network/agent-runtime 0.199.0 → 0.201.0

package/dist/sandbox-events-DbC2WKKS.js

@@ -1,929 +0,0 @@
-import { m as ValidationError } from "./errors-DodWX-cb.js";
-import { CanonicalStreamEventSchema, RuntimeEventEnvelopeSchema } from "@tangle-network/agent-interface";
-//#region src/runtime/harness-usage.ts
-/**
-* Read and validate one codex `turn.completed` usage record.
-*
-* Every counter must be a non-negative safe integer. Two cross-field invariants hold, and they are
-* what states that the two named counters are SUBSETS of their totals rather than additions to
-* them: `cached_input_tokens <= input_tokens` and `reasoning_output_tokens <= output_tokens`.
-* Measured against the codex CLI: a turn reporting `output_tokens 1523` with
-* `reasoning_output_tokens 1516` answered with about seven tokens of text.
-*
-* `label` names the surface the record came from, so one message serves both readers.
-* Throws `ValidationError` on any violation.
-*/
-function parseCodexUsageRecord(usage, label) {
-	const record = plainRecord$1(usage);
-	if (record === void 0) throw new ValidationError(`${label}: usage must be an object, received ${describe(usage)}`);
-	const inputTokens = naturalNumber(record.input_tokens, "input_tokens", label);
-	const cachedInputTokens = naturalNumber(record.cached_input_tokens, "cached_input_tokens", label);
-	const outputTokens = naturalNumber(record.output_tokens, "output_tokens", label);
-	const reasoningOutputTokens = naturalNumber(record.reasoning_output_tokens, "reasoning_output_tokens", label);
-	const cacheWriteInputTokens = record.cache_write_input_tokens === void 0 ? void 0 : naturalNumber(record.cache_write_input_tokens, "cache_write_input_tokens", label);
-	if (cachedInputTokens > inputTokens) throw new ValidationError(`${label}: cached_input_tokens exceeds input_tokens`);
-	if (reasoningOutputTokens > outputTokens) throw new ValidationError(`${label}: reasoning_output_tokens exceeds output_tokens`);
-	return {
-		inputTokens,
-		cachedInputTokens,
-		outputTokens,
-		reasoningOutputTokens,
-		...cacheWriteInputTokens === void 0 ? {} : { cacheWriteInputTokens }
-	};
-}
-/** Names the wire record every codex decode error is reported against. */
-const codexUsageContext = "codex turn.completed";
-/**
-* codex reports the tokens of a turn inside its own `turn.completed` event, which rides the
-* transport as `{ type: 'raw', data: { type: 'turn.completed', usage: { … } } }`. It emits no
-* canonical usage event, so this adapter is a codex worker's only usage source.
-*
-* The record is read by `parseCodexUsageRecord`, the same reader `runLocalHarness` uses on the
-* codex CLI's own stdout, so both surfaces hold one field policy and both cross-field invariants.
-*
-* A `turn.completed` that carries a `usage` member the reader cannot read is a `ValidationError`
-* naming the field. A `turn.completed` with no `usage` member reports no usage at all, which
-* leaves the turn's tokens unknown rather than zero.
-*/
-const decodeCodexTurnUsage = (event) => {
-	if (String(event.type ?? "") !== "raw") return void 0;
-	const data = plainRecord$1(event.data);
-	if (data === void 0 || data.type !== "turn.completed" || data.usage === void 0) return;
-	const record = parseCodexUsageRecord(data.usage, codexUsageContext);
-	return {
-		harness: "codex",
-		input: record.inputTokens,
-		output: record.outputTokens,
-		cachedInput: record.cachedInputTokens,
-		reasoningOutput: record.reasoningOutputTokens,
-		...record.cacheWriteInputTokens === void 0 ? {} : { cacheWriteInput: record.cacheWriteInputTokens }
-	};
-};
-/**
-* The harness → usage-decoder registry. Add a harness by adding one entry.
-*
-* Keyed by `HarnessType`, the vocabulary the `harness` argument is drawn from, so a key no caller
-* can produce does not compile. A harness absent from this registry reports usage through the
-* canonical events or not at all.
-*/
-const harnessUsageDecoders = { codex: decodeCodexTurnUsage };
-/**
-* Decode a sandbox event with one harness's adapter, or `undefined` when the event carries no
-* harness-native usage.
-*
-* A NAMED harness reads with that harness's adapter only, and a named harness with no adapter
-* reports nothing. It never falls through to another harness's adapter: a different harness's
-* `turn.completed` decoded as codex would either drop the counters codex does not name or fail on
-* a field codex requires, and both answers would be about the wrong harness. The composite over
-* every registered adapter runs only when the caller cannot name the harness.
-*
-* Throws `ValidationError` when an adapter recognizes the event as its harness's usage carrier and
-* cannot read the numbers.
-*/
-function decodeHarnessUsage(event, harness) {
-	if (!event || typeof event !== "object") return void 0;
-	if (harness !== void 0) return harnessUsageDecoders[harness]?.(event);
-	for (const decode of new Set(Object.values(harnessUsageDecoders))) {
-		const usage = decode(event);
-		if (usage !== void 0) return usage;
-	}
-}
-function plainRecord$1(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function naturalNumber(value, field, label) {
-	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new ValidationError(`${label}: usage.${field} must be a non-negative safe integer, received ${describe(value)}`);
-	return value;
-}
-function describe(value) {
-	if (value === null) return "null";
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (typeof value === "string") return JSON.stringify(value);
-	if (Array.isArray(value)) return "an array";
-	return typeof value;
-}
-//#endregion
-//#region src/runtime/timestamps.ts
-const validTimestamp = "2026-01-01T00:00:00.000Z";
-/** Validate a timestamp with the public runtime envelope contract. */
-function assertRuntimeTimestamp(value, label) {
-	try {
-		RuntimeEventEnvelopeSchema.parse({
-			runId: "runtime",
-			eventId: "event",
-			sequence: 0,
-			occurredAt: value,
-			receivedAt: validTimestamp,
-			event: {
-				type: "status",
-				status: "processing"
-			}
-		});
-	} catch (error) {
-		throw new Error(`${label} must be a valid ISO timestamp`, { cause: error });
-	}
-}
-//#endregion
-//#region src/runtime/sandbox-transport-events.ts
-/**
-* Transport type whose payload is the harness's OWN event, passed through verbatim.
-*
-* A `raw` payload names a harness-native type from a vocabulary the canonical schema does not
-* define (codex emits `thread.started` / `turn.started` / `turn.completed`). The transport type is
-* therefore the only canonical statement such an event makes, and its payload must never be read
-* as a canonical type: the mismatch guard below exists to catch a producer that MISLABELS a
-* canonical event, which a harness-native payload cannot do. A payload that does satisfy the
-* canonical `raw` shape (`backend` + `event`) still parses; anything else is not a canonical
-* event, and the caller reads it off the transport event instead.
-*/
-const harnessNativePayloadType = "raw";
-/** Parse canonical payload fields without treating transport identity as event data. */
-function parseCanonicalTransportEvent(type, data, normalized, source) {
-	if (!isRecord(data)) throw new Error(`${source} emitted a canonical event without an object payload`);
-	const outerType = String(type ?? "");
-	const harnessNative = outerType === harnessNativePayloadType;
-	if (normalized !== void 0) {
-		if (!harnessNative && typeof normalized === "object" && normalized !== null && "type" in normalized && typeof normalized.type === "string" && normalized.type !== outerType) throw new Error(`${source} canonical event type "${normalized.type}" does not match transport type "${outerType}"`);
-		const candidate = CanonicalStreamEventSchema.safeParse(normalized);
-		if (!candidate.success) {
-			if (harnessNative) return void 0;
-			throw new Error(`${source} emitted an invalid normalized canonical event`, { cause: candidate.error });
-		}
-		return candidate.data;
-	}
-	const { type: embeddedType, eventId: _eventId, cursor: _cursor, sequence: _sequence, occurredAt: _occurredAt, normalized: _normalized, ...payload } = data;
-	if (!harnessNative && embeddedType !== void 0 && embeddedType !== outerType) throw new Error(`${source} canonical event type "${String(embeddedType)}" does not match transport type "${outerType}"`);
-	const candidate = CanonicalStreamEventSchema.safeParse({
-		...payload,
-		type: outerType
-	});
-	return candidate.success ? candidate.data : void 0;
-}
-/** Extract shared event identity without privileging one provider wire shape. */
-function extractTransportEventIdentity(event) {
-	const record = isRecord(event) ? event : {};
-	const data = isRecord(record.data) ? record.data : {};
-	const providerEvent = isRecord(record.providerEvent) ? record.providerEvent : {};
-	const providerData = isRecord(providerEvent.data) ? providerEvent.data : {};
-	const eventId = canonicalEventId(record, data, providerEvent, providerData);
-	const cursor = stableString(record.cursor ?? data.cursor ?? providerEvent.cursor ?? providerData.cursor);
-	const sequence = optionalSequence(record.sequence ?? data.sequence ?? providerEvent.sequence ?? providerData.sequence);
-	const occurredAt = optionalTimestamp(record.occurredAt ?? data.occurredAt ?? providerEvent.occurredAt ?? providerData.occurredAt);
-	return {
-		...eventId === void 0 ? {} : { eventId },
-		...cursor === void 0 ? {} : { cursor },
-		...sequence === void 0 ? {} : { sequence },
-		...occurredAt === void 0 ? {} : { occurredAt }
-	};
-}
-function canonicalEventId(record, data, providerEvent, providerData) {
-	const present = [
-		["data.eventId", data.eventId],
-		["providerEvent.eventId", providerEvent.eventId],
-		["providerData.eventId", providerData.eventId],
-		["record.eventId", record.eventId]
-	].filter(([, value]) => value !== void 0);
-	if (present.length === 0) return stableString(record.id ?? providerEvent.id);
-	const normalized = present.map(([source, value]) => {
-		const eventId = stableString(value);
-		if (eventId === void 0) throw new Error(`transport event ${source} must be a stable string`);
-		return {
-			source,
-			eventId
-		};
-	});
-	const first = normalized[0];
-	if (normalized.some((candidate) => candidate.eventId !== first.eventId)) throw new Error("transport event canonical identities disagree");
-	return first.eventId;
-}
-function stableString(value) {
-	return typeof value === "string" && value.length > 0 && value.trim() === value ? value : void 0;
-}
-function finiteNonNegativeInteger(value) {
-	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
-}
-function optionalSequence(value) {
-	if (value === void 0) return void 0;
-	if (finiteNonNegativeInteger(value) === void 0) throw new Error("transport event sequence must be a non-negative safe integer");
-	return value;
-}
-function optionalTimestamp(value) {
-	if (value === void 0) return void 0;
-	assertRuntimeTimestamp(value, "occurredAt");
-	return value;
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
-//#region src/runtime/sandbox-events.ts
-const CANONICAL_STREAM_EVENT_TYPES = /* @__PURE__ */ new Set([
-	"child-task",
-	"message.part.updated",
-	"tool-heartbeat",
-	"tool-slow",
-	"model-processing",
-	"status",
-	"warning",
-	"raw",
-	"session.updated",
-	"interaction",
-	"interaction.cancel",
-	"plan.submitted"
-]);
-/** Decode one known Agent Interface event from a Sandbox event. */
-function canonicalStreamEventFromSandboxEvent(event) {
-	if (!event || typeof event !== "object") return void 0;
-	const type = String(event.type ?? "");
-	const data = event.data && typeof event.data === "object" ? event.data : {};
-	const normalized = data.normalized;
-	if (normalized === void 0 && !CANONICAL_STREAM_EVENT_TYPES.has(type)) return void 0;
-	return parseCanonicalTransportEvent(type, data, normalized, "sandbox");
-}
-/**
-* Forward a sandbox event to an optional observer without letting observer
-* behavior affect the run. The observer receives a defensive copy, synchronous
-* throws are swallowed, and returned promises are deliberately not awaited.
-*/
-function notifySandboxEventObserver(event, observer, meta) {
-	if (!observer) return;
-	try {
-		const result = observer(cloneEventForObserver(event), meta);
-		if (result && typeof result.then === "function") result.then(void 0, () => {});
-	} catch {}
-}
-function cloneEventForObserver(event) {
-	try {
-		return structuredClone(event);
-	} catch {
-		return copyPlainSpine(event, /* @__PURE__ */ new WeakMap());
-	}
-}
-function copyPlainSpine(value, seen) {
-	if (value === null || typeof value !== "object") return value;
-	const existing = seen.get(value);
-	if (existing !== void 0) return existing;
-	if (Array.isArray(value)) {
-		const copy = [];
-		seen.set(value, copy);
-		for (const item of value) copy.push(copyPlainSpine(item, seen));
-		return copy;
-	}
-	const proto = Object.getPrototypeOf(value);
-	if (proto !== Object.prototype && proto !== null) return {};
-	const copy = {};
-	seen.set(value, copy);
-	for (const [key, child] of Object.entries(value)) copy[key] = copyPlainSpine(child, seen);
-	return copy;
-}
-/**
-* Read the served execution identity off one Sandbox event.
-*
-* The platform reports `effectiveBackend` on `execution.started` and again on the terminal
-* event (`@tangle-network/sandbox`, `EffectiveBackend`). Absence returns `undefined`
-* and must stay unknown — a request is not a receipt, so nothing here may be inferred from
-* what was asked for.
-*/
-function sandboxEventServedBackend(event) {
-	if (!event || typeof event !== "object") return void 0;
-	const served = plainRecord(plainRecord(event.data)?.effectiveBackend);
-	if (!served) return void 0;
-	const provider = firstString(served.provider);
-	const model = firstString(served.model);
-	const source = firstString(served.source);
-	if (provider === void 0 && model === void 0) return void 0;
-	return {
-		...provider !== void 0 ? { provider } : {},
-		...model !== void 0 ? { model } : {},
-		...source !== void 0 ? { source } : {}
-	};
-}
-/**
-* Fail the execution when the platform reports serving a model other than the exact one asked for.
-*
-* Measured motive (agent-runtime#892, live infrastructure 2026-08-17): 6 of 6 boxes whose profile
-* declared `zai-coding-plan/glm-5.2` reported
-* `{"provider":"openai-compat","model":"deepseek/deepseek-v4-flash","source":"environment"}`,
-* while the materialization receipt recorded the declared model as `status: "known"`. Sending
-* `backend.model` makes that substitution unlikely; only reading the report back makes it
-* detectable. A run that cannot say which model produced its evidence must not settle as one
-* that can.
-*
-* Silent when the platform reports no served model: unobserved stays unobserved.
-*/
-function assertSandboxServedModel(event, expected) {
-	const wanted = expected?.model?.trim();
-	if (!wanted) return;
-	const served = sandboxEventServedBackend(event);
-	if (served?.model === void 0) return;
-	if (sameModelId(served.model, wanted, [served.provider, expected?.provider])) return;
-	const attribution = [served.provider !== void 0 ? `provider ${JSON.stringify(served.provider)}` : void 0, served.source !== void 0 ? `source ${JSON.stringify(served.source)}` : void 0].filter((part) => part !== void 0);
-	const detail = attribution.length > 0 ? ` (${attribution.join(", ")})` : "";
-	throw new Error(`sandbox served model ${JSON.stringify(served.model)}${detail} instead of the exact profile model ${JSON.stringify(wanted)}`);
-}
-/**
-* Do two model ids name the same model, allowing for routing prefixes?
-*
-* Either side may spell the model bare (`glm-5.2`), provider-qualified
-* (`zai-coding-plan/glm-5.2`), or route-qualified, and the platform reports the provider in its
-* own field rather than always in the id. So the comparison drops any known provider prefix and
-* then accepts a `/`-boundary suffix match: a longer route to the SAME leaf model is a routing
-* difference, not a substitution.
-*
-* What it deliberately does NOT absorb is a different leaf: `glm-5.2` against `glm-5.3` stays a
-* mismatch, which is the substitution measured directly against the provider API (a request for
-* `glm-5.2` was served `glm-5.3`). A version suffix is the whole difference between two
-* instruments, so nothing here may treat it as noise.
-*/
-function sameModelId(served, wanted, providers) {
-	const a = stripProviderPrefix(served, providers);
-	const b = stripProviderPrefix(wanted, providers);
-	return a === b || a.endsWith(`/${b}`) || b.endsWith(`/${a}`);
-}
-function stripProviderPrefix(id, providers) {
-	let out = id.trim().toLowerCase();
-	for (const provider of providers) {
-		const prefix = provider?.trim().toLowerCase();
-		if (prefix && out.startsWith(`${prefix}/`)) out = out.slice(prefix.length + 1);
-	}
-	return out;
-}
-function firstString(...values) {
-	return values.find((value) => typeof value === "string" && value.length > 0);
-}
-const terminalTypes = /* @__PURE__ */ new Set([
-	"message.completed",
-	"result",
-	"final",
-	"done"
-]);
-/** True for an event type that ends a sandbox turn. */
-function isSandboxTerminalEvent(type) {
-	return terminalTypes.has(type);
-}
-/**
-* Which member of a terminal event's `data` carries its usage receipt.
-*
-* The one place the terminal types legitimately differ, stated rather than implied by two lists:
-* sandbox 0.4.0's `done` reports under `tokenUsage` with the cost at the top level, every other
-* terminal type reports under `usage`.
-*/
-function sandboxTerminalUsageField(type) {
-	return type === "done" ? "tokenUsage" : "usage";
-}
-/**
-* Extract a `RuntimeStreamEvent`-shaped `llm_call` from a sandbox event when
-* the event carries usage/cost data. Returns `undefined` for non-cost events
-* so the kernel can iterate the full stream without branching.
-*
-* Pure by contract: it never throws on a failed run. The terminal truth
-* boundary is the public Sandbox outcome tracker, applied after the complete
-* stream. Post-hoc readers — {@link sumSandboxUsage}, the
-* analyst trace store, the chat projection — must stay able to read a failed
-* turn's events, which is when reading them matters most.
-*
-* Canonical cost-carrying types observed in the wild:
-*   - `llm_call` — `data: { model, tokensIn, tokensOut, costUsd, ... }`
-*   - `message.completed` / `result` — `data: { usage: { inputTokens,
-*      outputTokens, totalCostUsd? } }`
-*   - `cost.usage` / `usage` — same shape under a dedicated type
-*
-* Numeric coercion is strict: `Number.isFinite` gates every accumulator write
-* so a sentinel `NaN` from a misbehaving backend cannot poison the ledger.
-*/
-function extractLlmCallEvent(event, agentRunName) {
-	if (!event || typeof event !== "object") return void 0;
-	const type = String(event.type ?? "");
-	const data = event.data && typeof event.data === "object" ? event.data : {};
-	if (type === "llm_call" || type === "cost.usage" || type === "usage") return buildLlmCall(data, agentRunName);
-	if (isSandboxTerminalEvent(type) && sandboxTerminalUsageField(type) === "usage") {
-		const usage = data.usage;
-		if (!usage || typeof usage !== "object") return void 0;
-		return buildLlmCall({
-			...usage,
-			model: data.model ?? usage.model,
-			...usage.costUsd === void 0 && data.costUsd !== void 0 ? { costUsd: data.costUsd } : {}
-		}, agentRunName);
-	}
-	if (type === "done") {
-		const usage = data.tokenUsage;
-		if (!usage || typeof usage !== "object") return void 0;
-		const out = pickFiniteNumber(usage, [
-			"outputTokens",
-			"completion_tokens",
-			"tokensOut"
-		]);
-		const reasoning = pickFiniteNumber(usage, ["reasoningTokens"]);
-		const mergedOut = out !== void 0 || reasoning !== void 0 ? (out ?? 0) + (reasoning ?? 0) : void 0;
-		const cache = readPromptCacheUsage(usage);
-		return buildLlmCall({
-			inputTokens: usage.inputTokens,
-			outputTokens: mergedOut,
-			totalCostUsd: data.totalCostUsd,
-			...data.costUsd === void 0 ? {} : { costUsd: data.costUsd },
-			model: data.model ?? usage.model,
-			...cache !== void 0 ? { promptCache: cache } : {}
-		}, agentRunName);
-	}
-}
-/** A {@link SandboxUsageLedger} for one worker. Pass the worker's harness to decode with that
-*  harness's adapter; omit it to try every registered adapter. */
-function createSandboxUsageLedger(harness) {
-	let held = [];
-	let sawCanonical = false;
-	return {
-		observe(event, agentRunName) {
-			const call = extractLlmCallEvent(event, agentRunName);
-			if (call) {
-				sawCanonical = true;
-				return call;
-			}
-			let usage;
-			try {
-				usage = decodeHarnessUsage(event, harness);
-			} catch (err) {
-				return {
-					type: "llm_call",
-					model: agentRunName,
-					tokensKnown: false,
-					usdKnown: false,
-					tokensUnknownReason: err instanceof Error ? err.message : String(err)
-				};
-			}
-			if (usage) held.push(usage);
-		},
-		settleTurn(agentRunName) {
-			const reports = held;
-			const canonical = sawCanonical;
-			held = [];
-			sawCanonical = false;
-			if (canonical || reports.length === 0) return void 0;
-			return harnessUsageLlmCall(reports, agentRunName);
-		}
-	};
-}
-/**
-* Fold harness-native usage reports into the canonical `llm_call` the accounting paths read.
-*
-* Every counter a `HarnessUsage` carries beside `input` and `output` CLASSIFIES one of those two
-* totals, so none of them is added to the total it describes:
-*
-*   - the prompt-cache counters classify `input` and ride `promptCache`, the convention the
-*     terminal `tokenUsage` branch above already follows and `promptCacheTokenClasses` folds,
-*     where `freshInput = input - cacheRead - cacheWrite`;
-*   - `reasoningOutput` classifies `output`. Codex counts its reasoning tokens INSIDE
-*     `output_tokens` — a turn reporting `output_tokens 1523` with `reasoning_output_tokens 1516`
-*     answered with about seven tokens of text — and `parseCodexUsageRecord` holds that as an
-*     invariant. The canonical `llm_call` carries no reasoning class, so the count is not
-*     forwarded to {@link buildLlmCall}, whose `reasoningTokens` input is for the sandbox
-*     `tokenUsage` record that reports reasoning BESIDE its output count.
-*
-* A counter no report carried stays absent, because a zero would claim the provider measured none.
-*/
-function harnessUsageLlmCall(reports, agentRunName) {
-	let inputTokens = 0;
-	let outputTokens = 0;
-	let readTokens;
-	let writeTokens;
-	for (const report of reports) {
-		inputTokens += report.input;
-		outputTokens += report.output;
-		if (report.cachedInput !== void 0) readTokens = (readTokens ?? 0) + report.cachedInput;
-		if (report.cacheWriteInput !== void 0) writeTokens = (writeTokens ?? 0) + report.cacheWriteInput;
-	}
-	const promptCache = {};
-	if (readTokens !== void 0) promptCache.readTokens = readTokens;
-	if (writeTokens !== void 0) promptCache.writeTokens = writeTokens;
-	return buildLlmCall({
-		inputTokens,
-		outputTokens,
-		...Object.keys(promptCache).length > 0 ? { promptCache } : {}
-	}, agentRunName);
-}
-/**
-* Sum the token usage + USD cost of a sandbox turn's events — the one honest way to meter an
-* `openSandboxRun` cell. Folds a {@link SandboxUsageLedger} over the stream, so it reads usage off
-* EVERY backend event shape — the canonical events plus a harness that reports usage only in its
-* own event — and a `runProfileMatrix` dispatch can report it to `ctx.cost`:
-*
-*     receipt: (turn) => {
-*       const u = sumSandboxUsage(turn.events)
-*       return { model, inputTokens: u.input, outputTokens: u.output,
-*         ...(u.tokensKnown === false ? { usageUnknown: true } : {}),
-*         ...(u.usdKnown !== false && u.costUsd > 0 ? { actualCostUsd: u.costUsd } : {}),
-*         ...(u.usdKnown === false ? { costUnknown: true } : {}),
-*         ...(u.estimatedCostUsd !== undefined ? { estimatedCostUsd: u.estimatedCostUsd } : {}) }
-*     }
-*
-* Without this a cell reads `{tokens:0, cost:0}` and the backend-integrity guard correctly aborts the
-* matrix as a stub. `agentRunName` is the fallback model label for cost-only events (default `'agent'`).
-*
-* Pure by contract, like the ledger it folds: it never throws. A harness receipt the ledger cannot
-* read leaves the result at `tokensKnown: false` with `tokensUnknownReason` carrying the decode
-* message — an unreadable receipt is a different fact from a turn that reported no usage, and a
-* post-hoc reader that threw would lose the whole failed turn it exists to report.
-*/
-function sumSandboxUsage(events, agentRunName = "agent") {
-	let input = 0;
-	let output = 0;
-	let costUsd = 0;
-	let estimatedCostUsd = 0;
-	let sawEstimate = false;
-	let sawCall = false;
-	let tokensKnown = true;
-	let usdKnown = true;
-	let unreadable;
-	const ledger = createSandboxUsageLedger();
-	const credit = (call) => {
-		sawCall = true;
-		input += call.tokensIn ?? 0;
-		output += call.tokensOut ?? 0;
-		costUsd += call.costUsd ?? 0;
-		if (call.tokensKnown === false) tokensKnown = false;
-		if (call.usdKnown === false) usdKnown = false;
-		unreadable ??= call.tokensUnknownReason;
-		if (call.estimatedCostUsd !== void 0) {
-			estimatedCostUsd += call.estimatedCostUsd;
-			sawEstimate = true;
-		}
-	};
-	for (const ev of events) {
-		const call = ledger.observe(ev, agentRunName);
-		if (call) credit(call);
-	}
-	const harnessCall = ledger.settleTurn(agentRunName);
-	if (harnessCall) credit(harnessCall);
-	return {
-		input,
-		output,
-		costUsd,
-		...sawCall && tokensKnown ? {} : { tokensKnown: false },
-		...sawCall && usdKnown ? {} : { usdKnown: false },
-		...sawEstimate ? { estimatedCostUsd } : {},
-		...unreadable === void 0 ? {} : { tokensUnknownReason: unreadable }
-	};
-}
-function buildLlmCall(data, agentRunName) {
-	const tokensIn = pickFiniteNumber(data, [
-		"tokensIn",
-		"inputTokens",
-		"prompt_tokens"
-	]);
-	const outputTokens = pickFiniteNumber(data, [
-		"tokensOut",
-		"outputTokens",
-		"completion_tokens"
-	]);
-	const reasoningTokens = pickFiniteNumber(data, ["reasoningTokens"]);
-	const tokensOut = outputTokens !== void 0 || reasoningTokens !== void 0 ? (outputTokens ?? 0) + (reasoningTokens ?? 0) : void 0;
-	const reportedCostUsd = pickFiniteNumber(data, [
-		"costUsd",
-		"totalCostUsd",
-		"cost_usd",
-		"cost"
-	]);
-	const explicitTokensKnown = data.tokensKnown ?? data.tokens_known;
-	const explicitCostKnown = data.costKnown ?? data.cost_known ?? data.usdKnown ?? data.usd_known;
-	const costProvenance = data.costProvenance ?? data.cost_provenance;
-	const explicitEstimate = pickFiniteNumber(data, ["estimatedCostUsd", "estimated_cost_usd"]);
-	const catalogEstimate = costProvenance === "catalog-estimate" ? explicitEstimate ?? reportedCostUsd : explicitEstimate;
-	const costUsd = costProvenance === "catalog-estimate" ? void 0 : reportedCostUsd;
-	const promptCache = readPromptCacheUsage(data);
-	const tokensKnown = explicitTokensKnown !== false && tokensIn !== void 0 && tokensOut !== void 0;
-	const usdKnown = explicitCostKnown !== false && costUsd !== void 0 && (costProvenance === void 0 || costProvenance === "provider-receipt" || costProvenance === "billing-receipt");
-	if (tokensIn === void 0 && tokensOut === void 0 && costUsd === void 0 && catalogEstimate === void 0 && promptCache === void 0 && explicitTokensKnown !== false && explicitCostKnown !== false) return;
-	const event = {
-		type: "llm_call",
-		model: typeof data.model === "string" && data.model.length > 0 ? data.model : agentRunName
-	};
-	if (tokensIn !== void 0) event.tokensIn = tokensIn;
-	if (tokensOut !== void 0) event.tokensOut = tokensOut;
-	if (!tokensKnown) event.tokensKnown = false;
-	if (costUsd !== void 0) event.costUsd = costUsd;
-	if (!usdKnown) event.usdKnown = false;
-	if (catalogEstimate !== void 0) event.estimatedCostUsd = catalogEstimate;
-	if (promptCache !== void 0) event.promptCache = promptCache;
-	return event;
-}
-/**
-* Every wire spelling of a prompt-cache READ counter, in precedence order: the canonical name
-* first, then the spellings observed on the paths that reach this extractor — the sandbox terminal
-* `tokenUsage` record, the cli-bridge OpenAI-compatible usage object (which normalizes every
-* backend to Anthropic's `cache_read_input_tokens`), Anthropic verbatim, OpenAI's
-* `prompt_tokens_details.cached_tokens`, and DeepSeek's `prompt_cache_hit_tokens`.
-*/
-const PROMPT_CACHE_READ_KEYS = [
-	"readTokens",
-	"read_tokens",
-	"cacheReadInputTokens",
-	"cache_read_input_tokens",
-	"cacheRead",
-	"cache_read",
-	"cachedInputTokens",
-	"cachedTokens",
-	"cached_tokens",
-	"prompt_cache_hit_tokens"
-];
-/**
-* Every wire spelling of a prompt-cache WRITE counter. OpenAI reports no write counter at all, so
-* an OpenAI-shaped usage record matches nothing here and the write stays absent — which is the
-* point: absent is not zero.
-*/
-const PROMPT_CACHE_WRITE_KEYS = [
-	"writeTokens",
-	"write_tokens",
-	"cacheWriteInputTokens",
-	"cache_write_input_tokens",
-	"cacheCreationInputTokens",
-	"cache_creation_input_tokens",
-	"cacheWrite",
-	"cache_write"
-];
-const PROMPT_CACHE_MISS_KEYS = [
-	"missTokens",
-	"miss_tokens",
-	"prompt_cache_miss_tokens"
-];
-const PROMPT_CACHE_SAVINGS_KEYS = ["readSavingsUsd", "read_savings_usd"];
-/**
-* Read the provider's own prompt-cache accounting off one usage-bearing event payload, in the
-* `PromptCacheUsage` vocabulary the router, driver, and chat-client paths already speak.
-*
-* Two sources, one record. A payload that already carries a `promptCache` / `prompt_cache` object
-* is forwarded VERBATIM — those fields are the provider's own report, and an unrecognized one must
-* stay visible rather than be bucketed away. On top of that, flat provider counters are translated
-* to the canonical names, filling only the names the verbatim object did not already define.
-*
-* A counter the payload does not carry is left out. Defaulting it to zero would assert the provider
-* measured no cache, which is a different fact from a provider that reported nothing — and it is
-* the fact the budget reads to decide whether its charge is a measurement or a bound.
-*/
-function readPromptCacheUsage(data) {
-	const declared = finiteMetadata(data.promptCache ?? data.prompt_cache);
-	const nested = plainRecord(data.promptCache) ?? plainRecord(data.prompt_cache);
-	const sources = [
-		nested,
-		data,
-		plainRecord(data.prompt_tokens_details)
-	].filter((s) => s !== void 0);
-	const canonical = {};
-	const readTokens = pickTokenCount(sources, PROMPT_CACHE_READ_KEYS);
-	const writeTokens = pickTokenCount(sources, PROMPT_CACHE_WRITE_KEYS);
-	const missTokens = pickTokenCount(sources, PROMPT_CACHE_MISS_KEYS);
-	const readSavingsUsd = pickNonNegativeNumber(sources, PROMPT_CACHE_SAVINGS_KEYS);
-	const status = nested !== void 0 && typeof nested.status === "string" ? nested.status : void 0;
-	if (readTokens !== void 0) canonical.readTokens = readTokens;
-	if (writeTokens !== void 0) canonical.writeTokens = writeTokens;
-	if (missTokens !== void 0) canonical.missTokens = missTokens;
-	if (readSavingsUsd !== void 0) canonical.readSavingsUsd = readSavingsUsd;
-	if (status !== void 0) canonical.status = status;
-	const merged = {
-		...canonical,
-		...declared
-	};
-	return Object.keys(merged).length > 0 ? merged : void 0;
-}
-function plainRecord(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-}
-function pickTokenCount(sources, keys) {
-	for (const key of keys) for (const source of sources) {
-		const value = source[key];
-		if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) return value;
-	}
-}
-function pickNonNegativeNumber(sources, keys) {
-	for (const key of keys) for (const source of sources) {
-		const value = source[key];
-		if (typeof value === "number" && Number.isFinite(value) && value >= 0) return value;
-	}
-}
-function finiteMetadata(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-	const result = {};
-	for (const [key, entry] of Object.entries(value)) if (typeof entry === "number" && Number.isFinite(entry) || typeof entry === "string") result[key] = entry;
-	return Object.keys(result).length > 0 ? result : void 0;
-}
-function pickFiniteNumber(data, keys) {
-	for (const key of keys) {
-		const value = data[key];
-		if (typeof value === "number" && Number.isFinite(value)) return value;
-	}
-}
-/**
-* Fresh per-turn {@link SandboxToolPartState} for {@link mapSandboxToolEvent} — an
-* empty call-status map so each turn projects tool frames independently.
-*
-* @experimental
-*/
-function createSandboxToolPartState() {
-	return {
-		statusByCall: /* @__PURE__ */ new Map(),
-		seq: 0
-	};
-}
-/** Statuses that settle one tool call as a failure. A failed tool call stays a tool result:
-*  the run's terminal state comes from the public Sandbox outcome tracker, never from here. */
-const TERMINAL_FAILURE = /^(error|errored|failed|failure|cancelled|canceled|timeout|timed_out)$/i;
-/**
-* Project one `SandboxEvent` onto the `tool_call` / `tool_result` variants of
-* `RuntimeStreamEvent` — the tool-part projection `mapSandboxEvent`
-* deliberately does NOT perform. Opt-in and additive: `mapSandboxEvent`'s
-* default vocabulary (text/reasoning deltas + `llm_call`) is unchanged;
-* consumers that need the tool surface (chat UIs rendering tool activity)
-* compose this projector alongside it — `streamAgentTurn` does exactly that
-* under its `preserveToolParts` option.
-*
-* Handled shapes (observed on the opencode / claude-code sandbox backends):
-*   - `message.part.updated` with `part.type === 'tool'` — stateful: a
-*     `tool_call` on the call id's first frame (args from `state.input` or
-*     `state.metadata.input`), a `tool_result` when the status transitions to
-*     `completed` (result from `state.output` / `metadata.output`) or to a
-*     terminal failure (result is `{ error, status, output? }` — the error
-*     surfaced in-band, never dropped).
-*   - bare `tool*` event types (`tool.call`, `tool_result`, …) — stateless:
-*     `*result*` types project to `tool_result`, the rest to `tool_call`.
-*
-* Returns `[]` for every non-tool event.
-*
-* @experimental
-*/
-function mapSandboxToolEvent(event, state) {
-	if (!event || typeof event !== "object") return [];
-	const type = String(event.type ?? "");
-	const data = event.data && typeof event.data === "object" ? event.data : {};
-	if (type === "message.part.updated") {
-		const part = data.part && typeof data.part === "object" ? data.part : {};
-		if (String(part.type ?? "") !== "tool") return [];
-		return projectToolPart(part, state, typeof event.id === "string" ? event.id : void 0);
-	}
-	if (type.includes("tool")) {
-		const callId = pickString(data, [
-			"toolCallId",
-			"tool_use_id",
-			"id"
-		]) ?? (typeof event.id === "string" ? event.id : void 0) ?? `sandbox-tool-${++state.seq}`;
-		const toolName = pickString(data, [
-			"name",
-			"toolName",
-			"tool"
-		]) ?? "sandbox_tool";
-		if (type.includes("result")) return [{
-			type: "tool_result",
-			toolName,
-			toolCallId: callId,
-			result: data.output ?? data.result ?? data.content ?? data
-		}];
-		return [{
-			type: "tool_call",
-			toolName,
-			toolCallId: callId,
-			args: data.input ?? data.args ?? {}
-		}];
-	}
-	return [];
-}
-function projectToolPart(part, state, eventId) {
-	const callId = pickString(part, [
-		"callID",
-		"callId",
-		"toolCallId",
-		"id"
-	]) ?? eventId ?? `sandbox-tool-${++state.seq}`;
-	const toolName = pickString(part, [
-		"tool",
-		"toolName",
-		"name"
-	]) ?? "sandbox_tool";
-	const toolState = part.state && typeof part.state === "object" ? part.state : {};
-	const metadata = toolState.metadata && typeof toolState.metadata === "object" ? toolState.metadata : {};
-	const status = pickString(toolState, ["status"]) ?? "updated";
-	const previous = state.statusByCall.get(callId);
-	if (previous === "completed" || previous !== void 0 && TERMINAL_FAILURE.test(previous)) return [];
-	const out = [];
-	if (previous === void 0) out.push({
-		type: "tool_call",
-		toolName,
-		toolCallId: callId,
-		args: toolState.input ?? metadata.input ?? {}
-	});
-	state.statusByCall.set(callId, status);
-	if (status === "completed") out.push({
-		type: "tool_result",
-		toolName,
-		toolCallId: callId,
-		result: toolState.output ?? metadata.output ?? ""
-	});
-	else if (TERMINAL_FAILURE.test(status)) {
-		const message = pickString(toolState, ["error", "message"]) ?? pickString(metadata, ["error", "message"]) ?? `sandbox tool ended with status ${status}`;
-		const output = toolState.output ?? metadata.output;
-		out.push({
-			type: "tool_result",
-			toolName,
-			toolCallId: callId,
-			result: {
-				error: message,
-				status,
-				...output !== void 0 ? { output } : {}
-			}
-		});
-	}
-	return out;
-}
-function pickString(data, keys) {
-	for (const key of keys) {
-		const value = data[key];
-		if (typeof value === "string" && value.length > 0) return value;
-	}
-}
-/**
-* Project one `SandboxEvent` onto the `RuntimeStreamEvent` chat-UX vocabulary,
-* for runtimes that bridge a sandbox `streamPrompt` into the
-* `AgentRuntime.act` streaming contract. Returns `undefined` for events that
-* have no faithful projection — the raw stream is preserved separately for the
-* `OutputAdapter`, so an unmapped event never loses data.
-*
-* Mapped (the task-optional incremental variants — no synthesized task
-* lifecycle, no guessed tool-part shapes):
-*   - `message.part.updated` text part → `text_delta`
-*   - `message.part.updated` reasoning/thinking part → `reasoning_delta`
-*   - cost-bearing events → `llm_call` (shared with the ledger extractor)
-*
-* Tool parts are deliberately NOT mapped here (unchanged default) — compose
-* {@link mapSandboxToolEvent} alongside when a consumer needs them.
-*
-* The opencode backend emits incremental text as
-* `{ type: 'message.part.updated', data: { part: { type, text }, delta } }`;
-* `delta` is the increment, `part.text` the running accumulation.
-*/
-function mapSandboxEvent(event, opts = {}) {
-	if (!event || typeof event !== "object") return void 0;
-	const type = String(event.type ?? "");
-	const data = event.data && typeof event.data === "object" ? event.data : {};
-	if (type === "message.part.updated") {
-		const part = data.part && typeof data.part === "object" ? data.part : {};
-		const partType = String(part.type ?? "");
-		const text = (typeof data.delta === "string" ? data.delta : void 0) ?? (typeof part.text === "string" ? part.text : void 0);
-		if (text === void 0) return void 0;
-		if (partType === "text") return {
-			type: "text_delta",
-			text
-		};
-		if (partType === "reasoning" || partType === "thinking") return {
-			type: "reasoning_delta",
-			text
-		};
-		return;
-	}
-	return extractLlmCallEvent(event, opts.agentRunName ?? "agent");
-}
-/**
-* Project one `SandboxEvent` onto Runtime's executor progress vocabulary: incremental text and
-* reasoning, tool calls and results, and an interaction request. It composes the existing
-* projections ({@link mapSandboxEvent}, {@link mapSandboxToolEvent}, and the canonical Agent
-* Interface decode) so every sandbox-shaped executor publishes live output through one reader.
-* Usage-bearing events project to nothing here — accounting stays on the `tokens`/`cost`
-* channels.
-*
-* Pass one {@link SandboxToolPartState} per turn so a multi-frame tool call yields one call and
-* at most one result.
-*
-* @experimental
-*/
-function sandboxProgressEvents(event, state) {
-	const canonical = canonicalStreamEventFromSandboxEvent(event);
-	if (canonical?.type === "interaction") return [{
-		kind: "interaction",
-		request: canonical.request
-	}];
-	if (canonical?.type === "child-task") return [{
-		kind: "child_task",
-		event: canonical
-	}];
-	const tools = mapSandboxToolEvent(event, state).map((projected) => projected.type === "tool_call" ? {
-		kind: "tool_call",
-		toolName: projected.toolName,
-		...projected.toolCallId === void 0 ? {} : { toolCallId: projected.toolCallId },
-		...projected.args === void 0 ? {} : { args: projected.args }
-	} : {
-		kind: "tool_result",
-		toolName: projected.toolName,
-		...projected.toolCallId === void 0 ? {} : { toolCallId: projected.toolCallId },
-		...projected.result === void 0 ? {} : { result: projected.result }
-	});
-	if (tools.length > 0) return tools;
-	const mapped = mapSandboxEvent(event);
-	if (mapped?.type === "text_delta") return [{
-		kind: "text_delta",
-		text: mapped.text
-	}];
-	if (mapped?.type === "reasoning_delta") return [{
-		kind: "reasoning_delta",
-		text: mapped.text
-	}];
-	return [];
-}
-//#endregion
-export { parseCodexUsageRecord as _, extractLlmCallEvent as a, mapSandboxToolEvent as c, sandboxProgressEvents as d, sandboxTerminalUsageField as f, decodeHarnessUsage as g, parseCanonicalTransportEvent as h, createSandboxUsageLedger as i, notifySandboxEventObserver as l, extractTransportEventIdentity as m, canonicalStreamEventFromSandboxEvent as n, isSandboxTerminalEvent as o, sumSandboxUsage as p, createSandboxToolPartState as r, mapSandboxEvent as s, assertSandboxServedModel as t, sandboxEventServedBackend as u };
-
-//# sourceMappingURL=sandbox-events-DbC2WKKS.js.map