@runtypelabs/cli 2.59.1 → 2.59.2

package/dist/chunk-Crb4y7t4.js

@@ -0,0 +1,830 @@
+#!/usr/bin/env node
+import { F as getCliVersion } from "./index.js";
+import { n as RUNTYPE_ATTRIBUTES, r as GEN_AI_ATTRIBUTES, t as GEN_AI_CONTENT_ATTRIBUTES } from "./chunk-R265bzj9.js";
+import { n as HARNESS_BINDING_HEADER, t as HARNESS_ATTRIBUTES } from "./chunk-Bu0FJr6S.js";
+import { t as HARNESS_LIMITS } from "./chunk-0x7UKC1U.js";
+import { n as redactObservation, t as redactHarnessValue } from "./chunk-KcqPQJBi.js";
+import { join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+// src/lib/local-harness/delivery/otlp.ts
+function harnessSpanId(traceId, identity) {
+	return createHash("sha256").update(`${traceId}:${identity}`).digest("hex").slice(0, 16);
+}
+function makeHarnessSpan(input, identity, operation, attributes, start, end, status, root = false) {
+	const full = {
+		[GEN_AI_ATTRIBUTES.operationName]: operation,
+		[RUNTYPE_ATTRIBUTES.executionId]: input.binding.executionId,
+		[HARNESS_ATTRIBUTES.version]: 1,
+		[HARNESS_ATTRIBUTES.sessionId]: input.sessionId,
+		[HARNESS_ATTRIBUTES.turnId]: input.turnId,
+		...attributes
+	};
+	return {
+		traceId: input.binding.traceId,
+		spanId: harnessSpanId(input.binding.traceId, identity),
+		...root ? {} : { parentSpanId: harnessSpanId(input.binding.traceId, "root") },
+		name: operation,
+		kind: 1,
+		startTimeUnixNano: String(BigInt(Math.trunc(start)) * 1000000n),
+		endTimeUnixNano: String(BigInt(Math.trunc(end)) * 1000000n),
+		attributes: Object.entries(full).filter(([, value]) => value !== void 0).map(([key, value]) => ({
+			key,
+			value: typeof value === "boolean" ? { boolValue: value } : typeof value === "number" && Number.isFinite(value) ? { doubleValue: value } : { stringValue: typeof value === "string" ? value : JSON.stringify(value) }
+		})),
+		status: { code: status }
+	};
+}
+function observationSpan(input, observation, sequence, observedAt) {
+	return makeHarnessSpan(input, `event:${sequence}`, "harness.observation", {
+		[HARNESS_ATTRIBUTES.sequence]: sequence,
+		[HARNESS_ATTRIBUTES.eventId]: `${input.turnId}:${sequence}`,
+		[HARNESS_ATTRIBUTES.nativeId]: observation.nativeId,
+		[HARNESS_ATTRIBUTES.nativeSessionId]: observation.nativeSessionId,
+		[HARNESS_ATTRIBUTES.nativeTurnId]: observation.nativeTurnId,
+		[HARNESS_ATTRIBUTES.parentId]: observation.parentId,
+		[HARNESS_ATTRIBUTES.usage]: observation.usage,
+		[HARNESS_ATTRIBUTES.toolUpdate]: observation.tool ? {
+			id: observation.tool.id,
+			name: observation.tool.name,
+			nativeName: observation.tool.nativeName,
+			mcpServer: observation.tool.mcpServer,
+			mcpTool: observation.tool.mcpTool,
+			status: observation.tool.status,
+			durationMs: observation.tool.durationMs
+		} : void 0,
+		...input.dataPolicy === "metrics" ? {} : { [HARNESS_ATTRIBUTES.nativeContent]: observation }
+	}, observedAt, observedAt, 0);
+}
+function toolSpan(input, tool, observedStart, observedEnd) {
+	const durationKnown = typeof tool.durationMs === "number" && Number.isFinite(tool.durationMs) && tool.durationMs >= 0;
+	const ended = Number.isFinite(tool.endedAt) ? tool.endedAt : observedEnd;
+	const started = durationKnown ? ended - tool.durationMs : Number.isFinite(tool.startedAt) ? tool.startedAt : observedStart;
+	return makeHarnessSpan(input, `tool:${tool.id}`, "execute_tool", {
+		[GEN_AI_ATTRIBUTES.toolCallId]: tool.id,
+		[GEN_AI_ATTRIBUTES.toolName]: tool.name ?? tool.nativeName ?? "unknown",
+		[GEN_AI_ATTRIBUTES.toolType]: tool.mcpServer ? "mcp" : "function",
+		[HARNESS_ATTRIBUTES.nativeId]: tool.id,
+		[HARNESS_ATTRIBUTES.toolOutcome]: tool.status === "succeeded" ? "success" : tool.status === "failed" ? "failed" : "unknown",
+		[HARNESS_ATTRIBUTES.durationKnown]: durationKnown,
+		...input.dataPolicy === "metrics" ? {} : {
+			[GEN_AI_CONTENT_ATTRIBUTES.toolCallArguments]: tool.input,
+			[GEN_AI_CONTENT_ATTRIBUTES.toolCallResult]: tool.output ?? tool.error
+		}
+	}, started, Math.max(started, ended), tool.status === "failed" ? 2 : tool.status === "succeeded" ? 1 : 0);
+}
+function harnessExport(spans, agentId) {
+	return { resourceSpans: [{
+		resource: { attributes: [
+			{
+				key: RUNTYPE_ATTRIBUTES.agentId,
+				value: { stringValue: agentId }
+			},
+			{
+				key: RUNTYPE_ATTRIBUTES.adapterName,
+				value: { stringValue: "runtype-local-harness" }
+			},
+			{
+				key: RUNTYPE_ATTRIBUTES.adapterVersion,
+				value: { stringValue: getCliVersion() }
+			}
+		] },
+		scopeSpans: [{
+			scope: {
+				name: "runtype.local-harness",
+				version: "1"
+			},
+			spans
+		}]
+	}] };
+}
+// src/lib/local-harness/delivery/spool.ts
+/** Private bounded retry storage contains already-redacted spans, never authentication headers. */
+var HarnessSpool = class {
+	directory;
+	maxBytes;
+	queuedBytes = 0;
+	initialization;
+	constructor(directory, maxBytes = HARNESS_LIMITS.maxSpoolBytes) {
+		this.directory = directory;
+		this.maxBytes = maxBytes;
+	}
+	get bytes() {
+		return this.queuedBytes;
+	}
+	initialize() {
+		this.initialization ??= (async () => {
+			await mkdir(this.directory, {
+				recursive: true,
+				mode: 448
+			});
+			for (const name of await readdir(this.directory)) {
+				if (!/^[0-9a-f-]+\.json$/.test(name)) continue;
+				const path = join(this.directory, name);
+				const info = await stat(path);
+				if (Date.now() - info.mtimeMs > HARNESS_LIMITS.spoolRetentionMs) await rm(path);
+				else this.queuedBytes += info.size;
+			}
+		})();
+		return this.initialization;
+	}
+	async put(body) {
+		await this.initialize();
+		const serialized = JSON.stringify(body);
+		const bytes = Buffer.byteLength(serialized);
+		if (bytes > HARNESS_LIMITS.maxBatchBytes || this.queuedBytes + bytes > this.maxBytes) throw new Error("Harness telemetry spool capacity exceeded");
+		this.queuedBytes += bytes;
+		const path = join(this.directory, `${randomUUID()}.json`);
+		try {
+			await writeFile(path, serialized, {
+				mode: 384,
+				flag: "wx"
+			});
+		} catch (error) {
+			this.queuedBytes -= bytes;
+			throw error;
+		}
+		return {
+			path,
+			bytes
+		};
+	}
+	async acknowledge(entry) {
+		await rm(entry.path, { force: true });
+		this.queuedBytes -= entry.bytes;
+	}
+	async read(entry) {
+		return JSON.parse(await readFile(entry.path, "utf8"));
+	}
+};
+function ingestFullyAccepted(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	const partial = record.partialSuccess ?? record.partial_success;
+	if (partial === void 0) return true;
+	if (typeof partial !== "object" || partial === null) return false;
+	const rejected = partial.rejectedSpans ?? partial.rejected_spans;
+	return rejected === void 0 || rejected === 0 || rejected === "0";
+}
+// ../model-execution/src/base64.ts
+/**
+* Base64 helpers shared by the asset offload/rehydrate walk and the tool-result media-handle walk.
+* Workers/Node/browser safe: prefers `Buffer` when present, falls back to `atob` / `btoa`.
+* Internal to this package on purpose, not re-exported from the barrel.
+*/
+function base64ToBytes(base64) {
+	const bufferCtor = globalThis.Buffer;
+	if (bufferCtor) return new Uint8Array(bufferCtor.from(base64, "base64"));
+	const binary = atob(base64);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+/**
+* True when a string is plausibly raw base64 (alphabet + padding only).
+* `Buffer.from(str, 'base64')` silently drops non-alphabet characters rather than throwing.
+* This predicate is the guard that keeps non-base64 text out of byte-level paths.
+*/
+function looksLikeBase64(value) {
+	return value.length >= 16 && /^[A-Za-z0-9+/]+={0,2}$/.test(value);
+}
+/** Lowercase hex of a digest, signature or random buffer. */
+function bufferToHex(buffer) {
+	let hex = "";
+	for (const byte of new Uint8Array(buffer)) hex += byte.toString(16).padStart(2, "0");
+	return hex;
+}
+// ../model-execution/src/media-part-descriptor.ts
+function payloadOf(part) {
+	return part.image ?? part.data;
+}
+function declaredMimeType(part) {
+	if (typeof part.mimeType === "string" && part.mimeType.length > 0) return part.mimeType;
+	if (typeof part.mediaType === "string" && part.mediaType.length > 0) return part.mediaType;
+}
+function inlineBytes(payload) {
+	if (payload instanceof Uint8Array) return { bytes: payload };
+	if (payload instanceof ArrayBuffer) return { bytes: new Uint8Array(payload) };
+	if (ArrayBuffer.isView(payload)) return { bytes: new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength) };
+	if (typeof payload !== "string") return void 0;
+	if (payload.startsWith("data:")) {
+		const match = /^data:([^;,]*)(?:;[^,]*)?;base64,(.*)$/s.exec(payload);
+		if (!match) return void 0;
+		const bytes = base64ToBytes(match[2] ?? "");
+		return match[1] ? {
+			bytes,
+			mimeType: match[1]
+		} : { bytes };
+	}
+	return looksLikeBase64(payload) ? { bytes: base64ToBytes(payload) } : void 0;
+}
+/** Web Crypto takes no view over a `SharedArrayBuffer`; such bytes are copied first. */
+function ownedBytes(bytes) {
+	return isArrayBufferBacked(bytes) ? bytes : new Uint8Array(bytes);
+}
+function isArrayBufferBacked(bytes) {
+	return bytes.buffer instanceof ArrayBuffer;
+}
+/** Message and tool-result part types whose `image` or `data` field can carry inline bytes. */
+const MEDIA_PART_TYPES = /* @__PURE__ */ new Set([
+	"image",
+	"file",
+	"media",
+	"audio",
+	"video",
+	"image-data",
+	"file-data"
+]);
+/** Past this nesting depth a value is left as-is; real message and tool-result shapes sit far above it. */
+const MAX_DESCRIBE_DEPTH = 8;
+function isMediaPart(part) {
+	if (part === null || typeof part !== "object") return false;
+	const type = part.type;
+	return typeof type === "string" && MEDIA_PART_TYPES.has(type);
+}
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* The descriptor for a media part whose payload is inline bytes (a
+* `Uint8Array`, an `ArrayBuffer`, a base64 data URL or raw base64), or
+* `undefined` for a URL reference or any other value.
+*/
+async function describeMediaPart(part) {
+	if (!isMediaPart(part)) return void 0;
+	let media;
+	try {
+		media = inlineBytes(payloadOf(part));
+	} catch {
+		return;
+	}
+	if (!media) return void 0;
+	const digest = await crypto.subtle.digest("SHA-256", ownedBytes(media.bytes));
+	const mimeType = declaredMimeType(part) ?? media.mimeType;
+	return {
+		type: part.type,
+		...mimeType ? { mimeType } : {},
+		...typeof part.filename === "string" && part.filename.length > 0 ? { filename: part.filename } : {},
+		bytes: media.bytes.byteLength,
+		sha256: bufferToHex(digest)
+	};
+}
+/**
+* `value` with every inline media part, at any depth of arrays and plain
+* objects (messages, tool results, MCP `content` envelopes), replaced by its
+* descriptor. A value holding no inline media comes back as the same reference.
+*/
+async function describeInlineMedia(value, depth = 0) {
+	if (depth > MAX_DESCRIBE_DEPTH) return value;
+	if (isMediaPart(value)) return await describeMediaPart(value) ?? value;
+	if (Array.isArray(value)) {
+		const items = await Promise.all(value.map((item) => describeInlineMedia(item, depth + 1)));
+		return items.some((item, index) => item !== value[index]) ? items : value;
+	}
+	if (!isPlainObject(value)) return value;
+	const entries = Object.entries(value);
+	const described = await Promise.all(entries.map(([, item]) => describeInlineMedia(item, depth + 1)));
+	if (described.every((item, index) => item === entries[index][1])) return value;
+	return Object.fromEntries(entries.map(([key], index) => [key, described[index]]));
+}
+// src/lib/local-harness/delivery/media.ts
+const MEDIA_TYPES = /* @__PURE__ */ new Set([
+	"image",
+	"file",
+	"media",
+	"audio",
+	"video",
+	"image-data",
+	"file-data"
+]);
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** Describe native and JSON-encoded MCP media before telemetry serialization. */
+async function normalizeHarnessMedia(value, timeoutMs = 1e3) {
+	let truncated = false;
+	let visited = 0;
+	let expired = false;
+	const describe = async (part) => {
+		const payloadKey = part.image !== void 0 ? "image" : "data";
+		const payload = part[payloadKey];
+		const inline = typeof payload === "string" ? !/^https?:\/\//.test(payload) : payload instanceof ArrayBuffer || ArrayBuffer.isView(payload);
+		if (inline && typeof payload === "string") {
+			const encoded = payload.startsWith("data:") ? /^data:[^,]*;base64,(.*)$/s.exec(payload)?.[1] : payload;
+			if (encoded === void 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.length % 4 === 1) throw new Error("Inline media could not be described");
+		}
+		const candidate = typeof payload === "string" && !payload.startsWith("data:") && inline ? {
+			...part,
+			[payloadKey]: `data:${String(part.mimeType ?? part.mediaType ?? "application/octet-stream")};base64,${payload}`
+		} : part;
+		const described = await describeInlineMedia(candidate);
+		if (inline && described === candidate) throw new Error("Inline media could not be described");
+		return described;
+	};
+	const walk = async (item, depth) => {
+		if (expired) throw new Error("Media normalization deadline exceeded");
+		if (depth > 24 || ++visited > 2e4) {
+			truncated = true;
+			return "[capture nesting limit]";
+		}
+		if (typeof item === "string") {
+			if (/^\s*[[{]/.test(item)) {
+				let parsed;
+				try {
+					parsed = JSON.parse(item);
+				} catch {
+					return item;
+				}
+				return JSON.stringify(await walk(parsed, depth + 1));
+			}
+			if (item.startsWith("data:") && item.includes(";base64,")) return describe({
+				type: "media",
+				data: item
+			});
+			return item;
+		}
+		if (Array.isArray(item)) {
+			const result = [];
+			for (const child of item) result.push(await walk(child, depth + 1));
+			return result;
+		}
+		if (!object(item)) return item;
+		const source = object(item.source) ? item.source : void 0;
+		const imageUrl = object(item.image_url) ? item.image_url.url : item.image_url;
+		const audio = object(item.input_audio) ? item.input_audio : void 0;
+		const candidate = source?.type === "base64" && typeof source.data === "string" ? {
+			type: item.type === "document" ? "file" : MEDIA_TYPES.has(String(item.type)) ? item.type : "media",
+			data: source.data,
+			mimeType: source.media_type,
+			filename: item.filename
+		} : item.type === "base64" && typeof item.data === "string" ? {
+			type: "media",
+			data: item.data,
+			mimeType: item.media_type
+		} : ["input_image", "image_url"].includes(String(item.type)) && typeof imageUrl === "string" ? {
+			type: "image",
+			image: imageUrl
+		} : item.type === "input_audio" && audio ? {
+			type: "audio",
+			data: audio.data,
+			mimeType: typeof audio.format === "string" ? `audio/${audio.format}` : void 0
+		} : item.type === "input_file" && item.file_data !== void 0 ? {
+			type: "file",
+			data: item.file_data,
+			filename: item.filename
+		} : item;
+		if (MEDIA_TYPES.has(String(candidate.type))) {
+			const described = await describe(candidate);
+			if (described !== candidate) return described;
+		}
+		const entries = [];
+		for (const [key, child] of Object.entries(item)) entries.push([key, await walk(child, depth + 1)]);
+		return Object.fromEntries(entries);
+	};
+	let timer;
+	try {
+		return await Promise.race([walk(value, 0).then((normalized) => ({
+			value: normalized,
+			truncated
+		})), new Promise((_, reject) => {
+			timer = setTimeout(() => {
+				expired = true;
+				reject(/* @__PURE__ */ new Error("Media normalization deadline exceeded"));
+			}, Math.max(1, timeoutMs));
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+// src/lib/local-harness/delivery/index.ts
+const STREAM_RELEASE_CHARS = 32768;
+const STREAM_BUFFER_CAP_CHARS = 36864;
+const STREAM_HOLDBACK_CHARS = 1024;
+function continuesStream(current, next) {
+	return current.message?.role === next.message?.role && current.nativeSessionId === next.nativeSessionId && current.nativeTurnId === next.nativeTurnId && current.parentId === next.parentId;
+}
+/**
+* Where a long joined stream may be released: before any known secret straddling the cut and at a
+* word start, so a pattern-matched credential still arriving in later deltas is never split.
+* Returns 0 when no safe boundary exists. A holdback of 0 releases up to the final unfinished word.
+*/
+function streamCut(text, secrets, holdback = STREAM_HOLDBACK_CHARS) {
+	const longest = Math.max(0, ...secrets.map((secret) => secret.length));
+	let cut = Math.max(0, text.length - Math.max(longest, holdback));
+	for (let moved = true; moved && cut > 0;) {
+		moved = false;
+		for (const secret of secrets) {
+			if (secret.length < 2) continue;
+			const start = text.indexOf(secret, Math.max(0, cut - secret.length + 1));
+			if (start >= 0 && start < cut) {
+				cut = start;
+				moved = true;
+			}
+		}
+	}
+	const line = text.lastIndexOf("\n", cut - 1);
+	if (holdback > 0 && line >= 0 && cut - line < holdback) cut = line + 1;
+	while (cut > 0 && !/\s/.test(text[cut - 1])) cut -= 1;
+	const scheme = /\bbearer\s+$/i.exec(text.slice(Math.max(0, cut - 64), cut));
+	return scheme ? cut - (Math.min(cut, 64) - scheme.index) : cut;
+}
+function createHarnessCaptureFactory(options) {
+	const spool = new HarnessSpool(options.spoolDirectory);
+	const now = options.now ?? Date.now;
+	let pendingBatches = 0;
+	let deliveryFailures = 0;
+	const factory = (originalInput) => {
+		const ranks = {
+			metrics: 0,
+			redacted: 1,
+			full: 2
+		};
+		const dataPolicy = ranks[originalInput.dataPolicy] < ranks[originalInput.binding.dataPolicy] ? originalInput.dataPolicy : originalInput.binding.dataPolicy;
+		const input = {
+			...originalInput,
+			dataPolicy,
+			provenance: {
+				...originalInput.provenance,
+				cliVersion: getCliVersion()
+			}
+		};
+		const started = now();
+		const secrets = [...options.secrets ?? [], input.binding.token];
+		const tools = /* @__PURE__ */ new Map();
+		const coverage = {
+			...input.provenance.coverage,
+			content: { state: dataPolicy === "metrics" ? "disabled" : "available" }
+		};
+		let sequence = 0;
+		let bytes = 0;
+		let dropped = 0;
+		let delivered = 0;
+		let failed = false;
+		let finalAccepted = false;
+		let flushDeadline = Infinity;
+		let finishDeadline = Infinity;
+		let drainTimer;
+		let expireDrain;
+		const drainExpired = new Promise((resolve) => {
+			expireDrain = resolve;
+		});
+		let finished;
+		let pending = [];
+		let pendingBytes = 0;
+		let chain = Promise.resolve();
+		let normalization = Promise.resolve();
+		let admittedBytes = 0;
+		let omittedFragments = 0;
+		const post = async (body, deadline, final) => {
+			let timer;
+			try {
+				return await Promise.race([
+					options.client.post("/otel/v1/traces", body, { [HARNESS_BINDING_HEADER]: input.binding.token }, { timeoutMs: Math.max(1, deadline - now()) }),
+					new Promise((_, reject) => {
+						timer = setTimeout(() => reject(/* @__PURE__ */ new Error("Harness evidence delivery deadline exceeded")), Math.max(0, deadline - now()));
+					}),
+					...final ? [] : [drainExpired.then(() => {
+						throw new Error("Harness evidence drain deadline exceeded");
+					})]
+				]);
+			} finally {
+				if (timer) clearTimeout(timer);
+			}
+		};
+		const enqueue = (spans, count, final = false) => {
+			pendingBatches += 1;
+			chain = chain.then(async () => {
+				try {
+					if (failed && !final) return;
+					const entry = await spool.put(harnessExport(spans, options.agentId));
+					const deadline = Math.min(final ? finishDeadline : flushDeadline, input.binding.expiresAt, now() + (options.deliveryTimeoutMs ?? HARNESS_LIMITS.deliveryTimeoutMs));
+					let accepted = false;
+					for (let attempt = 0; attempt < 3 && now() < deadline; attempt += 1) try {
+						if (!ingestFullyAccepted(await post(await spool.read(entry), deadline, final))) break;
+						accepted = true;
+						break;
+					} catch {
+						if (attempt < 2 && now() < deadline && (final || now() < flushDeadline)) await new Promise((resolve) => setTimeout(resolve, Math.min(100 * (attempt + 1), deadline - now())));
+						if (!final && now() >= flushDeadline) break;
+					}
+					if (!accepted) {
+						failed = true;
+						deliveryFailures += 1;
+						return;
+					}
+					await spool.acknowledge(entry);
+					delivered += count;
+					if (final) finalAccepted = true;
+				} catch {
+					failed = true;
+					deliveryFailures += 1;
+				} finally {
+					pendingBatches -= 1;
+				}
+			});
+		};
+		const flush = () => {
+			if (!pending.length) return;
+			enqueue(pending, pending.filter((span) => span.name === "harness.observation").length);
+			pending = [];
+			pendingBytes = 0;
+		};
+		const append = (span) => {
+			const size = Buffer.byteLength(JSON.stringify(span));
+			if (size > HARNESS_LIMITS.maxEventBytes) {
+				dropped += 1;
+				coverage.content = {
+					state: "truncated",
+					reason: "Event exceeded the capture byte limit"
+				};
+				return;
+			}
+			if (pendingBytes + size > 131072) flush();
+			pending.push(span);
+			pendingBytes += size;
+			if (pending.length >= 16) flush();
+		};
+		const admit = (raw) => {
+			if (finished) return;
+			const observedSequence = ++sequence;
+			const timestamp = now();
+			if (failed || sequence > 1e3) {
+				dropped += 1;
+				coverage.delivery = {
+					state: "partial",
+					reason: "Capture capacity or delivery failed"
+				};
+				return;
+			}
+			let snapshot;
+			try {
+				const admitted = dataPolicy === "metrics" ? redactObservation(raw, dataPolicy, secrets).observation : raw;
+				const size = Buffer.byteLength(JSON.stringify(admitted));
+				if (size > HARNESS_LIMITS.maxEventBytes || admittedBytes + size > HARNESS_LIMITS.maxTurnBytes) {
+					dropped += 1;
+					coverage.content = {
+						state: "truncated",
+						reason: "Turn capture byte limit reached"
+					};
+					return;
+				}
+				admittedBytes += size;
+				snapshot = structuredClone(admitted);
+			} catch {
+				dropped += 1;
+				coverage.content = {
+					state: "partial",
+					reason: "An observation could not be serialized"
+				};
+				return;
+			}
+			normalization = normalization.then(async () => {
+				try {
+					if (now() >= flushDeadline) throw new Error("Capture normalization deadline exceeded");
+					const normalized = dataPolicy === "metrics" ? {
+						value: snapshot,
+						truncated: false
+					} : await normalizeHarnessMedia(snapshot, Math.min(1e3, flushDeadline - now()));
+					const redacted = redactObservation(normalized.value, dataPolicy, secrets);
+					const observation = redacted.observation;
+					if (normalized.truncated) coverage.content = {
+						state: "truncated",
+						reason: "Content exceeded capture nesting limits"
+					};
+					else if (redacted.changed && dataPolicy !== "metrics" && coverage.content?.state === "available") coverage.content = { state: "redacted" };
+					const size = Buffer.byteLength(JSON.stringify(observation));
+					if (size > HARNESS_LIMITS.maxEventBytes || bytes + size > HARNESS_LIMITS.maxTurnBytes) {
+						dropped += 1;
+						coverage.content = {
+							state: "truncated",
+							reason: "Turn capture byte limit reached"
+						};
+						return;
+					}
+					bytes += size;
+					if (observation.tool) {
+						const tool = observation.tool;
+						const prior = tools.get(tool.id);
+						const values = Object.fromEntries(Object.entries(tool).filter(([, value]) => value !== void 0));
+						const merged = {
+							...prior?.value,
+							...values
+						};
+						if (prior?.value.status === "failed") merged.status = "failed";
+						else if (prior?.value.status === "succeeded" && [
+							"running",
+							"pending",
+							"unknown"
+						].includes(merged.status)) merged.status = "succeeded";
+						tools.set(tool.id, {
+							value: merged,
+							first: prior?.first ?? timestamp,
+							last: timestamp
+						});
+					}
+					append(observationSpan(input, observation, observedSequence, timestamp));
+					if (observation.tool) flush();
+				} catch {
+					dropped += 1;
+					coverage.content = {
+						state: "partial",
+						reason: "An observation could not be normalized"
+					};
+				}
+			});
+		};
+		let stream;
+		const releaseStream = (text) => {
+			if (!stream || !text) return;
+			admit({
+				...stream.observation,
+				message: {
+					...stream.observation.message,
+					content: text,
+					delta: true
+				}
+			});
+		};
+		const flushStream = () => {
+			if (stream) releaseStream(stream.text);
+			stream = void 0;
+		};
+		const observe = (raw) => {
+			if (finished) return;
+			if (dataPolicy === "metrics") return admit(raw);
+			if (raw.fragment) {
+				omittedFragments += 1;
+				return;
+			}
+			const message = raw.message;
+			if (!message?.delta || typeof message.content !== "string") {
+				flushStream();
+				return admit(raw);
+			}
+			if (!stream || !continuesStream(stream.observation, raw)) {
+				flushStream();
+				stream = {
+					observation: raw,
+					text: "",
+					withholding: false
+				};
+			}
+			let text = message.content;
+			if (stream.withholding) {
+				text = text.replace(/^\S+/, "");
+				if (!text) return;
+				stream.withholding = false;
+			}
+			stream.text += text;
+			if (stream.text.length < STREAM_RELEASE_CHARS) return;
+			const capped = stream.text.length >= STREAM_BUFFER_CAP_CHARS;
+			const cut = streamCut(stream.text, secrets, capped ? 0 : STREAM_HOLDBACK_CHARS);
+			if (cut > 0) {
+				releaseStream(stream.text.slice(0, cut));
+				stream.text = stream.text.slice(cut);
+				return;
+			}
+			if (!capped) return;
+			dropped += 1;
+			coverage.content = {
+				state: "truncated",
+				reason: "Streamed text without a word break exceeded the capture window"
+			};
+			stream.text = "";
+			stream.withholding = true;
+		};
+		const finish = (result) => {
+			if (!finished) flushStream();
+			finished ??= (async () => {
+				const budget = options.deliveryTimeoutMs ?? HARNESS_LIMITS.deliveryTimeoutMs;
+				finishDeadline = now() + budget - Math.min(250, budget / 10);
+				flushDeadline = finishDeadline - Math.min(1e3, budget / 4);
+				drainTimer = setTimeout(expireDrain, Math.max(0, flushDeadline - now()));
+				await normalization;
+				if (result.coverage) {
+					for (const [field, value] of Object.entries(result.coverage)) if (!coverage[field] || coverage[field].state === "available") coverage[field] = value;
+				}
+				let unresolvedTools = 0;
+				const toolCalls = [];
+				for (const { value: tool, first, last } of tools.values()) {
+					const isError = tool.status === "failed" ? true : tool.status === "succeeded" ? false : void 0;
+					if (isError === void 0) unresolvedTools += 1;
+					append(toolSpan(input, tool, first, last));
+					toolCalls.push({
+						id: tool.id,
+						name: tool.name ?? tool.nativeName ?? "unknown",
+						...tool.input === void 0 ? {} : { input: tool.input },
+						...tool.output === void 0 ? {} : { output: tool.output },
+						...isError === void 0 ? {} : { isError },
+						...tool.durationMs === void 0 ? {} : { durationMs: tool.durationMs }
+					});
+				}
+				flush();
+				if (omittedFragments && (coverage.native?.state ?? "available") === "available") coverage.native = {
+					state: "partial",
+					reason: "Raw stream fragments are omitted; their text is kept as joined messages."
+				};
+				if (unresolvedTools) coverage.tools = {
+					state: "partial",
+					reason: "Some tool outcomes are unknown"
+				};
+				let rootContent;
+				let safeProvenance;
+				try {
+					const finalContent = {
+						provenance: {
+							...input.provenance,
+							configuration: dataPolicy === "metrics" ? {} : input.provenance.configuration
+						},
+						...dataPolicy === "metrics" ? {} : { content: {
+							finalText: result.text,
+							reportedUsage: result.reportedUsage
+						} }
+					};
+					if (Buffer.byteLength(JSON.stringify(finalContent)) > HARNESS_LIMITS.maxEventBytes) throw new Error("Final content exceeded the capture byte limit");
+					const normalized = await normalizeHarnessMedia(finalContent, Math.min(1e3, Math.max(1, flushDeadline - now())));
+					const safe = redactHarnessValue(normalized.value, dataPolicy, secrets).value;
+					safeProvenance = safe.provenance;
+					rootContent = safe.content;
+					if (normalized.truncated) coverage.content = {
+						state: "truncated",
+						reason: "Content exceeded capture nesting limits"
+					};
+				} catch {
+					coverage.content = {
+						state: "partial",
+						reason: "Final content could not be normalized"
+					};
+					coverage.delivery = {
+						state: "partial",
+						reason: "Final content was omitted"
+					};
+					dropped += 1;
+				}
+				await chain;
+				if (drainTimer) clearTimeout(drainTimer);
+				if (failed || dropped) coverage.delivery = {
+					state: "partial",
+					reason: "Some evidence was not durably accepted"
+				};
+				const summary = {
+					version: 1,
+					traceId: input.binding.traceId,
+					executionId: input.binding.executionId,
+					delivery: failed ? "failed" : dropped ? "partial" : "accepted",
+					dataPolicy,
+					coverage,
+					observedEvents: sequence,
+					deliveredEvents: Math.min(sequence, delivered),
+					droppedEvents: dropped,
+					unresolvedTools
+				};
+				const root = makeHarnessSpan(input, "root", "invoke_agent", {
+					[HARNESS_ATTRIBUTES.summary]: summary,
+					[HARNESS_ATTRIBUTES.coverage]: coverage,
+					[HARNESS_ATTRIBUTES.provenance]: safeProvenance,
+					...dataPolicy === "metrics" ? {} : { [HARNESS_ATTRIBUTES.nativeContent]: rootContent }
+				}, started, now(), result.status === "completed" ? 1 : result.status === "failed" ? 2 : 0, true);
+				enqueue([root], 0, true);
+				await chain;
+				if (failed && !finalAccepted) {
+					summary.delivery = "failed";
+					summary.coverage.delivery = {
+						state: "partial",
+						reason: "Final evidence was not durably accepted"
+					};
+				}
+				while (Buffer.byteLength(JSON.stringify(toolCalls)) > HARNESS_LIMITS.maxControlReplyBytes / 2) {
+					toolCalls.pop();
+					summary.coverage.controlProjection = {
+						state: "truncated",
+						reason: "Read the canonical trace for remaining tool evidence"
+					};
+				}
+				return {
+					summary,
+					toolCalls,
+					...result.reportedUsage ? { reportedUsage: result.reportedUsage } : {}
+				};
+			})().finally(() => {
+				if (drainTimer) clearTimeout(drainTimer);
+			});
+			return finished;
+		};
+		return {
+			async prepare() {
+				if (!ingestFullyAccepted(await options.client.post("/otel/v1/traces", { resourceSpans: [] }, { [HARNESS_BINDING_HEADER]: input.binding.token }, { timeoutMs: HARNESS_LIMITS.deliveryTimeoutMs }))) throw new Error("Harness turn authorization was refused");
+			},
+			observe,
+			finish
+		};
+	};
+	factory.status = () => ({
+		queuedBytes: spool.bytes,
+		pendingBatches,
+		deliveryFailures
+	});
+	return factory;
+}
+export { createHarnessCaptureFactory, streamCut };
+