@full-self-browsing/lattice 0.0.0-bootstrap.0

package/dist/runtime-CfZ-sGGk.js

@@ -0,0 +1,1359 @@
+import mime from "mime";
+import canonicalize from "canonicalize";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/artifacts/metadata.ts
+const textEncoder$1 = new TextEncoder();
+function inferMediaType(value, options) {
+	if (options.mediaType !== void 0) return options.mediaType;
+	if (isBlobLike(value) && value.type !== "") return value.type;
+	if (typeof value === "string") return mime.getType(value) ?? options.defaultMediaType;
+	return options.defaultMediaType;
+}
+function measureArtifactValue(value, kind) {
+	if (kind === "text" && typeof value === "string") return measureString(value);
+	if (kind === "json") {
+		const serialized = JSON.stringify(value);
+		return serialized === void 0 ? void 0 : measureString(serialized);
+	}
+	if (isBlobLike(value)) return { bytes: value.size };
+}
+function measureString(value) {
+	return {
+		characters: value.length,
+		bytes: textEncoder$1.encode(value).byteLength
+	};
+}
+function isBlobLike(value) {
+	return typeof Blob !== "undefined" && value instanceof Blob;
+}
+//#endregion
+//#region src/artifacts/artifact.ts
+const artifact = {
+	text(value, options = {}) {
+		return createArtifact("text", "inline", value, options, "text/plain");
+	},
+	json(value, options = {}) {
+		return createArtifact("json", "inline", value, options, "application/json");
+	},
+	file(value, options = {}) {
+		return createArtifact("file", "file", value, options);
+	},
+	image(value, options = {}) {
+		return createArtifact("image", "file", value, options);
+	},
+	audio(value, options = {}) {
+		return createArtifact("audio", "file", value, options);
+	},
+	document(value, options = {}) {
+		return createArtifact("document", "file", value, options);
+	},
+	url(value, options = {}) {
+		return createArtifact("url", "url", value.toString(), options);
+	},
+	toolResult(value, options) {
+		return createArtifact("tool-result", "tool", value, {
+			...options,
+			metadata: {
+				...options.metadata,
+				toolName: options.toolName,
+				...options.callId !== void 0 ? { callId: options.callId } : {}
+			}
+		}, "application/json");
+	},
+	derive(input) {
+		const { kind, source = "generated", value, parents, transform, ...options } = input;
+		return createArtifact(kind, source, value, {
+			...options,
+			lineage: {
+				parents: parents.map(toArtifactRef),
+				transform
+			}
+		}, defaultMediaTypeForKind(kind));
+	}
+};
+function toArtifactRef(input) {
+	return {
+		id: input.id,
+		kind: input.kind,
+		source: input.source,
+		privacy: input.privacy,
+		...input.mediaType !== void 0 ? { mediaType: input.mediaType } : {},
+		...input.label !== void 0 ? { label: input.label } : {},
+		...input.metadata !== void 0 ? { metadata: input.metadata } : {},
+		...input.size !== void 0 ? { size: input.size } : {},
+		...input.fingerprint !== void 0 ? { fingerprint: input.fingerprint } : {},
+		...input.storage !== void 0 ? { storage: input.storage } : {},
+		...input.lineage !== void 0 ? { lineage: input.lineage } : {}
+	};
+}
+function isArtifactRef(value) {
+	if (!isRecord(value)) return false;
+	return typeof value.id === "string" && isArtifactKind(value.kind) && isArtifactSource(value.source) && isArtifactPrivacy(value.privacy);
+}
+function createArtifact(kind, source, value, options, defaultMediaType) {
+	const mediaType = inferMediaType(value, {
+		kind,
+		...options.mediaType !== void 0 ? { mediaType: options.mediaType } : {},
+		...defaultMediaType !== void 0 ? { defaultMediaType } : {}
+	});
+	const size = options.size ?? measureArtifactValue(value, kind);
+	return {
+		id: options.id ?? createArtifactId(kind),
+		kind,
+		source,
+		value,
+		privacy: options.privacy ?? "standard",
+		...mediaType !== void 0 ? { mediaType } : {},
+		...options.label !== void 0 ? { label: options.label } : {},
+		...options.metadata !== void 0 ? { metadata: options.metadata } : {},
+		...size !== void 0 ? { size } : {},
+		...options.fingerprint !== void 0 ? { fingerprint: options.fingerprint } : {},
+		...options.storage !== void 0 ? { storage: options.storage } : {},
+		...options.lineage !== void 0 ? { lineage: options.lineage } : {}
+	};
+}
+function defaultMediaTypeForKind(kind) {
+	switch (kind) {
+		case "text": return "text/plain";
+		case "json":
+		case "tool-result": return "application/json";
+		default: return;
+	}
+}
+function isArtifactKind(value) {
+	return value === "text" || value === "json" || value === "file" || value === "image" || value === "audio" || value === "video" || value === "document" || value === "url" || value === "tool-result";
+}
+function isArtifactSource(value) {
+	return value === "inline" || value === "file" || value === "url" || value === "generated" || value === `provider-upload` || value === "tool";
+}
+function isArtifactPrivacy(value) {
+	return value === "standard" || value === "sensitive" || value === "restricted";
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function createArtifactId(kind) {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return `artifact:${kind}:${crypto.randomUUID()}`;
+	return `artifact:${kind}:${Date.now()}:${Math.random().toString(16).slice(2)}`;
+}
+//#endregion
+//#region src/contract/bands.ts
+/**
+* Priority bands. Lower number = higher priority (runs first).
+*
+* SAFETY (0)        -- safety / breaker hooks; cannot be overridden by lower bands
+* OBSERVABILITY (1) -- logging, metrics, audit; runs after safety, before extension
+* EXTENSION (2)     -- user-supplied hooks; runs last
+*
+* Within a band, handlers run in registration order.
+*/
+const BAND = {
+	SAFETY: 0,
+	OBSERVABILITY: 1,
+	EXTENSION: 2
+};
+const BAND_ORDER = [
+	BAND.SAFETY,
+	BAND.OBSERVABILITY,
+	BAND.EXTENSION
+];
+const PIPELINE_FROZEN_ERROR_NAME = "PIPELINE_FROZEN";
+const HOOK_TIMEOUT_EVENT_NAME = "HOOK_TIMEOUT";
+function freezeContext(ctx) {
+	let cloned;
+	try {
+		cloned = structuredClone(ctx);
+	} catch {
+		cloned = ctx;
+	}
+	if (typeof cloned === "object" && cloned !== null) Object.freeze(cloned);
+	return cloned;
+}
+async function runHandlerWithBudget(record, ctx, controls, emit, event, sessionId) {
+	const startedAt = performance.now();
+	let timeoutFired = false;
+	const budgetMs = record.budgetMs;
+	const budgetPromise = new Promise((resolve) => {
+		setTimeout(() => {
+			timeoutFired = true;
+			resolve("__timeout__");
+		}, budgetMs);
+	});
+	const handlerPromise = (async () => {
+		try {
+			await record.handler(ctx, controls);
+		} catch {}
+		return "__done__";
+	})();
+	if (await Promise.race([handlerPromise, budgetPromise]) === "__timeout__" && timeoutFired) {
+		const elapsedMs = Math.round(performance.now() - startedAt);
+		if (emit !== void 0) emit(HOOK_TIMEOUT_EVENT_NAME, {
+			event,
+			band: record.band,
+			budgetMs,
+			...sessionId !== void 0 ? { sessionId } : {},
+			handlerIndex: record.registrationIndex,
+			elapsedMs
+		});
+	}
+}
+/**
+* Factory: build a fresh hook pipeline.
+*/
+function createHookPipeline(options) {
+	const tracer = options?.tracer;
+	const sessionId = options?.sessionId;
+	const defaultBudgetMs = options?.defaultBudgetMs ?? 100;
+	const registry = /* @__PURE__ */ new Map();
+	let frozen = false;
+	let globalRegistrationCounter = 0;
+	let currentDenialReason = null;
+	const emit = tracer !== void 0 ? (kind, payload) => {
+		tracer.event?.(kind, payload);
+	} : void 0;
+	function register(event, handler, opts) {
+		if (frozen) {
+			const err = /* @__PURE__ */ new Error("HookPipeline.register() called after freeze()");
+			err.name = PIPELINE_FROZEN_ERROR_NAME;
+			throw err;
+		}
+		let perEventBands = registry.get(event);
+		if (perEventBands === void 0) {
+			perEventBands = /* @__PURE__ */ new Map();
+			registry.set(event, perEventBands);
+		}
+		let arr = perEventBands.get(opts.band);
+		if (arr === void 0) {
+			arr = [];
+			perEventBands.set(opts.band, arr);
+		}
+		const record = {
+			handler,
+			...opts.matcher !== void 0 ? { matcher: opts.matcher } : {},
+			budgetMs: opts.budgetMs ?? defaultBudgetMs,
+			band: opts.band,
+			registrationIndex: globalRegistrationCounter
+		};
+		globalRegistrationCounter += 1;
+		arr.push(record);
+	}
+	function freezePipeline() {
+		frozen = true;
+	}
+	function isFrozen() {
+		return frozen;
+	}
+	async function run(event, context) {
+		currentDenialReason = null;
+		const perEventBands = registry.get(event);
+		if (perEventBands === void 0) return;
+		const controls = { deny: (reason) => {
+			currentDenialReason = reason;
+		} };
+		for (const band of BAND_ORDER) {
+			const arr = perEventBands.get(band);
+			if (arr === void 0 || arr.length === 0) continue;
+			for (const record of arr) {
+				if (record.matcher !== void 0 && !record.matcher.test(event)) continue;
+				await runHandlerWithBudget(record, freezeContext(context), controls, emit, event, sessionId);
+			}
+		}
+	}
+	function lastDenialReason() {
+		return currentDenialReason;
+	}
+	return {
+		kind: "hook-pipeline",
+		register,
+		freeze: freezePipeline,
+		isFrozen,
+		run,
+		lastDenialReason
+	};
+}
+//#endregion
+//#region src/receipts/canonical.ts
+const encoder = new TextEncoder();
+/**
+* Convert costUsd (number | null) to its canonical string form.
+* RFC 8785 requires deterministic float-to-string; using JS Number→string
+* directly is unsafe across V8 versions (Grisu3 vs Dragonbox). We pin the
+* format by routing through Number.prototype.toString() for FINITE numbers
+* only, and treat NaN/Infinity as null. This matches "I-JSON only" from
+* 09-CONTEXT.md — receipts NEVER carry non-finite floats.
+*/
+function stringifyCostUsd(costUsd) {
+	if (costUsd === null) return null;
+	if (!Number.isFinite(costUsd)) return null;
+	return costUsd.toString();
+}
+/**
+* Convert a runtime Usage (number costUsd) to its canonical receipt form
+* (string costUsd). This is the single conversion site — canonical bytes
+* NEVER see a raw float in the cost field.
+*/
+function usageToCanonical(usage) {
+	return {
+		promptTokens: usage.promptTokens,
+		completionTokens: usage.completionTokens,
+		costUsd: stringifyCostUsd(usage.costUsd)
+	};
+}
+/**
+* Canonicalize a receipt body to JCS bytes (RFC 8785).
+*
+* INVARIANT: callers MUST pass an already-redacted body. The redactor in
+* redact.ts produces the input to this function — never the cleartext.
+* See 09-CONTEXT.md "Redact-Then-Sign Ordering (UNRETROFITTABLE)".
+*
+* Throws if canonicalize returns undefined (impossible for valid bodies
+* — surfaces a programmer error rather than silently producing zero
+* bytes that would later fail signature verification).
+*/
+function canonicalizeReceiptBody(body) {
+	const json = canonicalize(body);
+	if (json === void 0) throw new Error("canonicalizeReceiptBody: canonicalize returned undefined; receipt body contained a non-canonicalizable value (function/symbol/undefined).");
+	return encoder.encode(json);
+}
+//#endregion
+//#region src/receipts/envelope.ts
+const PAYLOAD_TYPE = "application/vnd.lattice.receipt+json";
+const textEncoder = new TextEncoder();
+function base64Encode(bytes) {
+	return Buffer.from(bytes).toString("base64");
+}
+function base64Decode(value) {
+	return new Uint8Array(Buffer.from(value, "base64"));
+}
+/**
+* DSSE v1.0 Pre-Authentication Encoding.
+*
+* Reference: https://github.com/secure-systems-lab/dsse/blob/v1.0.0/protocol.md
+*
+* PAE = UTF-8("DSSEv1 " + len(payloadType) + " " + payloadType
+*           + " " + len(payload) + " " + payload)
+*
+* `payload` here is the BASE64-encoded string per DSSE v1.0 spec (NOT raw
+* canonical bytes). Both signing and verification MUST construct PAE the
+* same way; this module is the single source of truth.
+*
+* ASCII length is decimal (no zero-padding). e.g. length 1000 → "1000".
+*/
+function buildPae(payloadType, payloadBase64) {
+	const ascii = "DSSEv1 " + payloadType.length.toString() + " " + payloadType + " " + payloadBase64.length.toString() + " " + payloadBase64;
+	return textEncoder.encode(ascii);
+}
+function encodeEnvelope(input) {
+	return {
+		payloadType: PAYLOAD_TYPE,
+		payload: base64Encode(input.payloadBytes),
+		signatures: input.signatures.map((entry) => ({
+			keyid: entry.keyid,
+			sig: base64Encode(entry.sig)
+		}))
+	};
+}
+function decodeEnvelope(envelope) {
+	if (envelope.payloadType !== "application/vnd.lattice.receipt+json") throw new Error(`envelope payloadType mismatch: expected "${PAYLOAD_TYPE}" got "${envelope.payloadType}"`);
+	return {
+		payloadType: envelope.payloadType,
+		payloadBytes: base64Decode(envelope.payload),
+		signatures: envelope.signatures.map((entry) => ({
+			keyid: entry.keyid,
+			sig: base64Decode(entry.sig)
+		}))
+	};
+}
+//#endregion
+//#region src/receipts/redact.ts
+/**
+* Default redaction policy id for v1.1. Free-form string per
+* 09-CONTEXT.md — registry enforcement deferred to v1.2.
+*/
+const DEFAULT_REDACTION_POLICY_ID = "lattice.default.v1";
+/**
+* Redact a receipt body BEFORE canonicalization (and BEFORE signing).
+*
+* The signed digest commits to canonicalize(redact(body)). NEVER the
+* other way around. See 09-CONTEXT.md "Redact-Then-Sign Ordering
+* (UNRETROFITTABLE)" and PITFALLS.md Pitfall #1.
+*
+* For v1.1 the default policy is minimal — the heavy lifting already
+* happened upstream:
+*   - Tripwire evaluator emits {detector, substring} for no-pii (T-08-01).
+*   - Provider responses are hashed into inputHashes/outputHash, never
+*     embedded raw.
+*   - Router reject messages do not contain PII by construction.
+*
+* This function therefore primarily:
+*   1. Materializes the redactions[] manifest declaring what WAS elided
+*      upstream (so receipts are self-describing).
+*   2. Provides the extension point future policies will use.
+*
+* Returns a NEW body — never mutates the input.
+*/
+function redactReceiptBody(body, policyId = DEFAULT_REDACTION_POLICY_ID) {
+	const redactions = [];
+	if (body.tripwireEvidence !== void 0 && body.tripwireEvidence.kind === "no-pii") redactions.push({
+		path: "tripwireEvidence.observed",
+		reason: "no-pii-detector-substring-only"
+	});
+	const sorted = [...redactions].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+	return {
+		body: {
+			...body,
+			redactionPolicyId: policyId,
+			redactions: sorted
+		},
+		redactions: sorted
+	};
+}
+//#endregion
+//#region src/receipts/receipt.ts
+/**
+* Build, redact, canonicalize, sign, and envelope a CapabilityReceipt.
+*
+* Ordering INVARIANT (09-CONTEXT.md, PITFALLS.md Pitfall #1):
+*   redact -> canonicalize -> PAE -> sign -> encode
+*
+* The signed digest commits to canonicalize(redact(body)). The function
+* structure makes any other ordering impossible to write by accident —
+* canonicalizeReceiptBody is ONLY called on the output of redactReceiptBody.
+*
+* Defense in depth:
+*   - body.kid is assigned from signer.kid, never from input (input has no
+*     kid field). The signed body and the envelope keyid CANNOT disagree by
+*     construction.
+*   - signer.kid is also written to envelope.signatures[0].keyid, so the
+*     verifier can cross-check (Step 7 of verifyReceipt).
+*
+* I-JSON guarantees: usage.costUsd is converted to string (or null) via
+* usageToCanonical. Receipts NEVER carry raw floats in the canonical form.
+*/
+async function createReceipt(input, signer) {
+	const policyId = input.redactionPolicyId ?? "lattice.default.v1";
+	const receiptId = input.receiptId ?? crypto.randomUUID();
+	const issuedAt = input.issuedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+	const { body } = redactReceiptBody({
+		version: "lattice-receipt/v1.1",
+		receiptId,
+		runId: input.runId,
+		issuedAt,
+		kid: signer.kid,
+		model: input.model,
+		route: input.route,
+		usage: usageToCanonical(input.usage),
+		contractVerdict: input.contractVerdict,
+		contractHash: input.contractHash,
+		inputHashes: input.inputHashes,
+		outputHash: input.outputHash,
+		redactionPolicyId: policyId,
+		redactions: [],
+		...input.noRouteReasons !== void 0 ? { noRouteReasons: input.noRouteReasons } : {},
+		...input.tripwireEvidence !== void 0 ? { tripwireEvidence: input.tripwireEvidence } : {},
+		...input.stepName !== void 0 ? { stepName: input.stepName } : {},
+		...input.stepIndex !== void 0 ? { stepIndex: input.stepIndex } : {},
+		...input.parentStepName !== void 0 ? { parentStepName: input.parentStepName } : {},
+		...input.previousStepName !== void 0 ? { previousStepName: input.previousStepName } : {},
+		...input.sessionId !== void 0 ? { sessionId: input.sessionId } : {},
+		...input.timestamp !== void 0 ? { timestamp: input.timestamp } : {}
+	}, policyId);
+	const payloadBytes = canonicalizeReceiptBody(body);
+	const pae = buildPae(PAYLOAD_TYPE, base64Encode(payloadBytes));
+	const sig = await signer.sign(pae);
+	return encodeEnvelope({
+		payloadBytes,
+		signatures: [{
+			keyid: signer.kid,
+			sig
+		}]
+	});
+}
+//#endregion
+//#region src/contract/checkpoint.ts
+/**
+* The tracer event name Lattice's checkpoint hook emits per step transition.
+* Identical to the literal added to RunEventKind in tracing.ts.
+*/
+const STEP_TRANSITION_EVENT_NAME = "step.transition";
+/**
+* Default band convention for the checkpoint hook (D-06). The caller is
+* free to register in a different band but the documented convention is
+* OBSERVABILITY -- between SAFETY (runs first) and EXTENSION (runs last).
+*/
+const DEFAULT_CHECKPOINT_BAND = BAND.OBSERVABILITY;
+const DEFAULT_MODEL = {
+	requested: "lattice-checkpoint/observability",
+	observed: null
+};
+const DEFAULT_ROUTE = {
+	providerId: "lattice-checkpoint",
+	capabilityId: "lattice-checkpoint/step-transition",
+	attemptNumber: 1
+};
+const DEFAULT_USAGE = {
+	promptTokens: 0,
+	completionTokens: 0,
+	costUsd: null
+};
+/**
+* Build a checkpoint hook handler.
+*
+* The returned handler is suitable for registration on a HookPipeline
+* created via createHookPipeline (see ./bands.ts). The handler does not
+* auto-register; the caller passes it to pipeline.register(...) with the
+* desired lifecycle event (typically AFTER_TOOL or BEFORE_TOOL) and band
+* (typically BAND.OBSERVABILITY, exported as DEFAULT_CHECKPOINT_BAND).
+*
+* Per-invocation behavior:
+*   1. Build event metadata from options + per-call context.
+*   2. If signer is configured, attempt createReceipt(...) inside a
+*      try/catch. On success, set metadata.receiptId + metadata.envelope.
+*      On failure, set metadata.mintError (string from caught error).
+*   3. If tracer is configured, emit exactly one tracer.event?.(
+*      STEP_TRANSITION_EVENT_NAME, metadata) call.
+*   4. Return void.
+*
+* NO upstream throw (D-07). NO global mutation (D-05).
+*/
+function createCheckpointHook(options) {
+	const runId = options.runId;
+	const tracer = options.tracer;
+	const signer = options.signer;
+	const sessionId = options.sessionId;
+	const model = options.model ?? DEFAULT_MODEL;
+	const route = options.route ?? DEFAULT_ROUTE;
+	const contractVerdict = options.contractVerdict ?? "success";
+	return async function checkpointHookHandler(ctx) {
+		const baseMetadata = {
+			runId,
+			stepName: ctx.stepName,
+			stepIndex: ctx.stepIndex,
+			timestamp: ctx.timestamp,
+			...ctx.parentStepName !== void 0 ? { parentStepName: ctx.parentStepName } : {},
+			...ctx.previousStepName !== void 0 ? { previousStepName: ctx.previousStepName } : {},
+			...sessionId !== void 0 ? { sessionId } : {}
+		};
+		let envelope;
+		let receiptId;
+		let mintError;
+		if (signer !== void 0) try {
+			envelope = await createReceipt({
+				runId,
+				model,
+				route,
+				usage: DEFAULT_USAGE,
+				contractVerdict,
+				contractHash: null,
+				inputHashes: [],
+				outputHash: null,
+				stepName: ctx.stepName,
+				stepIndex: ctx.stepIndex,
+				timestamp: ctx.timestamp,
+				...ctx.parentStepName !== void 0 ? { parentStepName: ctx.parentStepName } : {},
+				...ctx.previousStepName !== void 0 ? { previousStepName: ctx.previousStepName } : {},
+				...sessionId !== void 0 ? { sessionId } : {}
+			}, signer);
+			receiptId = extractReceiptId(envelope);
+		} catch (err) {
+			mintError = err instanceof Error ? err.message : String(err);
+		}
+		const metadata = {
+			...baseMetadata,
+			...receiptId !== void 0 ? { receiptId } : {},
+			...envelope !== void 0 ? { envelope } : {},
+			...mintError !== void 0 ? { mintError } : {}
+		};
+		tracer?.event?.(STEP_TRANSITION_EVENT_NAME, metadata);
+	};
+}
+/**
+* Decode the canonical payload of a freshly-minted envelope and return
+* its receiptId. The envelope's payload is base64-encoded JSON of the
+* signed body (DSSE v1.0 form); receiptId is a top-level field.
+*
+* Returns undefined if decoding fails (defensive -- the handler still
+* emits the tracer event with the envelope itself so subscribers can
+* re-derive the id if they want).
+*/
+function extractReceiptId(envelope) {
+	try {
+		const bytes = Uint8Array.from(atob(envelope.payload), (c) => c.charCodeAt(0));
+		const body = JSON.parse(new TextDecoder().decode(bytes));
+		return typeof body.receiptId === "string" ? body.receiptId : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/runtime/survivability.ts
+/**
+* Reference implementation of SurvivabilityAdapter<TState>. Records
+* eviction events but does NOT persist; serialize / deserialize round-
+* trip via JSON.stringify / JSON.parse. Analog to createFakeProvider
+* in the providers/ module -- gives Lattice's vitest a complete shape-
+* conformance target before the real (FSB-side) adapter ships in
+* Plan 05-05.
+*
+* Per CONTEXT.md D-11 the noop adapter ships in Lattice (not FSB)
+* because it covers the contract surface in Lattice's own test suite;
+* FSB's real chrome.storage.session-backed adapter is glue layer.
+*/
+function createNoopSurvivabilityAdapter(options = {}) {
+	const id = options.id ?? "noop-survivability";
+	const defaultPolicy = options.policy ?? "SAFE";
+	const hooks = /* @__PURE__ */ new Set();
+	return {
+		kind: "survivability-adapter",
+		id,
+		serialize(state) {
+			return {
+				kind: "survivability-snapshot",
+				version: "lattice-survivability/v1",
+				payload: JSON.stringify(state ?? null),
+				capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+		},
+		deserialize(snapshot) {
+			return JSON.parse(snapshot.payload);
+		},
+		onEviction(hook) {
+			hooks.add(hook);
+			let unsubscribed = false;
+			return () => {
+				if (unsubscribed) return;
+				unsubscribed = true;
+				hooks.delete(hook);
+			};
+		},
+		async resume(_snapshot) {
+			return defaultPolicy;
+		}
+	};
+}
+//#endregion
+//#region src/outputs/validate.ts
+async function validateSchemaOutput(name, schema, value) {
+	const result = schema["~standard"].validate(value);
+	const validation = result instanceof Promise ? await result : result;
+	if (validation.issues) return {
+		ok: false,
+		issue: {
+			["output"]: name,
+			issues: validation.issues.map(normalizeIssue)
+		}
+	};
+	return {
+		ok: true,
+		value: validation.value
+	};
+}
+async function validateOutputMap(contracts, rawOutputs, plan) {
+	const outputs = {};
+	for (const [name, contract] of Object.entries(contracts)) {
+		const value = rawOutputs[name];
+		const issue = await validateOutput(name, contract, value);
+		if (!issue.ok) return {
+			ok: false,
+			error: {
+				kind: "validation",
+				message: `Invalid output "${name}".`,
+				["output"]: name,
+				issues: issue.issues
+			},
+			usage: {
+				promptTokens: 0,
+				completionTokens: 0,
+				costUsd: null
+			},
+			raw: rawOutputs,
+			partialOutputs: outputs,
+			plan
+		};
+		outputs[name] = issue.value;
+	}
+	return {
+		ok: true,
+		outputs,
+		artifacts: [],
+		usage: {
+			promptTokens: 0,
+			completionTokens: 0,
+			costUsd: null
+		},
+		plan
+	};
+}
+async function validateOutput(name, contract, value) {
+	if (contract === "text") {
+		if (typeof value !== "string") return {
+			ok: false,
+			issues: [{ message: "Expected text output to be a string." }]
+		};
+		return {
+			ok: true,
+			value
+		};
+	}
+	if (isStandardSchema(contract)) {
+		const result = await validateSchemaOutput(name, contract, value);
+		if (!result.ok) return {
+			ok: false,
+			issues: result.issue.issues
+		};
+		return {
+			ok: true,
+			value: result.value
+		};
+	}
+	if (contract.kind === "citations") {
+		if (!Array.isArray(value)) return {
+			ok: false,
+			issues: [{ message: "Expected citations output to be an array." }]
+		};
+		return {
+			ok: true,
+			value
+		};
+	}
+	if (contract.kind === "artifacts") {
+		if (!Array.isArray(value)) return {
+			ok: false,
+			issues: [{ message: "Expected artifacts output to be an array." }]
+		};
+		for (const item of value) {
+			if (!isArtifactRef(item)) return {
+				ok: false,
+				issues: [{ message: "Expected artifacts output item to be an artifact ref." }]
+			};
+			if (contract.artifactKind !== void 0 && item.kind !== contract.artifactKind) return {
+				ok: false,
+				issues: [{ message: `Expected artifacts output item kind to be "${contract.artifactKind}".` }]
+			};
+		}
+		return {
+			ok: true,
+			value: value.map(toArtifactRef)
+		};
+	}
+	return {
+		ok: false,
+		issues: [{ message: "Unsupported output contract." }]
+	};
+}
+function isStandardSchema(contract) {
+	if (typeof contract !== "object" || contract === null) return false;
+	return typeof contract["~standard"]?.validate === "function";
+}
+function normalizeIssue(issue) {
+	const path = issue.path?.map(normalizePathSegment).filter((segment) => segment !== void 0);
+	return {
+		message: issue.message,
+		...path !== void 0 && path.length > 0 ? { path } : {}
+	};
+}
+function normalizePathSegment(segment) {
+	if (typeof segment === "string" || typeof segment === "number" || typeof segment === "symbol") return segment;
+	return normalizePathKey(segment.key);
+}
+function normalizePathKey(key) {
+	return key;
+}
+//#endregion
+//#region src/tools/tools.ts
+function defineTool(definition) {
+	return {
+		kind: "tool",
+		...definition
+	};
+}
+async function runTool(tool, input, context = {}) {
+	const validation = await validateSchemaOutput(tool.name, tool.inputSchema, input);
+	if (!validation.ok) throw new Error(`Invalid input for tool "${tool.name}".`);
+	const callId = createToolCallId();
+	const output = await tool.execute(validation.value, context);
+	return {
+		callId,
+		toolName: tool.name,
+		artifact: artifact.toolResult(output, {
+			id: `artifact:tool-result:${tool.name}:${callId}`,
+			toolName: tool.name,
+			callId
+		})
+	};
+}
+async function importMcpTools(client, toolNames) {
+	const descriptors = await Promise.resolve(client.listTools?.() ?? []);
+	const allowed = toolNames === void 0 ? void 0 : new Set(toolNames);
+	return descriptors.filter((descriptor) => allowed === void 0 || allowed.has(descriptor.name)).map((descriptor) => defineTool({
+		name: descriptor.name,
+		...descriptor.description !== void 0 ? { description: descriptor.description } : {},
+		inputSchema: descriptor.inputSchema,
+		execute: async (input) => client.callTool({
+			name: descriptor.name,
+			arguments: input
+		})
+	}));
+}
+function toolArtifactRef(result) {
+	const { value: _value, ...ref } = result.artifact;
+	return ref;
+}
+function createToolCallId() {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	return `${Date.now()}:${Math.random().toString(16).slice(2)}`;
+}
+//#endregion
+//#region src/agent/format-tools.ts
+/**
+* Convert a Standard Schema to a JSON Schema-shaped descriptor suitable for
+* inclusion in an LLM tool description. Standard Schema vendors can
+* optionally expose `toJSONSchema` on their schema objects; when absent,
+* we fall back to a minimal structural description that lists the schema
+* vendor + version + a placeholder. Models tolerate placeholder schemas in
+* practice because the tool description is supplementary — what matters
+* is the envelope contract (`{tool_call: {name, args}}`).
+*/
+function toolSchemaToJsonSchema(schema) {
+	const standardSchema = schema["~standard"];
+	if (typeof standardSchema === "object" && standardSchema !== null && "vendor" in standardSchema) {
+		const vendor = standardSchema;
+		const maybeToJson = schema.toJSONSchema;
+		if (typeof maybeToJson === "function") try {
+			return maybeToJson();
+		} catch {}
+		return {
+			$comment: `standard-schema vendor: ${vendor.vendor}; toJSONSchema not available`,
+			type: "object"
+		};
+	}
+	return {
+		$comment: "non-standard-schema input",
+		type: "object"
+	};
+}
+/**
+* Builds the prompt-reencoded tool-use protocol handle for any provider.
+*
+* Phase 19 ships a uniform implementation across all 7 logical providers
+* (openai, openai-compat, anthropic, gemini, xai, openrouter, lm-studio).
+* The `providerName` argument is accepted for forward compatibility but
+* does not branch the implementation in v1.2.
+*/
+function formatToolsForProvider(providerName, tools, options = {}) {
+	options.mode;
+	const system = options.system?.trim() ?? "";
+	const toolDescriptions = tools.map((tool) => {
+		const schemaDescriptor = toolSchemaToJsonSchema(tool.inputSchema);
+		const schemaJson = JSON.stringify(schemaDescriptor, null, 2);
+		const desc = tool.description?.trim() ?? "(no description)";
+		return `- name: ${tool.name}\n  description: ${desc}\n  args_schema: ${schemaJson}`;
+	}).join("\n");
+	const envelopeInstructions = [
+		"You are a single-agent loop. You can either:",
+		"  (a) answer the user directly with a final response, OR",
+		"  (b) request one or more tool calls.",
+		"",
+		"To request tool calls, respond with ONE JSON object on a line by itself:",
+		"  {\"tool_calls\": [{\"id\": \"...\", \"name\": \"tool_name\", \"args\": {...}}]}",
+		"Each tool_call needs a unique id (any string). The args MUST match the tool's args_schema.",
+		"",
+		"To answer directly, respond with a final answer in natural language with NO JSON envelope.",
+		"Do not mix a final answer and a tool_calls envelope in the same response."
+	].join("\n");
+	const systemBlock = [
+		system,
+		"",
+		"Available tools:",
+		toolDescriptions || "(none)",
+		"",
+		envelopeInstructions
+	].filter((s) => s !== "" || true).join("\n").replace(/^\n+/, "").trimEnd();
+	function buildTask(conversation) {
+		const lines = [];
+		lines.push(systemBlock);
+		lines.push("");
+		lines.push("---");
+		lines.push("");
+		for (const turn of conversation) {
+			if (turn.role === "user") lines.push(`USER:\n${turn.content}`);
+			else if (turn.role === "assistant") lines.push(`ASSISTANT:\n${turn.content}`);
+			else {
+				const idHint = turn.toolCallId !== void 0 ? ` id=${turn.toolCallId}` : "";
+				const nameHint = turn.toolName !== void 0 ? ` name=${turn.toolName}` : "";
+				lines.push(`TOOL_RESULT (${nameHint.trim() || "tool"}${idHint}):\n${turn.content}`);
+			}
+			lines.push("");
+		}
+		lines.push("ASSISTANT:");
+		return lines.join("\n");
+	}
+	function parseToolUse(responseText) {
+		if (typeof responseText !== "string" || responseText.length === 0) return null;
+		const candidates = extractJsonCandidates(responseText);
+		for (const candidate of candidates) {
+			const parsed = tryParseEnvelope(candidate);
+			if (parsed !== null) return parsed;
+		}
+		return null;
+	}
+	function describeForSystem() {
+		return systemBlock;
+	}
+	return {
+		buildTask,
+		parseToolUse,
+		describeForSystem,
+		mode: "prompt-reencoded"
+	};
+}
+/**
+* Extracts JSON-looking candidate substrings from a response text.
+*
+* Models routinely wrap JSON in markdown code fences (```json ... ```),
+* prepend explanatory prose ("I'll call the search tool: { ... }"), or
+* produce multiple JSON-shaped blobs. This extractor scans for plausible
+* candidates ordered by likelihood.
+*/
+function extractJsonCandidates(text) {
+	const candidates = [];
+	const fenceRegex = /```(?:json)?\s*([\s\S]*?)```/g;
+	let fenceMatch;
+	while ((fenceMatch = fenceRegex.exec(text)) !== null) {
+		const inner = fenceMatch[1];
+		if (inner !== void 0) candidates.push(inner.trim());
+	}
+	const braceStart = text.indexOf("{");
+	const braceEnd = text.lastIndexOf("}");
+	if (braceStart !== -1 && braceEnd > braceStart) candidates.push(text.slice(braceStart, braceEnd + 1));
+	candidates.push(text.trim());
+	return candidates;
+}
+function tryParseEnvelope(jsonLike) {
+	let parsed;
+	try {
+		parsed = JSON.parse(jsonLike);
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null) return null;
+	const toolCalls = parsed["tool_calls"];
+	if (!Array.isArray(toolCalls) || toolCalls.length === 0) return null;
+	const requests = [];
+	for (const call of toolCalls) {
+		if (typeof call !== "object" || call === null) return null;
+		const callRecord = call;
+		const id = callRecord["id"];
+		const name = callRecord["name"];
+		const args = callRecord["args"];
+		if (typeof id !== "string" || typeof name !== "string") return null;
+		requests.push({
+			id,
+			name,
+			args
+		});
+	}
+	return requests;
+}
+//#endregion
+//#region src/agent/host.ts
+/**
+* Reference implementation suitable for Node tests + the Phase 19 default
+* behavior.
+*
+* - scheduler: resolves immediately (no yield between iterations).
+* - transport: pass-through to provider.execute().
+* - storage: save() / clear() are no-ops; load() always returns null.
+*
+* Equivalent to passing no host at all.
+*/
+function createNoopAgentHost() {
+	return {
+		kind: "agent-host",
+		scheduler: { async scheduleNext(_iterationIndex) {} },
+		transport: { async call(provider, request) {
+			if (provider.execute === void 0) throw new Error(`AgentTransport: provider ${provider.id} has no execute() method.`);
+			return provider.execute(request);
+		} },
+		storage: {
+			async save(_snapshot) {},
+			async load() {
+				return null;
+			},
+			async clear() {}
+		}
+	};
+}
+//#endregion
+//#region src/agent/types.ts
+/**
+* Typed error raised when a SAFETY-band handler sets `controls.deny(reason)`
+* during `BEFORE_AGENT_ITERATION`. Carries `terminal: true` semantics to
+* align with v1.1 `TripwireViolationError`: the failure is NOT retried by
+* the fallback chain.
+*
+* Surfaced via `AgentFailure { kind: "agent-iteration-denied", reason, ... }`
+* — callers can also catch the typed error if they prefer.
+*/
+var AgentDeniedError = class extends Error {
+	kind = "agent-iteration-denied";
+	terminal = true;
+	reason;
+	iterationIndex;
+	constructor(reason, iterationIndex) {
+		super(`Agent iteration ${iterationIndex} denied: ${reason}`);
+		this.name = "AgentDeniedError";
+		this.reason = reason;
+		this.iterationIndex = iterationIndex;
+	}
+};
+//#endregion
+//#region src/agent/runtime.ts
+var runtime_exports = /* @__PURE__ */ __exportAll({ runAgent: () => runAgent });
+const ZERO_USAGE = {
+	promptTokens: 0,
+	completionTokens: 0,
+	costUsd: null
+};
+/**
+* Resolves the runtime's behaviour for a single `ai.runAgent(intent)` call.
+*
+* Phase 19 ships an in-process default scheduler (the loop runs in the
+* calling Promise), direct transport (provider.execute()), and in-memory
+* transcript (the `conversation` array). Phase 20 promotes scheduler /
+* transport / storage to the pluggable `AgentHost` adapter.
+*/
+async function runAgent(intent, config = {}) {
+	const startedAt = Date.now();
+	const cumulativeUsage = {
+		promptTokens: 0,
+		completionTokens: 0,
+		costUsd: null
+	};
+	const iterations = [];
+	const host = intent.host ?? createNoopAgentHost();
+	const survivabilityAdapter = intent.survivabilityAdapter ?? createNoopSurvivabilityAdapter();
+	const pipeline = ensurePipeline(intent);
+	maybeAutoRegisterCheckpoint(pipeline, intent);
+	const provider = pickFirstExecutableProvider(config);
+	if (provider === null) return buildFailure({
+		kind: "execution_unavailable",
+		reason: "No provider adapter with execute() is configured.",
+		iterations,
+		usage: cumulativeUsage
+	});
+	let providerName = provider.id;
+	let conversation = [{
+		role: "user",
+		content: intent.task
+	}];
+	const handle = formatToolsForProvider(providerName, intent.tools);
+	const budget = intent.contract?.budget;
+	const maxIterations = budget?.maxIterations ?? Number.POSITIVE_INFINITY;
+	const maxWallTimeMs = budget?.maxWallTimeMs ?? Number.POSITIVE_INFINITY;
+	const maxCostUsd = budget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+	let iterationIndex = 0;
+	const existingSnapshot = await host.storage?.load();
+	if (existingSnapshot !== null && existingSnapshot !== void 0) {
+		intent.tracer?.event?.("recovery.start", {
+			snapshotVersion: existingSnapshot.version,
+			capturedAt: existingSnapshot.capturedAt
+		});
+		try {
+			const restored = survivabilityAdapter.deserialize(existingSnapshot);
+			iterationIndex = restored.iterationIndex;
+			conversation = [...restored.conversation];
+			cumulativeUsage.promptTokens = restored.cumulativeUsage.promptTokens;
+			cumulativeUsage.completionTokens = restored.cumulativeUsage.completionTokens;
+			cumulativeUsage.costUsd = restored.cumulativeUsage.costUsd;
+			providerName = restored.providerName;
+			intent.tracer?.event?.("recovery.complete", {
+				iterationIndex,
+				providerName
+			});
+		} catch (error) {
+			intent.tracer?.event?.("recovery.failed", { reason: error instanceof Error ? error.message : "deserialize failed" });
+			await host.storage?.clear();
+		}
+	}
+	while (iterationIndex < maxIterations) {
+		const elapsedMs = Date.now() - startedAt;
+		if (elapsedMs >= maxWallTimeMs) return buildFailure({
+			kind: "agent-wall-time-exceeded",
+			reason: `Wall-time budget ${maxWallTimeMs}ms exceeded after ${elapsedMs}ms`,
+			iterations,
+			usage: cumulativeUsage
+		});
+		if (cumulativeUsage.costUsd !== null && cumulativeUsage.costUsd >= maxCostUsd) return buildFailure({
+			kind: "no-contract-match",
+			reason: `Cost budget $${maxCostUsd} exceeded at $${cumulativeUsage.costUsd}`,
+			iterations,
+			usage: cumulativeUsage
+		});
+		await pipeline.run("BEFORE_AGENT_ITERATION", {
+			iterationIndex,
+			intent,
+			conversation: conversation.map((t) => ({ ...t })),
+			stepName: `agent-iteration-${iterationIndex}-before`,
+			stepIndex: iterationIndex,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			...iterationIndex > 0 ? { previousStepName: `agent-iteration-${iterationIndex - 1}-after` } : {}
+		});
+		const denial = pipeline.lastDenialReason();
+		if (denial !== null) {
+			const failedRecord = {
+				index: iterationIndex,
+				provider: providerName,
+				promptTokens: 0,
+				completionTokens: 0,
+				costUsd: null,
+				durationMs: 0,
+				toolCalls: [],
+				deniedReason: denial
+			};
+			iterations.push(failedRecord);
+			await pipeline.run("AFTER_AGENT_ITERATION", {
+				iterationIndex,
+				intent,
+				record: failedRecord,
+				stepName: `agent-iteration-${iterationIndex}-after`,
+				stepIndex: iterationIndex,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				previousStepName: `agent-iteration-${iterationIndex}-before`
+			});
+			return buildFailure({
+				kind: "agent-iteration-denied",
+				reason: denial,
+				iterations,
+				usage: cumulativeUsage
+			});
+		}
+		const task = handle.buildTask(conversation);
+		const iterStart = Date.now();
+		let response;
+		try {
+			if (provider.execute === void 0) return buildFailure({
+				kind: "execution_unavailable",
+				reason: "Selected provider has no execute() method.",
+				iterations,
+				usage: cumulativeUsage
+			});
+			const providerRequest = {
+				task,
+				artifacts: [],
+				outputs: ["answer"],
+				...intent.policy !== void 0 ? { policy: intent.policy } : {}
+			};
+			response = host.transport !== void 0 ? await host.transport.call(provider, providerRequest) : await provider.execute(providerRequest);
+		} catch (error) {
+			return buildFailure({
+				kind: "provider_execution",
+				reason: error instanceof Error ? error.message : "Provider execution failed",
+				cause: error,
+				iterations,
+				usage: cumulativeUsage
+			});
+		}
+		const iterDuration = Date.now() - iterStart;
+		const iterUsage = response.normalizedUsage ?? ZERO_USAGE;
+		accumulateUsage(cumulativeUsage, iterUsage);
+		const responseText = extractResponseText(response);
+		const toolUseRequests = handle.parseToolUse(responseText);
+		if (toolUseRequests === null) {
+			const finalRecord = {
+				index: iterationIndex,
+				provider: providerName,
+				promptTokens: iterUsage.promptTokens,
+				completionTokens: iterUsage.completionTokens,
+				costUsd: iterUsage.costUsd,
+				durationMs: iterDuration,
+				toolCalls: []
+			};
+			iterations.push(finalRecord);
+			conversation.push({
+				role: "assistant",
+				content: responseText
+			});
+			await pipeline.run("AFTER_AGENT_ITERATION", {
+				iterationIndex,
+				intent,
+				record: finalRecord,
+				stepName: `agent-iteration-${iterationIndex}-after`,
+				stepIndex: iterationIndex,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				previousStepName: `agent-iteration-${iterationIndex}-before`
+			});
+			await host.storage?.clear();
+			return {
+				kind: "success",
+				output: { answer: responseText },
+				usage: snapshotUsage(cumulativeUsage),
+				iterations: Object.freeze([...iterations])
+			};
+		}
+		conversation.push({
+			role: "assistant",
+			content: responseText
+		});
+		const toolCallRecords = [];
+		for (const req of toolUseRequests) {
+			const tool = intent.tools.find((t) => t.name === req.name);
+			let toolResult = null;
+			let resultContent;
+			let resultHash = "tool-not-found";
+			if (tool === void 0) resultContent = JSON.stringify({ error: `Unknown tool: ${req.name}` });
+			else try {
+				await pipeline.run("BEFORE_TOOL", {
+					iterationIndex,
+					toolName: req.name,
+					args: req.args
+				});
+				toolResult = await runTool(tool, req.args);
+				resultContent = stringifyArtifactValue(toolResult.artifact.value);
+				resultHash = toolResult.callId;
+				await pipeline.run("AFTER_TOOL", {
+					iterationIndex,
+					toolName: req.name,
+					args: req.args,
+					result: toolResult.artifact.value
+				});
+			} catch (error) {
+				resultContent = JSON.stringify({ error: error instanceof Error ? error.message : "Tool execution failed" });
+			}
+			conversation.push({
+				role: "tool",
+				content: resultContent,
+				toolCallId: req.id,
+				toolName: req.name
+			});
+			toolCallRecords.push({
+				id: req.id,
+				name: req.name,
+				argsHash: stableHash(req.args),
+				resultHash
+			});
+		}
+		const record = {
+			index: iterationIndex,
+			provider: providerName,
+			promptTokens: iterUsage.promptTokens,
+			completionTokens: iterUsage.completionTokens,
+			costUsd: iterUsage.costUsd,
+			durationMs: iterDuration,
+			toolCalls: Object.freeze([...toolCallRecords])
+		};
+		iterations.push(record);
+		await pipeline.run("AFTER_AGENT_ITERATION", {
+			iterationIndex,
+			intent,
+			record,
+			stepName: `agent-iteration-${iterationIndex}-after`,
+			stepIndex: iterationIndex,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			previousStepName: `agent-iteration-${iterationIndex}-before`
+		});
+		if (host.storage !== void 0) {
+			const snapshot = survivabilityAdapter.serialize({
+				version: "agent-snapshot/v1",
+				iterationIndex: iterationIndex + 1,
+				conversation: [...conversation],
+				cumulativeUsage: snapshotUsage(cumulativeUsage),
+				providerName,
+				capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			await host.storage.save(snapshot);
+		}
+		if (host.scheduler !== void 0) await host.scheduler.scheduleNext(iterationIndex);
+		iterationIndex += 1;
+	}
+	return buildFailure({
+		kind: "agent-max-iterations",
+		reason: `Iteration budget ${maxIterations} reached without a final answer`,
+		iterations,
+		usage: cumulativeUsage
+	});
+}
+function ensurePipeline(intent) {
+	if (intent.pipeline !== void 0) return intent.pipeline;
+	return createHookPipeline(intent.tracer !== void 0 ? { tracer: intent.tracer } : {});
+}
+function maybeAutoRegisterCheckpoint(pipeline, intent) {
+	if (intent.signer === void 0) return;
+	if (intent.autoRegisterCheckpoint === false) return;
+	if (pipeline.isFrozen()) return;
+	const handler = createCheckpointHook({
+		runId: `runAgent-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+		signer: intent.signer,
+		...intent.tracer !== void 0 ? { tracer: intent.tracer } : {}
+	});
+	pipeline.register("AFTER_AGENT_ITERATION", handler, { band: BAND.OBSERVABILITY });
+}
+function pickFirstExecutableProvider(config) {
+	const providers = config.providers ?? [];
+	for (const entry of providers) {
+		if (typeof entry === "string") continue;
+		if ("kind" in entry && entry.kind === "provider-adapter" && entry.execute !== void 0) return entry;
+	}
+	return null;
+}
+function extractResponseText(response) {
+	const raw = response.rawOutputs ?? {};
+	const text = raw["answer"];
+	if (typeof text === "string") return text;
+	for (const value of Object.values(raw)) if (typeof value === "string") return value;
+	return "";
+}
+function accumulateUsage(cumulative, iter) {
+	cumulative.promptTokens += iter.promptTokens;
+	cumulative.completionTokens += iter.completionTokens;
+	if (iter.costUsd !== null) cumulative.costUsd = (cumulative.costUsd ?? 0) + iter.costUsd;
+}
+function snapshotUsage(c) {
+	return {
+		promptTokens: c.promptTokens,
+		completionTokens: c.completionTokens,
+		costUsd: c.costUsd
+	};
+}
+function buildFailure(input) {
+	return {
+		kind: input.kind,
+		usage: snapshotUsage(input.usage),
+		iterations: Object.freeze([...input.iterations]),
+		...input.reason !== void 0 ? { reason: input.reason } : {},
+		...input.cause !== void 0 ? { cause: input.cause } : {}
+	};
+}
+function stringifyArtifactValue(value) {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+function stableHash(input) {
+	try {
+		const json = JSON.stringify(input);
+		let hash = 5381;
+		for (let i = 0; i < json.length; i += 1) hash = hash * 33 ^ json.charCodeAt(i);
+		return `djb2:${(hash >>> 0).toString(16)}`;
+	} catch {
+		return "djb2:0";
+	}
+}
+//#endregion
+export { createHookPipeline as C, BAND as S, toArtifactRef as T, PAYLOAD_TYPE as _, formatToolsForProvider as a, decodeEnvelope as b, importMcpTools as c, validateOutputMap as d, createNoopSurvivabilityAdapter as f, createReceipt as g, createCheckpointHook as h, createNoopAgentHost as i, runTool as l, STEP_TRANSITION_EVENT_NAME as m, runtime_exports as n, toolSchemaToJsonSchema as o, DEFAULT_CHECKPOINT_BAND as p, AgentDeniedError as r, defineTool as s, runAgent as t, toolArtifactRef as u, base64Encode as v, artifact as w, canonicalizeReceiptBody as x, buildPae as y };
+
+//# sourceMappingURL=runtime-CfZ-sGGk.js.map