@tangle-network/sdk-telemetry 0.7.5 → 0.7.6

package/dist/index.mjs

@@ -1,5 +1,285 @@
 import { PROVISION_TRACE_ID_HEADER, SpanRecorder, isAdoptablePtid, mintPtid } from "./stage-span.mjs";
-import { GEN_AI_CONVERSATION_ID, GEN_AI_CONVERSATION_ID as GEN_AI_CONVERSATION_ID$1, GEN_AI_INPUT_TOKEN_KEYS, GEN_AI_MODEL_KEYS, GEN_AI_OPERATION_NAME, GEN_AI_OUTPUT_TOKEN_KEYS, GEN_AI_REQUEST_MODEL, GEN_AI_REQUEST_MODEL as GEN_AI_REQUEST_MODEL$1, GEN_AI_RESPONSE_MODEL, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_INPUT_TOKENS as GEN_AI_USAGE_INPUT_TOKENS$1, GEN_AI_USAGE_OUTPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS as GEN_AI_USAGE_OUTPUT_TOKENS$1, SSEChunkParser, TOKEN_USAGE_INPUT_KEYS, TOKEN_USAGE_OUTPUT_KEYS, createStreamUsageExtractor, firstTokenCount, genAiUsageAttributes, isFilePart, isReasoningPart, isTextPart, isToolPart, isToolPart as isToolPart$1, tokenCount } from "@tangle-network/agent-core";
+import { GEN_AI_CONVERSATION_ID, GEN_AI_CONVERSATION_ID as GEN_AI_CONVERSATION_ID$1, GEN_AI_INPUT_TOKEN_KEYS, GEN_AI_MODEL_KEYS, GEN_AI_OPERATION_NAME, GEN_AI_OUTPUT_TOKEN_KEYS, GEN_AI_REQUEST_MODEL, GEN_AI_REQUEST_MODEL as GEN_AI_REQUEST_MODEL$1, GEN_AI_RESPONSE_MODEL, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_INPUT_TOKENS as GEN_AI_USAGE_INPUT_TOKENS$1, GEN_AI_USAGE_OUTPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS as GEN_AI_USAGE_OUTPUT_TOKENS$1, SSEChunkParser, TOKEN_USAGE_INPUT_KEYS, TOKEN_USAGE_OUTPUT_KEYS, createStreamUsageExtractor, firstTokenCount, firstTokenCount as firstTokenCount$1, genAiUsageAttributes, isFilePart, isReasoningPart, isTextPart, isToolPart, isToolPart as isToolPart$1, readTokenUsage, tokenCount } from "@tangle-network/agent-core";
+import { CACHE_READ_TOKEN_ATTR_KEYS, CACHE_WRITE_TOKEN_ATTR_KEYS, REASONING_TOKEN_ATTR_KEYS, contractSpan, llmSpan, toW3CSpanId, toolSpan } from "@tangle-network/agent-trace-contract";
+//#region src/contract-spans.ts
+/**
+* One execution's `TraceEvent`s as `@tangle-network/agent-trace-contract`
+* spans, which any OTLP-JSONL reader takes without an adapter.
+*
+* The execution is an `invoke_agent` AGENT span. Each model turn the harness
+* reported is an `llm.turn` span with that turn's usage, and each message,
+* reasoning part and tool call is a span inside the turn it happened in. Names
+* and attributes follow `@tangle-network/harness-sessions` (`tool.<name>`,
+* `input.value`, `output.value`), so a live execution and a session file of
+* the same harness read alike. Unreported usage carries no token attribute and
+* an unreported tool end keeps an unset status: unknown is never zero. A patch
+* ends when a file part reports the last file it lists written, as a Sandbox
+* reports a Codex patch landing. Span ids derive from the execution id, so a
+* writer can rewrite its file instead of appending.
+*/
+const OK = { code: "STATUS_CODE_OK" };
+const UNSET = { code: "STATUS_CODE_UNSET" };
+const ENDED = new Set([
+	"completed",
+	"error",
+	"failed"
+]);
+/** Project one execution's events: the execution span, then each span in the order its first event arrived. */
+function executionTraceToContractSpans(trace, context) {
+	const chars = context.contentChars ?? 8e3;
+	const content = (key, value) => {
+		const text = typeof value === "string" ? value : JSON.stringify(value) ?? "";
+		return chars > 0 && value != null && text.length > 0 ? { [key]: cap(text, chars) } : {};
+	};
+	const id = (key) => toW3CSpanId(`${trace.id}:${key}`);
+	const executionId = id("execution");
+	const first = trace.events[0]?.timestamp ?? trace.startedAt;
+	const last = trace.events.at(-1)?.timestamp ?? trace.completedAt ?? first;
+	const spans = [];
+	const turns = [];
+	const messages = /* @__PURE__ */ new Map();
+	const tools = /* @__PURE__ */ new Map();
+	const unwritten = /* @__PURE__ */ new Map();
+	let openTurn;
+	let model;
+	let profile;
+	let sandboxId;
+	let harness;
+	let finalText;
+	let resultUsage;
+	let outcome;
+	let error;
+	let base = { traceId: context.traceId };
+	let shared = {};
+	const startTurn = (start) => {
+		const turn = {
+			spanId: id(`turn:${turns.length}`),
+			end: start,
+			status: UNSET
+		};
+		turns.push(turn);
+		spans.push(() => llmSpan({
+			...base,
+			spanId: turn.spanId,
+			parentSpanId: executionId,
+			name: "llm.turn",
+			startTime: start.toISOString(),
+			endTime: turn.end.toISOString(),
+			status: turn.status,
+			...model ? { model } : {},
+			...turn.usage ? {
+				inputTokens: turn.usage.inputTokens,
+				outputTokens: turn.usage.outputTokens
+			} : {},
+			attributes: {
+				...shared,
+				...usageDetail(turn.usage)
+			}
+		}));
+		return turn;
+	};
+	for (const event of trace.events) {
+		const at = event.timestamp;
+		if (openTurn !== void 0) openTurn.end = at;
+		const parentSpanId = openTurn?.spanId ?? executionId;
+		if (event.type === "message.part.updated") {
+			const part = event.part;
+			if (isTextPart(part) || isReasoningPart(part)) {
+				const held = messages.get(part.id);
+				if (held !== void 0 && part.text.startsWith(held.text)) Object.assign(held, {
+					text: part.text,
+					end: at
+				});
+				else if (part.text.length > 0) {
+					const kind = isTextPart(part) ? "assistant" : "reasoning";
+					const message = {
+						text: part.text,
+						end: at
+					};
+					const spanId = id(`${kind}:${spans.length}`);
+					messages.set(part.id, message);
+					spans.push(() => contractSpan({
+						...base,
+						spanId,
+						parentSpanId,
+						name: `message.${kind}`,
+						kind: "CHAIN",
+						startTime: at.toISOString(),
+						endTime: message.end.toISOString(),
+						status: OK,
+						attributes: {
+							...shared,
+							"message.role": "assistant",
+							"message.part.type": isTextPart(part) ? "text" : "reasoning",
+							"message.part.text_length": message.text.length,
+							...content("output.value", message.text)
+						}
+					}));
+				}
+			} else if (isToolPart$1(part)) {
+				let tool = tools.get(part.id);
+				if (tool === void 0) {
+					const created = {
+						status: part.state.status,
+						lastSeen: at
+					};
+					tools.set(part.id, created);
+					tool = created;
+					spans.push(() => {
+						const start = created.start ?? at.getTime();
+						const end = created.end ?? (ENDED.has(created.status) ? created.lastSeen.getTime() : start);
+						const failed = created.status !== "completed" && ENDED.has(created.status);
+						return toolSpan({
+							...base,
+							spanId: id(`tool:${part.id}`),
+							parentSpanId,
+							name: `tool.${part.tool}`,
+							toolName: part.tool,
+							startTime: new Date(start).toISOString(),
+							endTime: new Date(Math.max(start, end)).toISOString(),
+							status: failed ? {
+								code: "STATUS_CODE_ERROR",
+								message: cap(created.error ?? "tool reported an error", 500)
+							} : created.status === "completed" ? OK : UNSET,
+							attributes: {
+								...shared,
+								"gen_ai.tool.call.id": part.id,
+								"tangle.tool.status": created.status,
+								...content("input.value", created.input),
+								...content("output.value", created.output ?? created.error)
+							}
+						});
+					});
+				}
+				foldTool(tool, part.state, at);
+				if (tool.status === "running") for (const path of changedPaths(tool.input)) unwritten.set(path, tool);
+			} else if (isFilePart(part) && part.url?.startsWith("file://")) {
+				const patch = unwritten.get(part.url.slice(7));
+				if (patch !== void 0) {
+					unwritten.delete(part.url.slice(7));
+					if (![...unwritten.values()].includes(patch)) Object.assign(patch, {
+						status: "completed",
+						lastSeen: at,
+						end: at.getTime()
+					});
+				}
+			}
+		} else if (event.type === "message.updated") {
+			finalText = event.finalText ?? event.text ?? finalText;
+			resultUsage = usageOf(event.tokenUsage) ?? resultUsage;
+			outcome = "completed";
+		} else if (event.type === "error") {
+			error = event.message;
+			outcome = event.code ?? "error";
+		} else if (event.type === "custom" && event.name === "execution.started") {
+			const backend = record(event.data.effectiveBackend);
+			model = text(backend?.model) ?? model;
+			profile = text(record(backend?.profile)?.name) ?? profile;
+			sandboxId = text(event.data.sandboxId) ?? sandboxId;
+		} else if (event.type === "custom" && event.name === "raw") {
+			harness ??= text(event.data.backend);
+			const raw = record(event.data.event);
+			const type = text(raw?.type);
+			if (type === "turn.started") openTurn = startTurn(at);
+			else if (type === "turn.completed" || type === "turn.failed") {
+				const turn = openTurn ?? startTurn(at);
+				turn.end = at;
+				turn.usage = usageOf(raw?.usage);
+				turn.status = type === "turn.completed" ? OK : {
+					code: "STATUS_CODE_ERROR",
+					message: text(record(raw?.error)?.message) ?? "turn failed"
+				};
+				openTurn = void 0;
+			}
+		}
+	}
+	if (turns.length === 0 && resultUsage !== void 0) startTurn(first).end = last;
+	const lastTurn = turns.at(-1);
+	if (lastTurn !== void 0 && !turns.some((turn) => turn.usage)) lastTurn.usage = resultUsage;
+	const agent = context.agent ?? (profile ? { profileName: profile } : void 0);
+	base = {
+		traceId: context.traceId,
+		...agent ? { agent } : {}
+	};
+	shared = {
+		...harness ? { "service.name": harness } : {},
+		...context.attributes,
+		"tangle.execution.id": trace.id,
+		...sandboxId ? { "tangle.sandbox.id": sandboxId } : {}
+	};
+	return [contractSpan({
+		...base,
+		spanId: executionId,
+		parentSpanId: context.parentSpanId ?? null,
+		name: "invoke_agent",
+		kind: "AGENT",
+		startTime: first.toISOString(),
+		endTime: last.toISOString(),
+		status: error !== void 0 ? {
+			code: "STATUS_CODE_ERROR",
+			message: cap(error, 500)
+		} : outcome === "completed" ? OK : UNSET,
+		attributes: {
+			...shared,
+			"gen_ai.operation.name": "invoke_agent",
+			...profile ? { "gen_ai.agent.name": profile } : {},
+			...model ? { "gen_ai.request.model": model } : {},
+			...outcome ? { "tangle.execution.outcome": outcome } : {},
+			...content("output.value", finalText)
+		}
+	}), ...spans.map((build) => build())];
+}
+/** Fold one event's view of a tool call into what its earlier events reported. */
+function foldTool(tool, state, at) {
+	tool.lastSeen = at;
+	tool.status = String(state.status);
+	const input = record(state.input);
+	if (state.input !== void 0 && (!input || Object.keys(input).length > 0)) tool.input = state.input;
+	if (state.output != null) tool.output = state.output;
+	tool.error = text(state.error) ?? tool.error;
+	const time = record(state.time);
+	const start = number(time?.start);
+	if (start !== void 0 && (tool.start === void 0 || start < tool.start)) tool.start = start;
+	tool.end = number(time?.end) ?? tool.end;
+}
+/** The paths a patch's input lists as `changes: [{path}]`. */
+function changedPaths(input) {
+	const changes = record(input)?.changes;
+	return Array.isArray(changes) ? changes.flatMap((change) => text(record(change)?.path) ?? []) : [];
+}
+/** A usage report in any producer's spelling, read by agent-core, plus its reasoning share. */
+function usageOf(value) {
+	const bag = record(value);
+	const counts = bag && readTokenUsage(bag);
+	if (!bag || !counts) return void 0;
+	const reasoningTokens = firstTokenCount$1(bag, ["reasoning_output_tokens", "reasoningTokens"]);
+	return reasoningTokens === void 0 ? counts : {
+		...counts,
+		reasoningTokens
+	};
+}
+/** The usage `llmSpan` does not carry, under the contract's first-read keys. */
+function usageDetail(usage) {
+	const detail = [
+		[CACHE_READ_TOKEN_ATTR_KEYS[0] ?? "", usage?.cacheReadTokens],
+		[CACHE_WRITE_TOKEN_ATTR_KEYS[0] ?? "", usage?.cacheWriteTokens],
+		[REASONING_TOKEN_ATTR_KEYS[0] ?? "", usage?.reasoningTokens]
+	];
+	return Object.fromEntries(detail.filter(([, count]) => count !== void 0));
+}
+function cap(value, chars) {
+	return value.length <= chars ? value : `${value.slice(0, chars)}…`;
+}
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function text(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function number(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+//#endregion
 //#region src/enrichment/parse.ts
 const VALID_PRODUCTS = [
 	"vibe_coding",
@@ -75,6 +355,67 @@ function parseJsonBlob(blob) {
 	return context;
 }
 //#endregion
+//#region src/otel-provider.ts
+let provider = null;
+/** Parse `OTEL_EXPORTER_OTLP_HEADERS` ("k=v,k2=v2") into a header map. */
+function parseHeaders(raw) {
+	const out = {};
+	if (!raw) return out;
+	for (const pair of raw.split(",")) {
+		const eq = pair.indexOf("=");
+		if (eq <= 0) continue;
+		const key = pair.slice(0, eq).trim();
+		const value = pair.slice(eq + 1).trim();
+		if (key) out[key] = value;
+	}
+	return out;
+}
+async function initOtelProvider(serviceName) {
+	if (provider) return { active: true };
+	if (process.env.TELEMETRY_ENABLED !== "true") return {
+		active: false,
+		reason: "TELEMETRY_ENABLED!=true"
+	};
+	const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+	if (!endpoint) return {
+		active: false,
+		reason: "OTEL_EXPORTER_OTLP_ENDPOINT unset"
+	};
+	try {
+		const [{ NodeTracerProvider, BatchSpanProcessor }, { OTLPTraceExporter }, { resourceFromAttributes }, { ATTR_SERVICE_NAME }] = await Promise.all([
+			import("@opentelemetry/sdk-trace-node"),
+			import("@opentelemetry/exporter-trace-otlp-http"),
+			import("@opentelemetry/resources"),
+			import("@opentelemetry/semantic-conventions")
+		]);
+		const exporter = new OTLPTraceExporter({
+			url: endpoint,
+			headers: parseHeaders(process.env.OTEL_EXPORTER_OTLP_HEADERS)
+		});
+		const tracerProvider = new NodeTracerProvider({
+			resource: resourceFromAttributes({ [ATTR_SERVICE_NAME]: serviceName }),
+			spanProcessors: [new BatchSpanProcessor(exporter)]
+		});
+		tracerProvider.register();
+		provider = tracerProvider;
+		return { active: true };
+	} catch (error) {
+		return {
+			active: false,
+			reason: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+async function shutdownOtelProvider() {
+	if (!provider) return;
+	const current = provider;
+	provider = null;
+	try {
+		await current.forceFlush();
+	} catch {}
+	await current.shutdown();
+}
+//#endregion
 //#region src/trace-span-projection.ts
 const GEN_AI_PROMOTED_KEYS = Object.freeze([
 	GEN_AI_REQUEST_MODEL$1,
@@ -148,7 +489,6 @@ function projectTraceEvent(event, format, includePayloads = false) {
 	if (format === "intelligence") {
 		const { timestamp, type, ...rest } = event;
 		return {
-			kind: "span",
 			name: type,
 			startTime: timestamp,
 			attributes: {
@@ -157,89 +497,34 @@ function projectTraceEvent(event, format, includePayloads = false) {
 			}
 		};
 	}
-	const otel = format === "otel";
 	const attrs = { "event.type": event.type };
 	const projection = {
-		kind: otel ? "span" : "event",
 		name: "unknown",
 		startTime: event.timestamp,
-		...otel && { endTime: "durationMs" in event && typeof event.durationMs === "number" ? new Date(event.timestamp.getTime() + event.durationMs) : event.timestamp }
+		endTime: "durationMs" in event && typeof event.durationMs === "number" ? new Date(event.timestamp.getTime() + event.durationMs) : event.timestamp,
+		attributes: attrs
 	};
 	switch (event.type) {
 		case "message.part.updated": {
 			const part = event.part;
-			projection.metadata = {
-				partId: part.id,
-				sessionID: part.sessionID,
-				messageID: part.messageID
-			};
 			if (isToolPart$1(part)) {
 				const state = part.state;
-				const status = state.status;
-				projection.name = `tool.${part.tool}.${otel ? status : "result"}`;
-				if (otel) {
-					if (state.status === "error" || state.status === "failed") {
-						projection.error = typeof state.error === "string" ? state.error : "Tool execution failed";
-						projection.exception = true;
-					}
-				} else if (state.status === "running") {
-					projection.kind = "span";
-					projection.name = `tool.${part.tool}`;
-					projection.input = state.input ?? { callID: part.callID };
-					projection.metadata.status = status;
-				} else if (state.status !== "pending") {
-					projection.kind = "span";
-					projection.startTime = state.time?.start ? new Date(state.time.start) : event.timestamp;
-					projection.endTime = state.time?.end ? new Date(state.time.end) : event.timestamp;
-					projection.input = state.input;
-					projection.output = state.status === "completed" ? state.output ?? "success" : state.output ?? state.error;
-					projection.metadata.callID = part.callID;
-					projection.metadata.success = state.status === "completed";
-					if (state.status !== "completed") {
-						projection.level = "ERROR";
-						projection.statusMessage = state.error;
-					}
-				} else return void 0;
-			} else if (isTextPart(part) || isReasoningPart(part)) {
-				projection.name = `${otel ? "llm." : ""}${part.type}`;
-				if (!otel) {
-					projection.kind = "generation";
-					projection.output = part.text;
-					projection.metadata.delta = event.delta;
+				projection.name = `tool.${part.tool}.${state.status}`;
+				if (state.status === "error" || state.status === "failed") {
+					projection.error = typeof state.error === "string" ? state.error : "Tool execution failed";
+					projection.exception = true;
 				}
-			} else if (isFilePart(part)) {
-				projection.name = otel ? "message.file" : `file.${part.mediaType || "unknown"}`;
-				projection.metadata = {
-					partId: part.id,
-					filename: part.filename,
-					mediaType: part.mediaType,
-					url: part.url
-				};
-			} else if (!otel) return void 0;
+			} else if (isTextPart(part) || isReasoningPart(part)) projection.name = `llm.${part.type}`;
 			else projection.name = "message.file";
-			if (otel) addPartUpdateAttributes(attrs, event, includePayloads);
+			addPartUpdateAttributes(attrs, event, includePayloads);
 			break;
 		}
 		case "message.updated":
 			projection.name = "message.updated";
-			projection.metadata = {
-				text: event.text ?? event.finalText,
-				finalText: event.finalText,
-				tokenUsage: event.tokenUsage,
-				timing: event.timing,
-				toolInvocations: event.toolInvocations,
-				metadata: event.metadata
-			};
-			if (otel) addMessageUpdateAttributes(attrs, event, includePayloads);
+			addMessageUpdateAttributes(attrs, event, includePayloads);
 			break;
 		case "error":
 			projection.name = `error.${event.category}`;
-			projection.metadata = {
-				message: event.message,
-				code: event.code,
-				source: event.source
-			};
-			projection.level = "ERROR";
 			projection.error = event.message;
 			projection.exception = true;
 			attrs["error.category"] = event.category;
@@ -247,276 +532,20 @@ function projectTraceEvent(event, format, includePayloads = false) {
 			if (event.code) attrs["error.code"] = event.code;
 			if (event.source) attrs["error.source"] = event.source;
 			break;
-		case "diagnostic":
-			projection.name = `diagnostic.${event.language || "unknown"}`;
-			projection.metadata = {
-				file: event.file,
-				errorDelta: event.errorDelta,
-				errorsAfter: event.afterSummary.errors,
-				warningsAfter: event.afterSummary.warnings
-			};
-			attrs["diagnostic.file"] = event.file;
-			if (event.language) attrs["diagnostic.language"] = event.language;
-			attrs["diagnostic.error_delta"] = event.errorDelta;
-			attrs["diagnostic.errors_after"] = event.afterSummary.errors;
-			attrs["diagnostic.warnings_after"] = event.afterSummary.warnings;
-			break;
-		case "file_change":
-			projection.name = `file.${event.changeType}`;
-			projection.metadata = {
-				file: event.file,
-				linesAdded: event.linesAdded,
-				linesRemoved: event.linesRemoved
-			};
-			attrs["file.path"] = event.file;
-			attrs["file.change_type"] = event.changeType;
-			if (event.linesAdded) attrs["file.lines_added"] = event.linesAdded;
-			if (event.linesRemoved) attrs["file.lines_removed"] = event.linesRemoved;
-			break;
-		case "build_result":
-		case "test_result": {
-			const build = event.type === "build_result";
-			const prefix = build ? "build" : "test";
-			projection.name = `${prefix}.${event.success ? "success" : "failure"}`;
-			projection.kind = "span";
-			projection.metadata = build ? {
-				command: event.command,
-				errorCount: event.errorCount,
-				warningCount: event.warningCount
-			} : {
-				command: event.command,
-				passed: event.passed,
-				failed: event.failed,
-				skipped: event.skipped
-			};
-			if (!otel) {
-				projection.endTime = event.durationMs ? new Date(event.timestamp.getTime() + event.durationMs) : void 0;
-				projection.output = event.success ? "success" : "failed";
-				projection.level = event.success ? void 0 : "ERROR";
-			}
-			if (!event.success) projection.error = build ? "Build failed" : "Tests failed";
-			attrs[`${prefix}.success`] = event.success;
-			if (event.command) attrs[`${prefix}.command`] = event.command;
-			if (event.durationMs) attrs[`${prefix}.duration_ms`] = event.durationMs;
-			const counts = build ? {
-				error_count: event.errorCount,
-				warning_count: event.warningCount
-			} : {
-				passed: event.passed,
-				failed: event.failed,
-				skipped: event.skipped
-			};
-			for (const [key, value] of Object.entries(counts)) if (value) attrs[`${prefix}.${key}`] = value;
-			break;
-		}
-		case "environment":
-			projection.name = "environment.snapshot";
-			projection.metadata = {
-				workingDir: event.workingDir,
-				platform: event.platform
-			};
-			if (event.workingDir) attrs["env.working_dir"] = event.workingDir;
-			if (event.platform) attrs["env.platform"] = event.platform;
-			break;
 		case "custom":
 			projection.name = `custom.${event.name}`;
-			projection.metadata = event.data;
-			if (event.name === "startup.phase" || !otel && event.name === "http.phase") {
-				projection.kind = "span";
-				const phase = typeof event.data.phase === "string" ? event.data.phase : "unknown";
-				projection.name = `${event.name === "http.phase" ? "http" : "startup"}.${phase}`;
+			if (event.name === "startup.phase") {
+				projection.name = `startup.${typeof event.data.phase === "string" ? event.data.phase : "unknown"}`;
 				if (typeof event.data.durationMs === "number") projection.startTime = new Date(event.timestamp.getTime() - event.data.durationMs);
 				projection.endTime = event.timestamp;
-				if (event.data.status === "error") {
-					projection.level = "ERROR";
-					projection.error = typeof event.data.error === "string" ? event.data.error : "Startup phase failed";
-				}
-				if (!otel && typeof event.data.error === "string") projection.statusMessage = event.data.error;
+				if (event.data.status === "error") projection.error = typeof event.data.error === "string" ? event.data.error : "Startup phase failed";
 			}
-			if (otel) addCustomEventAttributes(attrs, event);
+			addCustomEventAttributes(attrs, event);
 			break;
-		default: if (!otel) return void 0;
 	}
-	if (otel) projection.attributes = attrs;
 	return projection;
 }
 //#endregion
-//#region src/langfuse-sink.ts
-/**
-* Langfuse Sink
-*
-* Native Langfuse SDK integration for trace export.
-* Uses the langfuse-node SDK directly instead of going through OTEL,
-* which provides better compatibility and richer trace visualization.
-*/
-let langfuseClient = null;
-let langfuseConfig = null;
-/**
-* Get or create the Langfuse client
-*/
-async function getLangfuseClient(config) {
-	if (langfuseClient && langfuseConfig === config) return langfuseClient;
-	try {
-		const { Langfuse } = await import("langfuse-node");
-		langfuseClient = new Langfuse({
-			publicKey: config.publicKey,
-			secretKey: config.secretKey,
-			baseUrl: config.baseUrl || "https://cloud.langfuse.com"
-		});
-		langfuseConfig = config;
-		return langfuseClient;
-	} catch (err) {
-		console.warn("[langfuse-sink] Failed to initialize Langfuse:", err);
-		return null;
-	}
-}
-/**
-* Langfuse trace exporter using the native SDK.
-*
-* Creates proper Langfuse traces with spans and generations
-* for rich observability in the Langfuse dashboard.
-*
-* Note: This is a trace-level exporter (ExecutionTrace), not a
-* TelemetrySink (TelemetryEvent). Use for exporting complete traces.
-*/
-var LangfuseSink = class {
-	name = "langfuse";
-	config;
-	constructor(config) {
-		this.config = config;
-	}
-	/**
-	* Export an execution trace to Langfuse.
-	*/
-	async exportTrace(trace) {
-		const client = await getLangfuseClient(this.config);
-		if (!client) return;
-		const effectiveTrace = this.config.redactTrace ? this.config.redactTrace(trace) : trace;
-		try {
-			const langfuseTrace = client.trace({
-				id: effectiveTrace.id,
-				name: effectiveTrace.task,
-				sessionId: effectiveTrace.scope.sessionId,
-				userId: effectiveTrace.scope.userId,
-				metadata: {
-					outcome: effectiveTrace.outcome,
-					projectRef: effectiveTrace.scope.projectRef,
-					...effectiveTrace.metadata
-				},
-				tags: effectiveTrace.outcome === "failure" ? ["failed"] : void 0
-			});
-			for (const event of effectiveTrace.events) {
-				if (!event) continue;
-				this.exportTraceEvent(langfuseTrace, event);
-			}
-			for (const signal of effectiveTrace.signals) langfuseTrace.event({
-				name: `signal.${signal.signal}`,
-				startTime: signal.timestamp,
-				metadata: signal.metadata
-			});
-			langfuseTrace.update({ output: effectiveTrace.outcome });
-			await client.flushAsync();
-		} catch (err) {
-			console.warn("[langfuse-sink] Failed to export trace:", err);
-		}
-	}
-	exportTraceEvent(trace, event) {
-		const projected = projectTraceEvent(event, "langfuse");
-		if (!projected) return;
-		const { kind, attributes: _attributes, error: _error, exception: _exception, ...data } = projected;
-		if (kind === "generation") trace.generation(data);
-		else if (kind === "span") trace.span(data);
-		else trace.event(data);
-	}
-	async flush() {
-		const client = await getLangfuseClient(this.config);
-		if (client) await client.flushAsync();
-	}
-	async close() {
-		const client = await getLangfuseClient(this.config);
-		if (client) {
-			await client.shutdownAsync();
-			langfuseClient = null;
-		}
-	}
-};
-/**
-* Create a Langfuse sink from environment variables.
-*/
-function createLangfuseSinkFromEnv(options) {
-	const publicKey = process.env.LANGFUSE_PUBLIC_KEY;
-	const secretKey = process.env.LANGFUSE_SECRET_KEY;
-	if (!publicKey || !secretKey) return null;
-	return new LangfuseSink({
-		publicKey,
-		secretKey,
-		baseUrl: process.env.LANGFUSE_HOST || "https://cloud.langfuse.com",
-		debug: process.env.LANGFUSE_DEBUG === "true",
-		...options?.redactTrace ? { redactTrace: options.redactTrace } : {}
-	});
-}
-//#endregion
-//#region src/otel-provider.ts
-let provider = null;
-/** Parse `OTEL_EXPORTER_OTLP_HEADERS` ("k=v,k2=v2") into a header map. */
-function parseHeaders(raw) {
-	const out = {};
-	if (!raw) return out;
-	for (const pair of raw.split(",")) {
-		const eq = pair.indexOf("=");
-		if (eq <= 0) continue;
-		const key = pair.slice(0, eq).trim();
-		const value = pair.slice(eq + 1).trim();
-		if (key) out[key] = value;
-	}
-	return out;
-}
-async function initOtelProvider(serviceName) {
-	if (provider) return { active: true };
-	if (process.env.TELEMETRY_ENABLED !== "true") return {
-		active: false,
-		reason: "TELEMETRY_ENABLED!=true"
-	};
-	const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-	if (!endpoint) return {
-		active: false,
-		reason: "OTEL_EXPORTER_OTLP_ENDPOINT unset"
-	};
-	try {
-		const [{ NodeTracerProvider, BatchSpanProcessor }, { OTLPTraceExporter }, { resourceFromAttributes }, { ATTR_SERVICE_NAME }] = await Promise.all([
-			import("@opentelemetry/sdk-trace-node"),
-			import("@opentelemetry/exporter-trace-otlp-http"),
-			import("@opentelemetry/resources"),
-			import("@opentelemetry/semantic-conventions")
-		]);
-		const exporter = new OTLPTraceExporter({
-			url: endpoint,
-			headers: parseHeaders(process.env.OTEL_EXPORTER_OTLP_HEADERS)
-		});
-		const tracerProvider = new NodeTracerProvider({
-			resource: resourceFromAttributes({ [ATTR_SERVICE_NAME]: serviceName }),
-			spanProcessors: [new BatchSpanProcessor(exporter)]
-		});
-		tracerProvider.register();
-		provider = tracerProvider;
-		return { active: true };
-	} catch (error) {
-		return {
-			active: false,
-			reason: error instanceof Error ? error.message : String(error)
-		};
-	}
-}
-async function shutdownOtelProvider() {
-	if (!provider) return;
-	const current = provider;
-	provider = null;
-	try {
-		await current.forceFlush();
-	} catch {}
-	await current.shutdown();
-}
-//#endregion
 //#region src/otel-sink.ts
 /**
 * OpenTelemetry Sink
@@ -525,8 +554,8 @@ async function shutdownOtelProvider() {
 * Langfuse, Jaeger, Honeycomb, and other OTLP collectors.
 *
 * IMPORTANT: This sink uses the GLOBAL tracer from @opentelemetry/api.
-* The OTEL SDK must be initialized separately (e.g., via NodeSDK with
-* LangfuseSpanProcessor or OTLPTraceExporter) before using this sink.
+* The OTEL SDK must be initialized separately (e.g., via initOtelProvider)
+* before using this sink.
 *
 * This sink converts ExecutionTrace data into OTEL spans using the
 * global tracer, which ensures spans flow through whatever processor
@@ -545,17 +574,8 @@ function buildTraceSpanAttributes(trace, flattenedMetadata) {
 		"agent.trace.id": trace.id,
 		"agent.task": trace.task,
 		"agent.outcome": trace.outcome,
-		"langfuse.trace.id": trace.id,
-		"langfuse.trace.name": trace.task,
-		...trace.scope.projectRef && { "langfuse.project": trace.scope.projectRef },
-		...trace.scope.sessionId && {
-			"langfuse.session.id": trace.scope.sessionId,
-			"session.id": trace.scope.sessionId
-		},
-		...trace.scope.userId && {
-			"langfuse.user.id": trace.scope.userId,
-			"user.id": trace.scope.userId
-		},
+		...trace.scope.sessionId && { "session.id": trace.scope.sessionId },
+		...trace.scope.userId && { "user.id": trace.scope.userId },
 		...flattenedMetadata ?? {}
 	};
 }
@@ -626,7 +646,6 @@ var OtelTelemetrySink = class {
 			if (!event?.type) continue;
 			api.context.with(parentContext, () => {
 				const projected = projectTraceEvent(event, "otel", this.config.includePayloads);
-				if (!projected) return;
 				const span = tracer.startSpan(projected.name, {
 					attributes: projected.attributes,
 					startTime: projected.startTime
@@ -673,14 +692,11 @@ function createOtelSink(config) {
 /**
 * Create an OTEL sink from environment variables.
 *
-* Returns a sink that uses the global tracer (which should be initialized
-* separately via NodeSDK with LangfuseSpanProcessor or OTLPTraceExporter).
+* Returns a sink that uses the global tracer (initialized separately).
 */
 function createOtelSinkFromEnv() {
-	const enabled = process.env.TELEMETRY_ENABLED === "true";
-	const hasLangfuse = process.env.LANGFUSE_PUBLIC_KEY && process.env.LANGFUSE_SECRET_KEY;
-	const hasOtlp = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-	if (!enabled || !hasLangfuse && !hasOtlp) return null;
+	if (process.env.TELEMETRY_ENABLED !== "true") return null;
+	if (!process.env.OTEL_EXPORTER_OTLP_ENDPOINT) return null;
 	return new OtelTelemetrySink({
 		serviceName: process.env.OTEL_SERVICE_NAME || "orchestrator",
 		includePayloads: process.env.OTEL_INCLUDE_PAYLOADS === "true"
@@ -889,6 +905,41 @@ function normalizeRawToolInvocation(event, timestamp) {
 		timestamp
 	};
 }
+/** Codex exec item statuses as the ToolState they report. */
+const CODEX_ITEM_STATUS = new Map([
+	["in_progress", "running"],
+	["completed", "completed"],
+	["failed", "failed"]
+]);
+/**
+* A Codex exec `file_change` item, which a Sandbox forwards in a `raw`
+* envelope, as the tool part it is: the files the agent's patch changed.
+* Other Codex items already arrive as parts.
+*/
+function codexFileChange(event, timestamp) {
+	const raw = event.event;
+	const item = raw?.item;
+	if (!String(raw?.type).startsWith("item.") || item?.type !== "file_change" || typeof item.id !== "string" || !Array.isArray(item.changes)) return null;
+	const status = CODEX_ITEM_STATUS.get(item.status) ?? "running";
+	const state = {
+		status,
+		input: { changes: item.changes },
+		...status === "completed" ? { output: null } : {}
+	};
+	return {
+		type: "message.part.updated",
+		part: {
+			id: item.id,
+			sessionID: "",
+			messageID: "",
+			type: "tool",
+			callID: item.id,
+			tool: "file_change",
+			state
+		},
+		timestamp
+	};
+}
 /**
 * Convert SSE event data to a typed TraceEvent.
 * Returns null for events that should be skipped (heartbeats, status-only, etc.)
@@ -901,11 +952,13 @@ function normalizeRawToolInvocation(event, timestamp) {
 * `ToolPart`) so consumers don't need to reach into provider-specific
 * raw shapes to render tool calls. Unrecognized raw events fall
 * through to a `custom` trace event.
+*
+* `timestamp` is when the event happened: now for a live stream, the recorded
+* time for a recorded one, so the trace keeps the run's own clock.
 */
-function sseToTraceEvent(event) {
-	const timestamp = /* @__PURE__ */ new Date();
+function sseToTraceEvent(event, timestamp = /* @__PURE__ */ new Date()) {
 	if (event.type === "raw" || typeof event.type === "string" && TOOL_INVOCATION_TYPES.has(event.type)) {
-		const normalized = normalizeRawToolInvocation(event, timestamp);
+		const normalized = (event.type === "raw" ? codexFileChange(event, timestamp) : null) ?? normalizeRawToolInvocation(event, timestamp);
 		if (normalized) {
 			if (normalized.part.state?.status === "pending") return null;
 			return normalized;
@@ -973,13 +1026,13 @@ function sseToTraceEvent(event) {
 	}
 }
 /**
-* Extract a signal from an SSE event if present.
+* Extract a signal from an SSE event if present; `at` as in {@link sseToTraceEvent}'s `timestamp`.
 */
-function sseToSignal(event) {
+function sseToSignal(event, at = /* @__PURE__ */ new Date()) {
 	if (event.type === "status" && typeof event.status === "string") {
 		if (VALID_SIGNALS.includes(event.status)) return {
 			signal: event.status,
-			timestamp: /* @__PURE__ */ new Date()
+			timestamp: at
 		};
 	}
 	return null;
@@ -1168,6 +1221,6 @@ function createTraceCollector(config) {
 	return new TraceCollector(config);
 }
 //#endregion
-export { GEN_AI_CONVERSATION_ID, GEN_AI_INPUT_TOKEN_KEYS, GEN_AI_MODEL_KEYS, GEN_AI_OUTPUT_TOKEN_KEYS, GEN_AI_REQUEST_MODEL, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS, HttpTelemetrySink, LangfuseSink, MultiTelemetrySink, OtelTelemetrySink, PROVISION_TRACE_ID_HEADER, SSEChunkParser, SpanRecorder, TOKEN_USAGE_INPUT_KEYS, TOKEN_USAGE_OUTPUT_KEYS, TraceCollector, createHttpSink, createLangfuseSinkFromEnv, createOtelSink, createOtelSinkFromEnv, createStreamUsageExtractor, createTraceCollector, firstTokenCount, flattenTraceMetadata, genAiUsageAttributes, initOtelProvider, isAdoptablePtid, isToolPart, mintPtid, parseMetadataBlob, projectTraceEvent, shutdownOtelProvider, sseToSignal, sseToTraceEvent, tokenCount };
+export { GEN_AI_CONVERSATION_ID, GEN_AI_INPUT_TOKEN_KEYS, GEN_AI_MODEL_KEYS, GEN_AI_OUTPUT_TOKEN_KEYS, GEN_AI_REQUEST_MODEL, GEN_AI_USAGE_INPUT_TOKENS, GEN_AI_USAGE_OUTPUT_TOKENS, HttpTelemetrySink, MultiTelemetrySink, OtelTelemetrySink, PROVISION_TRACE_ID_HEADER, SSEChunkParser, SpanRecorder, TOKEN_USAGE_INPUT_KEYS, TOKEN_USAGE_OUTPUT_KEYS, TraceCollector, createHttpSink, createOtelSink, createOtelSinkFromEnv, createStreamUsageExtractor, createTraceCollector, executionTraceToContractSpans, firstTokenCount, flattenTraceMetadata, genAiUsageAttributes, initOtelProvider, isAdoptablePtid, isToolPart, mintPtid, parseMetadataBlob, projectTraceEvent, shutdownOtelProvider, sseToSignal, sseToTraceEvent, tokenCount };
 
 //# sourceMappingURL=index.mjs.map