npm - @runtypelabs/flue-otel - Versions diffs - 0.5.4 → 0.5.6 - Mend

@runtypelabs/flue-otel 0.5.4 → 0.5.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.cjs CHANGED Viewed

@@ -1,1255 +1,1406 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ADAPTER_NAME: () => ADAPTER_NAME,
-  ADAPTER_VERSION: () => ADAPTER_VERSION,
-  DEFAULT_CONTENT_MAX_CHARS: () => DEFAULT_CONTENT_MAX_CHARS,
-  GEN_AI: () => GEN_AI,
-  GEN_AI_CONTENT: () => GEN_AI_CONTENT,
-  INGEST_CONTENT_ATTRIBUTE_CEILING: () => INGEST_CONTENT_ATTRIBUTE_CEILING,
-  RUNTYPE: () => RUNTYPE,
-  RUNTYPE_FLUE_INSTRUMENTATION_KEY: () => RUNTYPE_FLUE_INSTRUMENTATION_KEY,
-  RUNTYPE_SCHEMA_VERSION: () => RUNTYPE_SCHEMA_VERSION,
-  RUNTYPE_STOP_REASONS: () => RUNTYPE_STOP_REASONS,
-  RUNTYPE_TOOL_TYPES: () => RUNTYPE_TOOL_TYPES,
-  createRuntypeFlueInstrumentation: () => createRuntypeFlueInstrumentation,
-  runtypeFlueResourceAttributes: () => runtypeFlueResourceAttributes
-});
-module.exports = __toCommonJS(index_exports);
-var import_api2 = require("@opentelemetry/api");
-// src/compat.ts
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _opentelemetry_api = require("@opentelemetry/api");
+//#region src/compat.ts
+/**
+* Infer implementation class only from datastore semantics or the framework task tool. Origin
+* identifies who initiated a call, not its tool type; unsupported classes remain undefined.
+*/
 function resolveToolType(toolName, detail) {
-  if (isTaskDelegationTool(toolName, detail)) return "subagent";
-  if (detail.toolType === "datastore") return "data_connection";
-  return void 0;
+	if (isTaskDelegationTool(toolName, detail)) return "subagent";
+	if (detail.toolType === "datastore") return "data_connection";
 }
+/**
+* Recognize framework task delegation. Keep its subagent tool span rather than a nested invoke_agent
+* envelope, since one trace represents one execution.
+*/
 function isTaskDelegationTool(toolName, detail) {
-  return detail.origin === "framework" && toolName === "task";
+	return detail.origin === "framework" && toolName === "task";
 }
+/**
+* Recognize host-initiated shell calls. They produce bookkeeping spans, not model tool rows.
+*/
 function isCallerShellCall(toolName, detail) {
-  return detail.origin === "caller" && toolName === "bash";
+	return detail.origin === "caller" && toolName === "bash";
 }
+/**
+* Normalize finish reasons. Terminal tool_call/toolUse maps to unknown: it does not identify whether a
+* turn cap, tool cap, or host abort ended the run.
+*/
 function mapFinishReason(finishReason) {
-  if (!finishReason) return void 0;
-  const normalized = finishReason.toLowerCase().replace(/[\s-]+/g, "_");
-  if (END_TURN_REASONS.has(normalized)) return "end_turn";
-  if (LENGTH_REASONS.has(normalized)) return "length";
-  if (CONTENT_FILTER_REASONS.has(normalized)) return "content_filter";
-  if (ERROR_REASONS.has(normalized)) return "error";
-  return "unknown";
+	if (!finishReason) return void 0;
+	const normalized = finishReason.toLowerCase().replace(/[\s-]+/g, "_");
+	if (END_TURN_REASONS.has(normalized)) return "end_turn";
+	if (LENGTH_REASONS.has(normalized)) return "length";
+	if (CONTENT_FILTER_REASONS.has(normalized)) return "content_filter";
+	if (ERROR_REASONS.has(normalized)) return "error";
+	return "unknown";
 }
-var END_TURN_REASONS = /* @__PURE__ */ new Set([
-  "stop",
-  "end_turn",
-  "stop_sequence",
-  "complete",
-  "completed"
+const END_TURN_REASONS = /* @__PURE__ */ new Set([
+	"stop",
+	"end_turn",
+	"stop_sequence",
+	"complete",
+	"completed"
 ]);
-var LENGTH_REASONS = /* @__PURE__ */ new Set(["length", "max_tokens", "maxtokens"]);
-var CONTENT_FILTER_REASONS = /* @__PURE__ */ new Set([
-  "content_filter",
-  "contentfilter",
-  "refusal",
-  "safety"
+const LENGTH_REASONS = /* @__PURE__ */ new Set([
+	"length",
+	"max_tokens",
+	"maxtokens"
 ]);
-var ERROR_REASONS = /* @__PURE__ */ new Set(["error", "aborted", "abort", "cancelled"]);
+const CONTENT_FILTER_REASONS = /* @__PURE__ */ new Set([
+	"content_filter",
+	"contentfilter",
+	"refusal",
+	"safety"
+]);
+const ERROR_REASONS = /* @__PURE__ */ new Set([
+	"error",
+	"aborted",
+	"abort",
+	"cancelled"
+]);
+/**
+* A known submission settlement outranks a turn finish reason because it describes the run. completed
+* does not explain why it stopped, so retain the terminal turn reason.
+*/
 function mapSettlementOutcome(outcome) {
-  if (outcome === "failed" || outcome === "aborted") return "error";
-  return void 0;
+	if (outcome === "failed" || outcome === "aborted") return "error";
 }
-// src/messages.ts
-var ROLES = /* @__PURE__ */ new Set(["system", "user", "assistant"]);
-var FLUE_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
-var SIGNAL_MESSAGE = /^<([A-Za-z_][\w.-]*) type="[^"]*"[^>]*>\n[\s\S]*\n<\/\1>$/;
-var COMPACTION_SUMMARY_PREFIX = '<compaction type="context_summary"';
-var HTML_TYPED_TAGS = /* @__PURE__ */ new Set([
-  "a",
-  "button",
-  "embed",
-  "input",
-  "link",
-  "menu",
-  "object",
-  "ol",
-  "script",
-  "source",
-  "style",
-  "ul"
+//#endregion
+//#region src/messages.ts
+const ROLES = /* @__PURE__ */ new Set([
+	"system",
+	"user",
+	"assistant"
+]);
+const FLUE_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
+/**
+* A Flue signal exactly as `renderSignalMessage` frames it: one element whose first attribute is
+* `type`, body on its own lines. Tag names follow Flue's `[A-Za-z_][A-Za-z0-9_.-]*`; attribute names
+* are caller-defined, so the tail is `[^>]*`. A text-shape test can only REDUCE misclassification: a
+* user's `<p>hi</p>` stays a user row, and so do HTML elements that conventionally lead with `type`.
+*/
+const SIGNAL_MESSAGE = /^<([A-Za-z_][\w.-]*) type="[^"]*"[^>]*>\n[\s\S]*\n<\/\1>$/;
+/** The row Flue puts first after a compaction, standing in for everything it dropped. */
+const COMPACTION_SUMMARY_PREFIX = "<compaction type=\"context_summary\"";
+/** HTML elements whose `type` attribute conventionally comes first; a user pasting one is not a signal. */
+const HTML_TYPED_TAGS = /* @__PURE__ */ new Set([
+	"a",
+	"button",
+	"embed",
+	"input",
+	"link",
+	"menu",
+	"object",
+	"ol",
+	"script",
+	"source",
+	"style",
+	"ul"
 ]);
+/**
+* Flue's `LlmMessage[]` as text-only semconv messages, in order. A `toolResult` message, a system
+* row, and tool-call / thinking / image parts are dropped: tool content and the system prompt have
+* their own switches, and the rest is never exported. A Flue signal — delivered to the model as a
+* user message — becomes a `system` row, verbatim, so it is never read as something the user said.
+*/
 function projectFlueMessages(value) {
-  if (!Array.isArray(value)) return [];
-  const out = [];
-  for (const entry of value) {
-    const message = projectFlueMessage(entry);
-    if (message) out.push(message);
-  }
-  return out;
+	if (!Array.isArray(value)) return [];
+	const out = [];
+	for (const entry of value) {
+		const message = projectFlueMessage(entry);
+		if (message) out.push(message);
+	}
+	return out;
 }
+/** One Flue message as a semconv message, or undefined when it carries no text a reader could show. */
 function projectFlueMessage(value) {
-  if (!isRecord(value)) return void 0;
-  const role = value.role;
-  if (typeof role !== "string" || !FLUE_ROLES.has(role)) return void 0;
-  const text = flueMessageText(value.content);
-  if (text === "") return void 0;
-  if (role === "user" && isFlueSignal(value.content, text)) {
-    return { role: "system", parts: [{ type: "text", content: text }] };
-  }
-  return { role, parts: [{ type: "text", content: text }] };
+	if (!isRecord(value)) return void 0;
+	const role = value.role;
+	if (typeof role !== "string" || !FLUE_ROLES.has(role)) return void 0;
+	const text = flueMessageText(value.content);
+	if (text === "") return void 0;
+	if (role === "user" && isFlueSignal(value.content, text)) return {
+		role: "system",
+		parts: [{
+			type: "text",
+			content: text
+		}]
+	};
+	return {
+		role,
+		parts: [{
+			type: "text",
+			content: text
+		}]
+	};
 }
+/** Whether a user-role body is a Flue signal: exact framing, one text, not an HTML `type`-first tag. */
 function isFlueSignal(content, text) {
-  if (!isSingleText(content)) return false;
-  const signal = SIGNAL_MESSAGE.exec(text);
-  return signal !== null && !HTML_TYPED_TAGS.has(signal[1].toLowerCase());
+	if (!isSingleText(content)) return false;
+	const signal = SIGNAL_MESSAGE.exec(text);
+	return signal !== null && !HTML_TYPED_TAGS.has(signal[1].toLowerCase());
 }
+/** Flue renders a signal as one string or one text part; a multi-part body is a user's own message. */
 function isSingleText(content) {
-  if (typeof content === "string") return true;
-  return Array.isArray(content) && content.length === 1;
+	if (typeof content === "string") return true;
+	return Array.isArray(content) && content.length === 1;
 }
+/** The visible text of a Flue message body: a string as-is, or its `text` parts joined by newlines. */
 function flueMessageText(content) {
-  return contentMessageText({ content });
+	return contentMessageText({ content });
 }
+/**
+* Re-read semconv messages after the redaction hook, which may return anything. Accepts the ratified
+* `{ role, parts }` shape, the `{ role, content }` shorthand with a string or Flue-style text parts,
+* and text parts keyed `content` or `text`; drops everything else.
+*/
 function normalizeContentMessages(value) {
-  if (!Array.isArray(value)) return [];
-  const out = [];
-  for (const entry of value) {
-    if (!isRecord(entry)) continue;
-    const role = entry.role;
-    if (typeof role !== "string" || !ROLES.has(role)) continue;
-    const text = contentMessageText(entry);
-    if (text === "") continue;
-    out.push({ role, parts: [{ type: "text", content: text }] });
-  }
-  return out;
+	if (!Array.isArray(value)) return [];
+	const out = [];
+	for (const entry of value) {
+		if (!isRecord(entry)) continue;
+		const role = entry.role;
+		if (typeof role !== "string" || !ROLES.has(role)) continue;
+		const text = contentMessageText(entry);
+		if (text === "") continue;
+		out.push({
+			role,
+			parts: [{
+				type: "text",
+				content: text
+			}]
+		});
+	}
+	return out;
 }
+/** The text of a redacted system prompt: a string, or Flue-style / semconv text parts; else empty. */
 function contentTextOf(value) {
-  if (typeof value === "string") return value;
-  return Array.isArray(value) ? contentMessageText({ parts: value }) : "";
+	if (typeof value === "string") return value;
+	return Array.isArray(value) ? contentMessageText({ parts: value }) : "";
 }
 function contentMessageText(message) {
-  if (typeof message.content === "string") return message.content;
-  const parts = Array.isArray(message.parts) ? message.parts : Array.isArray(message.content) ? message.content : [];
-  const texts = [];
-  for (const part of parts) {
-    if (!isRecord(part) || part.type !== "text") continue;
-    const text = typeof part.content === "string" && part.content.length > 0 ? part.content : typeof part.text === "string" && part.text.length > 0 ? part.text : "";
-    if (text !== "") texts.push(text);
-  }
-  return texts.join("\n");
+	if (typeof message.content === "string") return message.content;
+	const parts = Array.isArray(message.parts) ? message.parts : Array.isArray(message.content) ? message.content : [];
+	const texts = [];
+	for (const part of parts) {
+		if (!isRecord(part) || part.type !== "text") continue;
+		const text = typeof part.content === "string" && part.content.length > 0 ? part.content : typeof part.text === "string" && part.text.length > 0 ? part.text : "";
+		if (text !== "") texts.push(text);
+	}
+	return texts.join("\n");
 }
 function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-// src/content.ts
-var DEFAULT_CONTENT_MAX_CHARS = 65536;
-var INGEST_CONTENT_ATTRIBUTE_CEILING = 262144;
-var INGEST_CONTENT_SPAN_CEILING = 393216;
+//#endregion
+//#region src/content.ts
+/**
+* The default per-value ceiling: 64 KiB of ASCII. Large enough for any
+* realistic tool argument object and most results, and small enough that
+* arguments plus result on one span sit well inside ingest's 384 KiB per-span
+* ceiling — a customer who raises it should know that ceiling exists.
+*/
+const DEFAULT_CONTENT_MAX_CHARS = 65536;
+/**
+* Inline the private ingest per-attribute ceiling so npm installs need no private dependency.
+* tests/contract.test.ts pins equality.
+*/
+const INGEST_CONTENT_ATTRIBUTE_CEILING = 262144;
+/**
+* Ingest's per-SPAN content ceiling, inlined for the same reason. The envelope carries up to three
+* message values and a tool span two, so each is capped at its share; tests/contract.test.ts pins
+* equality.
+*/
+const INGEST_CONTENT_SPAN_CEILING = 393216;
 function resolveContentPolicy(setting) {
-  const options = setting === false ? void 0 : setting;
-  const on = (value) => setting !== false && value !== false;
-  const requested = options?.maxChars;
-  const maxChars = typeof requested === "number" && Number.isFinite(requested) && requested > 0 ? Math.min(Math.floor(requested), INGEST_CONTENT_ATTRIBUTE_CEILING) : DEFAULT_CONTENT_MAX_CHARS;
-  return {
-    toolArguments: on(options?.toolArguments),
-    toolResults: on(options?.toolResults),
-    inputMessages: on(options?.inputMessages),
-    outputMessages: on(options?.outputMessages),
-    systemInstructions: on(options?.systemInstructions),
-    maxChars,
-    envelopeMaxChars: Math.min(maxChars, Math.floor(INGEST_CONTENT_SPAN_CEILING / 3)),
-    toolMaxChars: Math.min(maxChars, Math.floor(INGEST_CONTENT_SPAN_CEILING / 2)),
-    redact: options?.redact
-  };
+	const options = setting === false ? void 0 : setting;
+	const on = (value) => setting !== false && value !== false;
+	const requested = options?.maxChars;
+	const maxChars = typeof requested === "number" && Number.isFinite(requested) && requested > 0 ? Math.min(Math.floor(requested), INGEST_CONTENT_ATTRIBUTE_CEILING) : DEFAULT_CONTENT_MAX_CHARS;
+	return {
+		toolArguments: on(options?.toolArguments),
+		toolResults: on(options?.toolResults),
+		inputMessages: on(options?.inputMessages),
+		outputMessages: on(options?.outputMessages),
+		systemInstructions: on(options?.systemInstructions),
+		maxChars,
+		envelopeMaxChars: Math.min(maxChars, Math.floor(INGEST_CONTENT_SPAN_CEILING / 3)),
+		toolMaxChars: Math.min(maxChars, Math.floor(INGEST_CONTENT_SPAN_CEILING / 2)),
+		redact: options?.redact
+	};
 }
-function encodeContentValue(value, policy, context3) {
-  if (value === void 0) return void 0;
-  const redacted = applyRedact(value, policy, context3);
-  if (redacted === void 0) return void 0;
-  if (context3.kind === "arguments") return encodeArguments(redacted, policy.toolMaxChars);
-  const encoded = stringify(redacted);
-  if (encoded === void 0) return void 0;
-  return truncate(encoded, policy.toolMaxChars);
+/**
+* Encode one payload without propagating serialization or redaction failures. Missing values,
+* unsupported JSON values, undefined redactions, and thrown redactions emit nothing.
+*/
+function encodeContentValue(value, policy, context) {
+	if (value === void 0) return void 0;
+	const redacted = applyRedact(value, policy, context);
+	if (redacted === void 0) return void 0;
+	if (context.kind === "arguments") return encodeArguments(redacted, policy.toolMaxChars);
+	const encoded = stringify(redacted);
+	if (encoded === void 0) return void 0;
+	return truncate(encoded, policy.toolMaxChars);
 }
+/**
+* Encode semconv messages as one JSON array under the envelope ceiling. Over budget, the OLDEST
+* messages are dropped whole first so the newest one survives; a lone message that still does not
+* fit has its text cut with the truncation marker. Undefined when nothing survives redaction.
+*/
 function encodeMessagesValue(messages, policy, kind) {
-  if (messages.length === 0) return void 0;
-  const redacted = applyRedact(messages, policy, { kind });
-  if (redacted === void 0) return void 0;
-  const all = normalizeContentMessages(redacted);
-  if (all.length === 0) return void 0;
-  const maxChars = policy.envelopeMaxChars;
-  const perMessage = all.length > 1 ? Math.floor((maxChars - 3) / 2) : maxChars - 2;
-  const encoded = [];
-  for (const message of all) {
-    const one = JSON.stringify(message);
-    encoded.push(one.length <= perMessage ? one : encodeTruncatedMessage(message, perMessage) ?? "");
-  }
-  let start = all.length;
-  let total = 2;
-  while (start > 0) {
-    const length = encoded[start - 1].length + (start < all.length ? 1 : 0);
-    if (total + length > maxChars) break;
-    total += length;
-    start -= 1;
-  }
-  const kept = encoded.slice(start).filter((one) => one !== "");
-  if (kept.length === 0) return void 0;
-  return "[" + kept.join(",") + "]";
+	if (messages.length === 0) return void 0;
+	const redacted = applyRedact(messages, policy, { kind });
+	if (redacted === void 0) return void 0;
+	const all = normalizeContentMessages(redacted);
+	if (all.length === 0) return void 0;
+	const maxChars = policy.envelopeMaxChars;
+	const perMessage = all.length > 1 ? Math.floor((maxChars - 3) / 2) : maxChars - 2;
+	const encoded = [];
+	for (const message of all) {
+		const one = JSON.stringify(message);
+		encoded.push(one.length <= perMessage ? one : encodeTruncatedMessage(message, perMessage) ?? "");
+	}
+	let start = all.length;
+	let total = 2;
+	while (start > 0) {
+		const length = encoded[start - 1].length + (start < all.length ? 1 : 0);
+		if (total + length > maxChars) break;
+		total += length;
+		start -= 1;
+	}
+	const kept = encoded.slice(start).filter((one) => one !== "");
+	if (kept.length === 0) return void 0;
+	return "[" + kept.join(",") + "]";
 }
+/**
+* Encode the system prompt as one semconv text part, `[{ type: 'text', content }]`, under the
+* envelope ceiling. The array form keeps a prompt that happens to be valid JSON from being re-read
+* as data by ingest, which parses every string attribute first. A redaction must return a string or
+* text parts; anything else emits nothing, since ingest would discard it silently.
+*/
 function encodeSystemInstructionsValue(value, policy) {
-  if (value.length === 0) return void 0;
-  const redacted = applyRedact(value, policy, { kind: "system_instructions" });
-  if (redacted === void 0) return void 0;
-  const text = contentTextOf(redacted);
-  if (text.length === 0) return void 0;
-  return encodeTextParts(text, policy.envelopeMaxChars);
+	if (value.length === 0) return void 0;
+	const redacted = applyRedact(value, policy, { kind: "system_instructions" });
+	if (redacted === void 0) return void 0;
+	const text = contentTextOf(redacted);
+	if (text.length === 0) return void 0;
+	return encodeTextParts(text, policy.envelopeMaxChars);
 }
+/** Cut one message's text until its JSON object fits `maxChars`; undefined when even the marker cannot. */
 function encodeTruncatedMessage(message, maxChars) {
-  const text = message.parts.map((part) => part.content).join("\n");
-  return fitJson(
-    (cut) => JSON.stringify({ role: message.role, parts: [{ type: "text", content: cut }] }),
-    text,
-    maxChars
-  );
+	return fitJson((cut) => JSON.stringify({
+		role: message.role,
+		parts: [{
+			type: "text",
+			content: cut
+		}]
+	}), message.parts.map((part) => part.content).join("\n"), maxChars);
 }
 function encodeTextParts(text, maxChars) {
-  return fitJson((cut) => JSON.stringify([{ type: "text", content: cut }]), text, maxChars);
+	return fitJson((cut) => JSON.stringify([{
+		type: "text",
+		content: cut
+	}]), text, maxChars);
 }
+/**
+* Shrink `text` until `wrap(text)` fits. JSON escaping can inflate a cut by up to 6×, so the raw
+* budget is rescaled by the observed ratio each round rather than reduced by the overshoot, which
+* would go negative on escape-heavy text. Undefined when not even one character plus the marker fits.
+*/
 function fitJson(wrap, text, maxChars) {
-  let encoded = wrap(text);
-  if (encoded.length <= maxChars) return encoded;
-  const shell = wrap("").length;
-  let budget = maxChars - shell;
-  for (let round = 0; round < 8; round += 1) {
-    if (budget <= truncationMarker(text.length).length) return void 0;
-    const cut = truncate(text, budget);
-    encoded = wrap(cut);
-    if (encoded.length <= maxChars) return encoded;
-    const rescaled = Math.floor(budget * (maxChars - shell) / (encoded.length - shell));
-    budget = Math.min(budget - 1, rescaled);
-  }
-  return void 0;
+	let encoded = wrap(text);
+	if (encoded.length <= maxChars) return encoded;
+	const shell = wrap("").length;
+	let budget = maxChars - shell;
+	for (let round = 0; round < 8; round += 1) {
+		if (budget <= truncationMarker(text.length).length) return void 0;
+		encoded = wrap(truncate(text, budget));
+		if (encoded.length <= maxChars) return encoded;
+		const rescaled = Math.floor(budget * (maxChars - shell) / (encoded.length - shell));
+		budget = Math.min(budget - 1, rescaled);
+	}
 }
-function applyRedact(value, policy, context3) {
-  if (!policy.redact) return value;
-  try {
-    return policy.redact(value, context3);
-  } catch {
-    return void 0;
-  }
+/**
+* Run the redaction hook without letting it throw into the run. Returns undefined when the hook
+* suppresses the value or fails, which the caller maps to "emit nothing".
+*/
+function applyRedact(value, policy, context) {
+	if (!policy.redact) return value;
+	try {
+		return policy.redact(value, context);
+	} catch {
+		return;
+	}
 }
+/**
+* Encode arguments as a JSON object because ingest discards other shapes. Wrap non-objects as { value
+* }; replace oversized objects with a valid { truncated } envelope rather than slicing JSON.
+*/
 function encodeArguments(value, maxChars) {
-  const shaped = isPlainObject(value) ? value : { value };
-  const encoded = stringify(shaped);
-  if (encoded === void 0) return void 0;
-  if (encoded.length <= maxChars) return encoded;
-  return fitJson((cut) => JSON.stringify({ truncated: cut }), encoded, maxChars);
+	const encoded = stringify(isPlainObject(value) ? value : { value });
+	if (encoded === void 0) return void 0;
+	if (encoded.length <= maxChars) return encoded;
+	return fitJson((cut) => JSON.stringify({ truncated: cut }), encoded, maxChars);
 }
 function isPlainObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+/**
+* A string as-is, everything else as JSON. The attribute type is a string, and
+* ingest parses JSON back out; a tool result that is already prose would
+* otherwise round-trip as a quoted, escaped literal.
+*/
 function stringify(value) {
-  if (typeof value === "string") return value;
-  try {
-    const encoded = JSON.stringify(value);
-    return typeof encoded === "string" ? encoded : void 0;
-  } catch {
-    return void 0;
-  }
+	if (typeof value === "string") return value;
+	try {
+		const encoded = JSON.stringify(value);
+		return typeof encoded === "string" ? encoded : void 0;
+	} catch {
+		return;
+	}
 }
+/**
+* Reserve room for the truncation marker, then recompute its count. Budgets smaller than the marker
+* still emit that full marker, so callers must allow for its minimum size.
+*/
 function truncate(value, maxChars) {
-  if (value.length <= maxChars) return value;
-  const upperBound = truncationMarker(value.length);
-  let keep = Math.max(0, maxChars - upperBound.length);
-  let marker = truncationMarker(value.length - keep);
-  keep = Math.max(0, maxChars - marker.length);
-  marker = truncationMarker(value.length - keep);
-  if (keep > 0 && isHighSurrogate(value.charCodeAt(keep - 1))) {
-    keep -= 1;
-    marker = truncationMarker(value.length - keep);
-  }
-  return value.slice(0, keep) + marker;
+	if (value.length <= maxChars) return value;
+	const upperBound = truncationMarker(value.length);
+	let keep = Math.max(0, maxChars - upperBound.length);
+	let marker = truncationMarker(value.length - keep);
+	keep = Math.max(0, maxChars - marker.length);
+	marker = truncationMarker(value.length - keep);
+	if (keep > 0 && isHighSurrogate(value.charCodeAt(keep - 1))) {
+		keep -= 1;
+		marker = truncationMarker(value.length - keep);
+	}
+	return value.slice(0, keep) + marker;
 }
 function truncationMarker(droppedChars) {
-  return `\u2026[truncated ${droppedChars} chars]`;
+	return `…[truncated ${droppedChars} chars]`;
 }
 function isHighSurrogate(code) {
-  return code >= 55296 && code <= 56319;
+	return code >= 55296 && code <= 56319;
 }
-// package.json
-var version = "0.5.4";
-// src/semconv.ts
-var GEN_AI = {
-  operationName: "gen_ai.operation.name",
-  providerName: "gen_ai.provider.name",
-  agentName: "gen_ai.agent.name",
-  conversationId: "gen_ai.conversation.id",
-  requestModel: "gen_ai.request.model",
-  responseModel: "gen_ai.response.model",
-  responseId: "gen_ai.response.id",
-  requestStream: "gen_ai.request.stream",
-  reasoningLevel: "gen_ai.request.reasoning.level",
-  maxTokens: "gen_ai.request.max_tokens",
-  temperature: "gen_ai.request.temperature",
-  finishReasons: "gen_ai.response.finish_reasons",
-  usageInputTokens: "gen_ai.usage.input_tokens",
-  usageOutputTokens: "gen_ai.usage.output_tokens",
-  usageCacheReadTokens: "gen_ai.usage.cache_read.input_tokens",
-  usageCacheCreationTokens: "gen_ai.usage.cache_creation.input_tokens",
-  toolName: "gen_ai.tool.name",
-  toolCallId: "gen_ai.tool.call.id",
-  toolType: "gen_ai.tool.type",
-  conversationCompacted: "gen_ai.conversation.compacted",
-  errorType: "error.type",
-  serverAddress: "server.address",
-  serverPort: "server.port"
+//#endregion
+//#region package.json
+var version = "0.5.6";
+//#endregion
+//#region src/semconv.ts
+/**
+* GenAI semantic-convention attribute names. Mirrors the subset of
+* `packages/shared/src/gen-ai-semconv.ts` this instrumentation can populate
+* from Flue's STABLE observation plane.
+*/
+const GEN_AI = {
+	operationName: "gen_ai.operation.name",
+	providerName: "gen_ai.provider.name",
+	agentName: "gen_ai.agent.name",
+	conversationId: "gen_ai.conversation.id",
+	requestModel: "gen_ai.request.model",
+	responseModel: "gen_ai.response.model",
+	responseId: "gen_ai.response.id",
+	requestStream: "gen_ai.request.stream",
+	reasoningLevel: "gen_ai.request.reasoning.level",
+	maxTokens: "gen_ai.request.max_tokens",
+	temperature: "gen_ai.request.temperature",
+	finishReasons: "gen_ai.response.finish_reasons",
+	usageInputTokens: "gen_ai.usage.input_tokens",
+	usageOutputTokens: "gen_ai.usage.output_tokens",
+	usageCacheReadTokens: "gen_ai.usage.cache_read.input_tokens",
+	usageCacheCreationTokens: "gen_ai.usage.cache_creation.input_tokens",
+	toolName: "gen_ai.tool.name",
+	toolCallId: "gen_ai.tool.call.id",
+	toolType: "gen_ai.tool.type",
+	conversationCompacted: "gen_ai.conversation.compacted",
+	errorType: "error.type",
+	serverAddress: "server.address",
+	serverPort: "server.port"
 };
-var GEN_AI_CONTENT = {
-  inputMessages: "gen_ai.input.messages",
-  outputMessages: "gen_ai.output.messages",
-  systemInstructions: "gen_ai.system_instructions",
-  toolCallArguments: "gen_ai.tool.call.arguments",
-  toolCallResult: "gen_ai.tool.call.result"
+/**
+* Content attribute names, separate from the structural GEN_AI set. Tool content goes on
+* `execute_tool` spans, message content on the `invoke_agent` envelope; each kind can be switched
+* off through the content options. Mirrored in shared ingest semconv.
+*/
+const GEN_AI_CONTENT = {
+	inputMessages: "gen_ai.input.messages",
+	outputMessages: "gen_ai.output.messages",
+	systemInstructions: "gen_ai.system_instructions",
+	toolCallArguments: "gen_ai.tool.call.arguments",
+	toolCallResult: "gen_ai.tool.call.result"
 };
-var GEN_AI_OPERATION_INVOKE_AGENT = "invoke_agent";
-var GEN_AI_OPERATION_CHAT = "chat";
-var GEN_AI_OPERATION_EXECUTE_TOOL = "execute_tool";
-var RUNTYPE = {
-  agentId: "runtype.agent.id",
-  schemaVersion: "runtype.schema.version",
-  adapterName: "runtype.adapter.name",
-  adapterVersion: "runtype.adapter.version",
-  executionId: "runtype.execution.id",
-  iteration: "runtype.iteration",
-  iterations: "runtype.iterations",
-  totalCost: "runtype.total_cost",
-  stopReason: "runtype.stop_reason",
-  toolsReported: "runtype.tools.reported",
-  toolType: "runtype.tool.type",
-  turnId: "runtype.turn.id",
-  turnIndex: "runtype.turn.index",
-  providerFinishReason: "runtype.provider.finish_reason",
-  providerServiceTier: "runtype.provider.service_tier",
-  gatewayLogId: "runtype.gateway.log_id"
+/** The two GenAI operations this instrumentation claims. */
+const GEN_AI_OPERATION_INVOKE_AGENT = "invoke_agent";
+const GEN_AI_OPERATION_CHAT = "chat";
+const GEN_AI_OPERATION_EXECUTE_TOOL = "execute_tool";
+/**
+* Runtype's extension vocabulary. Placement is part of the contract and the
+* reader enforces it — see the `RUNTYPE_ATTRIBUTES` doc block in the shared
+* module for which level each name belongs on.
+*/
+const RUNTYPE = {
+	agentId: "runtype.agent.id",
+	schemaVersion: "runtype.schema.version",
+	adapterName: "runtype.adapter.name",
+	adapterVersion: "runtype.adapter.version",
+	executionId: "runtype.execution.id",
+	iteration: "runtype.iteration",
+	iterations: "runtype.iterations",
+	totalCost: "runtype.total_cost",
+	stopReason: "runtype.stop_reason",
+	toolsReported: "runtype.tools.reported",
+	toolType: "runtype.tool.type",
+	turnId: "runtype.turn.id",
+	turnIndex: "runtype.turn.index",
+	providerFinishReason: "runtype.provider.finish_reason",
+	providerServiceTier: "runtype.provider.service_tier",
+	gatewayLogId: "runtype.gateway.log_id"
 };
-var FLUE = {
-  instanceId: "flue.instance.id",
-  submissionId: "flue.submission.id",
-  agentName: "flue.agent.name",
-  harnessName: "flue.harness.name",
-  sessionName: "flue.session.name",
-  parentSessionName: "flue.parent_session.name",
-  operationId: "flue.operation.id",
-  operationKind: "flue.operation.kind",
-  turnId: "flue.turn.id",
-  turnPurpose: "flue.turn.purpose",
-  taskId: "flue.task.id",
-  eventIndex: "flue.event.index",
-  toolOrigin: "flue.tool.origin",
-  compactionReason: "flue.compaction.reason",
-  usageTotalTokens: "flue.usage.total_tokens"
+/**
+* Keep Flue vendor identifiers for existing customer dashboard grouping. Canonical runtype attributes
+* take precedence during normalization.
+*/
+const FLUE = {
+	instanceId: "flue.instance.id",
+	submissionId: "flue.submission.id",
+	agentName: "flue.agent.name",
+	harnessName: "flue.harness.name",
+	sessionName: "flue.session.name",
+	parentSessionName: "flue.parent_session.name",
+	operationId: "flue.operation.id",
+	operationKind: "flue.operation.kind",
+	turnId: "flue.turn.id",
+	turnPurpose: "flue.turn.purpose",
+	taskId: "flue.task.id",
+	eventIndex: "flue.event.index",
+	toolOrigin: "flue.tool.origin",
+	compactionReason: "flue.compaction.reason",
+	usageTotalTokens: "flue.usage.total_tokens"
 };
-var RUNTYPE_TOOL_TYPES = [
-  "flow",
-  "mcp",
-  "builtin",
-  "custom",
-  "external",
-  "advisor",
-  "subagent",
-  "local",
-  "data_connection",
-  "search"
+/**
+* `runtype.tool.type` values — the closed domain that drives display and
+* grader routing. Mirrors `RUNTYPE_TOOL_TYPES` in the shared module; only the
+* members this instrumentation can honestly assert are ever emitted (see
+* `projection.ts`).
+*/
+const RUNTYPE_TOOL_TYPES = [
+	"flow",
+	"mcp",
+	"builtin",
+	"custom",
+	"external",
+	"advisor",
+	"subagent",
+	"local",
+	"data_connection",
+	"search"
 ];
-var RUNTYPE_STOP_REASONS = [
-  "end_turn",
-  "max_tool_calls",
-  "length",
-  "content_filter",
-  "error",
-  "unknown"
+/**
+* Terminal stop reasons, in Runtype's own wire vocabulary
+* (`wireStopReasonSchema` in `packages/shared/src/utils/sse-event-schemas.ts`).
+* `runtype.stop_reason` is written to the run row verbatim, so an invented
+* value would render in the dashboard as a real fact.
+*/
+const RUNTYPE_STOP_REASONS = [
+	"end_turn",
+	"max_tool_calls",
+	"length",
+	"content_filter",
+	"error",
+	"unknown"
 ];
-var RUNTYPE_SCHEMA_VERSION = "1";
-var ADAPTER_NAME = "@runtypelabs/flue-otel";
-var ADAPTER_VERSION = version;
-// src/projection.ts
+/** The version of the `runtype.*` vocabulary this package was built against. */
+const RUNTYPE_SCHEMA_VERSION = "1";
+/** What this package reports itself as in `runtype.adapter.name`. */
+const ADAPTER_NAME = "@runtypelabs/flue-otel";
+/** What this package reports itself as in `runtype.adapter.version`. */
+const ADAPTER_VERSION = version;
+//#endregion
+//#region src/projection.ts
+/**
+* Resource attributes for the customer's `Resource`. Exported rather than set
+* internally because this package owns none of the SDK: the provider, the
+* processor, the exporter and the resource are all the application's, and a
+* library that reached into them would fight whatever the customer already runs.
+*/
 function runtypeFlueResourceAttributes(resource) {
-  return {
-    [RUNTYPE.schemaVersion]: RUNTYPE_SCHEMA_VERSION,
-    [RUNTYPE.adapterName]: ADAPTER_NAME,
-    [RUNTYPE.adapterVersion]: ADAPTER_VERSION,
-    ...resource?.agentId ? { [RUNTYPE.agentId]: resource.agentId } : {}
-  };
+	return {
+		[RUNTYPE.schemaVersion]: "1",
+		[RUNTYPE.adapterName]: ADAPTER_NAME,
+		[RUNTYPE.adapterVersion]: ADAPTER_VERSION,
+		...resource?.agentId ? { [RUNTYPE.agentId]: resource.agentId } : {}
+	};
 }
 function createFlueProjection(options = {}) {
-  const content = resolveContentPolicy(options.content);
-  const open = /* @__PURE__ */ new Map();
-  const envelopes = /* @__PURE__ */ new Map();
-  const envelopeByChain = /* @__PURE__ */ new Map();
-  const envelopeBySubmission = /* @__PURE__ */ new Map();
-  const envelopeByOperationId = /* @__PURE__ */ new Map();
-  const envelopeByTaskScope = /* @__PURE__ */ new Map();
-  const turnPositions = /* @__PURE__ */ new Map();
-  const taskTurnCounts = /* @__PURE__ */ new Map();
-  function observe(observation) {
-    switch (observation.type) {
-      case "operation_start":
-        return onOperationStart(observation);
-      case "operation":
-        return onOperationEnd(observation);
-      case "task_start":
-        return onTaskStart(observation);
-      case "task":
-        return onTaskEnd(observation);
-      case "compaction_start":
-        return onCompactionStart(observation);
-      case "compaction":
-        return onCompactionEnd(observation);
-      case "turn_request":
-        return onTurnRequest(observation);
-      case "turn":
-        return onTurnEnd(observation);
-      case "tool_start":
-        return onToolStart(observation);
-      case "tool":
-        return onToolEnd(observation);
-      case "submission_settled":
-        return onSubmissionSettled(observation);
-      default:
-        return [];
-    }
-  }
-  function onOperationStart(event) {
-    const kind = readString(event, "operationKind");
-    if (kind !== "prompt" && kind !== "skill") return [];
-    const ref = operationKey(event);
-    if (open.has(ref)) return [];
-    if (event.taskId && open.has(taskKey(event))) return [];
-    const parentRef = resolveParentRef(event);
-    const chain = chainKey(event);
-    const isEnvelope = !envelopeByChain.has(chain);
-    if (isEnvelope) {
-      envelopeByChain.set(chain, ref);
-      if (event.submissionId) envelopeBySubmission.set(event.submissionId, ref);
-      if (event.operationId) envelopeByOperationId.set(event.operationId, ref);
-      envelopes.set(ref, freshEnvelope());
-    }
-    open.set(ref, {
-      ref,
-      ...parentRef ? { parentRef } : {},
-      chainKey: chain,
-      isTask: false,
-      ...isEnvelope ? {
-        scope: {
-          instanceId: event.instanceId,
-          harness: event.harness,
-          conversationId: event.conversationId,
-          session: event.session
-        }
-      } : {}
-    });
-    const agentId = event.agentName ? options.agents?.[event.agentName] : void 0;
-    return [
-      {
-        kind: "open",
-        ref,
-        name: isEnvelope ? event.agentName ? `invoke_agent ${event.agentName}` : "invoke_agent" : `flue.operation ${kind}`,
-        spanKind: "internal",
-        ...parentRef ? { parentRef } : {},
-        ...event.timestamp ? { startTime: event.timestamp } : {},
-        attributes: {
-          ...identifiers(event),
-          [FLUE.operationKind]: kind,
-          ...isEnvelope ? { [GEN_AI.operationName]: GEN_AI_OPERATION_INVOKE_AGENT } : {},
-          ...isEnvelope && event.agentName ? { [GEN_AI.agentName]: event.agentName } : {},
-          ...isEnvelope && event.conversationId ? { [GEN_AI.conversationId]: event.conversationId } : {},
-          ...isEnvelope && event.submissionId ? { [RUNTYPE.executionId]: event.submissionId } : {},
-          ...isEnvelope && agentId ? { [RUNTYPE.agentId]: agentId } : {},
-          // WHY(README.md): the resource placement is the customer's to wire and is routinely skipped.
-          ...isEnvelope ? {
-            [RUNTYPE.adapterName]: ADAPTER_NAME,
-            [RUNTYPE.adapterVersion]: ADAPTER_VERSION
-          } : {}
-        }
-      }
-    ];
-  }
-  function onOperationEnd(event) {
-    const ref = operationKey(event);
-    const record = open.get(ref);
-    if (!record) return [];
-    const intents = sweepDescendants(ref, event.timestamp);
-    const envelope = envelopes.get(ref);
-    const isError = readBoolean(event, "isError") === true;
-    if (envelope) {
-      intents.push({ kind: "update", ref, attributes: envelopeAttributes(envelope, isError) });
-      envelopes.delete(ref);
-      if (envelopeByChain.get(record.chainKey) === ref) envelopeByChain.delete(record.chainKey);
-      for (const [submissionId, submissionRef] of envelopeBySubmission) {
-        if (submissionRef === ref) envelopeBySubmission.delete(submissionId);
-      }
-      for (const [operationId, operationRef] of envelopeByOperationId) {
-        if (operationRef === ref) envelopeByOperationId.delete(operationId);
-      }
-      for (const [taskScope, taskEnvelopeRef] of envelopeByTaskScope) {
-        if (taskEnvelopeRef === ref) envelopeByTaskScope.delete(taskScope);
-      }
-      for (const [key, position] of turnPositions) {
-        if (position.envelopeRef === ref) turnPositions.delete(key);
-      }
-    }
-    intents.push(closeIntent(ref, event, isError, readErrorInfo(event)));
-    open.delete(ref);
-    return intents;
-  }
-  function onTaskStart(event) {
-    const ref = taskKey(event);
-    if (open.has(ref)) return [];
-    const envelopeRef = event.operationId ? envelopeByOperationId.get(event.operationId) : void 0;
-    if (envelopeRef) envelopeByTaskScope.set(ref, envelopeRef);
-    const callerScope = {
-      ...envelopeRef ? open.get(envelopeRef)?.scope ?? {} : {},
-      operationId: event.operationId,
-      turnId: event.turnId,
-      toolCallId: event.toolCallId
-    };
-    const parentRef = resolveParentRef(callerScope) ?? envelopeRef;
-    open.set(ref, {
-      ref,
-      ...parentRef ? { parentRef } : {},
-      chainKey: chainKey(event),
-      isTask: true
-    });
-    taskTurnCounts.set(ref, 0);
-    const agent = readString(event, "agent");
-    return [
-      {
-        kind: "open",
-        ref,
-        // WHY(packages/flue-otel/src/projection.ts): Use a task span, not invoke_agent; one trace is persisted as one execution.
-        name: agent ? `flue.task ${agent}` : "flue.task",
-        spanKind: "internal",
-        ...parentRef ? { parentRef } : {},
-        ...event.timestamp ? { startTime: event.timestamp } : {},
-        attributes: {
-          ...identifiers(event),
-          ...agent ? { [GEN_AI.agentName]: agent } : {}
-        }
-      }
-    ];
-  }
-  function onTaskEnd(event) {
-    const ref = taskKey(event);
-    if (!open.has(ref)) return [];
-    const intents = sweepDescendants(ref, event.timestamp);
-    intents.push(
-      closeIntent(ref, event, readBoolean(event, "isError") === true, readErrorInfo(event))
-    );
-    open.delete(ref);
-    taskTurnCounts.delete(ref);
-    return intents;
-  }
-  function onCompactionStart(event) {
-    const ref = compactionKey(event);
-    if (open.has(ref)) return [];
-    const parentRef = resolveParentRef(event);
-    open.set(ref, {
-      ref,
-      ...parentRef ? { parentRef } : {},
-      chainKey: chainKey(event),
-      isTask: false
-    });
-    const reason = readString(event, "reason");
-    return [
-      {
-        kind: "open",
-        ref,
-        name: "flue.compaction",
-        spanKind: "internal",
-        requiresParent: true,
-        ...parentRef ? { parentRef } : {},
-        ...event.timestamp ? { startTime: event.timestamp } : {},
-        attributes: {
-          ...identifiers(event),
-          ...reason ? { [FLUE.compactionReason]: reason } : {}
-        }
-      }
-    ];
-  }
-  function onCompactionEnd(event) {
-    const ref = compactionKey(event);
-    if (!open.has(ref)) return [];
-    if (!event.taskId) {
-      const envelope = resolveEnvelopeRef(event);
-      const state = envelope ? envelopes.get(envelope) : void 0;
-      if (state) state.compacted = true;
-    }
-    const intents = sweepDescendants(ref, event.timestamp);
-    intents.push(
-      closeIntent(ref, event, readBoolean(event, "isError") === true, readErrorInfo(event))
-    );
-    open.delete(ref);
-    return intents;
-  }
-  function onTurnRequest(event) {
-    const ref = turnKey(event);
-    if (open.has(ref)) return [];
-    const request = readRecord(event, "request");
-    if (!request) return [];
-    const purpose = readString(event, "purpose") ?? "agent";
-    const compactionRef = compactionKey(event);
-    const parentRef = purpose !== "agent" && open.has(compactionRef) ? compactionRef : resolveParentRef(event);
-    open.set(ref, {
-      ref,
-      ...parentRef ? { parentRef } : {},
-      chainKey: chainKey(event),
-      isTask: false
-    });
-    const envelopeRef = resolveEnvelopeRef(event);
-    const envelope = envelopeRef ? envelopes.get(envelopeRef) : void 0;
-    let position;
-    if (purpose === "agent") {
-      if (!event.taskId && envelope && envelopeRef) {
-        position = {
-          turnId: event.turnId ?? "",
-          index: envelope.turnCount,
-          atEnvelopeScope: true,
-          envelopeRef
-        };
-        envelope.turnCount += 1;
-        envelope.maxIteration = position.index;
-      } else if (event.taskId) {
-        const taskRef = taskKey(event);
-        const index = taskTurnCounts.get(taskRef) ?? 0;
-        taskTurnCounts.set(taskRef, index + 1);
-        position = {
-          turnId: event.turnId ?? "",
-          index,
-          atEnvelopeScope: false,
-          ...envelopeRef ? { envelopeRef } : {}
-        };
-      }
-      if (position) turnPositions.set(ref, position);
-    }
-    if (envelope) {
-      if (!envelope.modelPinned && purpose === "agent")
-        envelope.requestModel = request.requestedModel;
-      if (Array.isArray(request.input?.tools)) envelope.toolsReported = true;
-      if (position?.atEnvelopeScope) captureInput(envelope, request);
-    }
-    return [
-      {
-        kind: "open",
-        ref,
-        name: request.requestedModel ? `${GEN_AI_OPERATION_CHAT} ${request.requestedModel}` : GEN_AI_OPERATION_CHAT,
-        spanKind: "client",
-        ...parentRef ? { parentRef } : {},
-        ...event.timestamp ? { startTime: event.timestamp } : {},
-        attributes: {
-          ...identifiers(event),
-          [GEN_AI.operationName]: GEN_AI_OPERATION_CHAT,
-          [FLUE.turnPurpose]: purpose,
-          ...request.providerName ? { [GEN_AI.providerName]: request.providerName } : {},
-          ...request.requestedModel ? { [GEN_AI.requestModel]: request.requestedModel } : {},
-          ...event.agentName ? { [GEN_AI.agentName]: event.agentName } : {},
-          ...event.conversationId ? { [GEN_AI.conversationId]: event.conversationId } : {},
-          ...request.reasoningLevel ? { [GEN_AI.reasoningLevel]: request.reasoningLevel } : {},
-          ...typeof request.maxTokens === "number" ? { [GEN_AI.maxTokens]: request.maxTokens } : {},
-          ...typeof request.temperature === "number" ? { [GEN_AI.temperature]: request.temperature } : {},
-          ...request.serverAddress ? { [GEN_AI.serverAddress]: request.serverAddress } : {},
-          ...typeof request.serverPort === "number" ? { [GEN_AI.serverPort]: request.serverPort } : {},
-          ...request.contextCompacted ? { [GEN_AI.conversationCompacted]: true } : {},
-          ...positionAttributes(position)
-        }
-      }
-    ];
-  }
-  function onTurnEnd(event) {
-    const ref = turnKey(event);
-    if (!open.has(ref)) return [];
-    const response = readRecord(event, "response") ?? {};
-    const purpose = readString(event, "purpose") ?? "agent";
-    const isError = readBoolean(event, "isError") === true;
-    const envelopeRef = resolveEnvelopeRef(event);
-    const envelope = envelopeRef ? envelopes.get(envelopeRef) : void 0;
-    if (envelope) {
-      if (!envelope.modelPinned && purpose === "agent") {
-        envelope.responseModel = response.responseModel;
-        envelope.modelPinned = true;
-      }
-      foldUsage(envelope, response.usage);
-      if (purpose === "agent" && response.finishReason) {
-        envelope.lastFinishReason = response.finishReason;
-      }
-      if (content.outputMessages && purpose === "agent" && !event.taskId && !isError) {
-        const output = projectFlueMessage(response.output);
-        if (output?.role === "assistant") envelope.outputMessage = output;
-      }
-    }
-    const attributes = {
-      ...response.responseModel ? { [GEN_AI.responseModel]: response.responseModel } : {},
-      ...response.responseId ? { [GEN_AI.responseId]: response.responseId } : {},
-      ...response.finishReason ? { [GEN_AI.finishReasons]: [response.finishReason] } : {},
-      ...usageAttributes(response.usage),
-      ...response.providerFinishReason ? { [RUNTYPE.providerFinishReason]: response.providerFinishReason } : {},
-      ...response.gatewayLogId ? { [RUNTYPE.gatewayLogId]: response.gatewayLogId } : {}
-    };
-    const intents = [];
-    if (Object.keys(attributes).length > 0) intents.push({ kind: "update", ref, attributes });
-    intents.push(closeIntent(ref, event, isError, response.error ?? readErrorInfo(event)));
-    open.delete(ref);
-    return intents;
-  }
-  function onToolStart(event) {
-    const toolName = readString(event, "toolName");
-    const toolCallId = readString(event, "toolCallId");
-    if (!toolName || !toolCallId) return [];
-    const ref = toolKey(event);
-    if (open.has(ref)) return [];
-    const parentRef = resolveParentRef(event);
-    open.set(ref, {
-      ref,
-      ...parentRef ? { parentRef } : {},
-      chainKey: chainKey(event),
-      isTask: false
-    });
-    const position = turnPositions.get(turnKey(event));
-    if (isCallerShellCall(toolName, event)) {
-      return [
-        {
-          kind: "open",
-          ref,
-          name: "flue.operation shell",
-          spanKind: "internal",
-          requiresParent: true,
-          ...parentRef ? { parentRef } : {},
-          ...event.timestamp ? { startTime: event.timestamp } : {},
-          attributes: {
-            ...identifiers(event),
-            ...event.origin ? { [FLUE.toolOrigin]: event.origin } : {},
-            ...positionAttributes(position)
-          }
-        }
-      ];
-    }
-    const isDelegation = isTaskDelegationTool(toolName, event);
-    const toolType = resolveToolType(toolName, event);
-    const args = content.toolArguments ? encodeContentValue(readUnknown(event, "args"), content, {
-      kind: "arguments",
-      toolName
-    }) : void 0;
-    return [
-      {
-        kind: "open",
-        ref,
-        name: `${GEN_AI_OPERATION_EXECUTE_TOOL} ${toolName}`,
-        spanKind: "internal",
-        ...parentRef ? { parentRef } : {},
-        ...event.timestamp ? { startTime: event.timestamp } : {},
-        attributes: {
-          ...identifiers(event),
-          [GEN_AI.operationName]: GEN_AI_OPERATION_EXECUTE_TOOL,
-          [GEN_AI.toolName]: toolName,
-          [GEN_AI.toolCallId]: toolCallId,
-          ...args !== void 0 ? { [GEN_AI_CONTENT.toolCallArguments]: args } : {},
-          ...isDelegation ? {} : { [GEN_AI.toolType]: "function" },
-          ...toolType ? { [RUNTYPE.toolType]: toolType } : {},
-          ...event.origin ? { [FLUE.toolOrigin]: event.origin } : {},
-          ...event.agentName ? { [GEN_AI.agentName]: event.agentName } : {},
-          ...event.conversationId ? { [GEN_AI.conversationId]: event.conversationId } : {},
-          ...positionAttributes(position)
-        }
-      }
-    ];
-  }
-  function onToolEnd(event) {
-    const ref = toolKey(event);
-    if (!open.has(ref)) return [];
-    const intents = sweepDescendants(ref, event.timestamp);
-    const isError = readBoolean(event, "isError") === true;
-    const toolName = readString(event, "toolName");
-    if (content.toolResults && !isError && toolName && !isCallerShellCall(toolName, event)) {
-      const result = encodeContentValue(readToolResult(event), content, {
-        kind: "result",
-        toolName
-      });
-      if (result !== void 0) {
-        intents.push({
-          kind: "update",
-          ref,
-          attributes: { [GEN_AI_CONTENT.toolCallResult]: result }
-        });
-      }
-    }
-    intents.push(closeIntent(ref, event, isError, readErrorInfo(event)));
-    open.delete(ref);
-    return intents;
-  }
-  function onSubmissionSettled(event) {
-    const outcome = readString(event, "outcome");
-    if (!outcome) return [];
-    const stopReason = mapSettlementOutcome(outcome);
-    if (!stopReason) return [];
-    const submissionId = readString(event, "submissionId");
-    if (!submissionId) return [];
-    const ref = envelopeBySubmission.get(submissionId);
-    const envelope = ref ? envelopes.get(ref) : void 0;
-    if (envelope) envelope.settlementStopReason = stopReason;
-    return [];
-  }
-  function envelopeAttributes(envelope, isError) {
-    const stopReason = isError ? "error" : envelope.settlementStopReason ?? mapFinishReason(envelope.lastFinishReason);
-    return {
-      ...envelope.requestModel ? { [GEN_AI.requestModel]: envelope.requestModel } : {},
-      ...envelope.responseModel ? { [GEN_AI.responseModel]: envelope.responseModel } : {},
-      ...envelope.sawUsage ? {
-        [GEN_AI.usageInputTokens]: envelope.inputTokens,
-        [GEN_AI.usageOutputTokens]: envelope.outputTokens,
-        [GEN_AI.usageCacheReadTokens]: envelope.cacheReadTokens,
-        [GEN_AI.usageCacheCreationTokens]: envelope.cacheCreationTokens
-      } : {},
-      ...stopReason ? { [RUNTYPE.stopReason]: stopReason } : {},
-      ...envelope.toolsReported ? { [RUNTYPE.toolsReported]: true } : {},
-      ...envelope.maxIteration !== null ? { [RUNTYPE.iteration]: envelope.maxIteration } : {},
-      ...envelopeContentAttributes(envelope)
-    };
-  }
-  function captureInput(envelope, request) {
-    const input = request.input;
-    if (envelope.inputRaw && (envelope.compacted || isCompactedHistory(input?.messages))) return;
-    if (content.inputMessages && Array.isArray(input?.messages) && input.messages.length > 0) {
-      envelope.inputRaw = input.messages;
-      envelope.inputBaseCount ??= input.messages.length;
-    }
-    if (content.systemInstructions && typeof input?.systemPrompt === "string") {
-      envelope.systemInstructions = input.systemPrompt;
-    }
-  }
-  function isCompactedHistory(messages) {
-    if (!Array.isArray(messages) || messages.length === 0) return false;
-    const first = messages[0];
-    if (!first || first.role !== "user") return false;
-    return flueMessageText(first.content).startsWith(COMPACTION_SUMMARY_PREFIX);
-  }
-  function projectInput(envelope) {
-    const raw = envelope.inputRaw ?? [];
-    const base = envelope.inputBaseCount ?? raw.length;
-    return [
-      ...projectFlueMessages(raw.slice(0, base)),
-      ...projectFlueMessages(raw.slice(base)).filter((message) => message.role !== "assistant")
-    ];
-  }
-  function envelopeContentAttributes(envelope) {
-    const input = envelope.inputRaw ? encodeMessagesValue(projectInput(envelope), content, "input_messages") : void 0;
-    const system = envelope.systemInstructions ? encodeSystemInstructionsValue(envelope.systemInstructions, content) : void 0;
-    const output = envelope.outputMessage ? encodeMessagesValue([envelope.outputMessage], content, "output_messages") : void 0;
-    return {
-      ...input !== void 0 ? { [GEN_AI_CONTENT.inputMessages]: input } : {},
-      ...system !== void 0 ? { [GEN_AI_CONTENT.systemInstructions]: system } : {},
-      ...output !== void 0 ? { [GEN_AI_CONTENT.outputMessages]: output } : {}
-    };
-  }
-  function resolveEnvelopeRef(event) {
-    if (event.taskId) {
-      const viaTask = envelopeByTaskScope.get(taskKey(event));
-      if (viaTask) return viaTask;
-    }
-    return envelopeByChain.get(chainKey(event));
-  }
-  function resolveParentRef(scope) {
-    if (scope.taskId) {
-      const ref = taskKey(scope);
-      if (open.has(ref)) return ref;
-    }
-    if (scope.toolCallId) {
-      const ref = toolKey(scope);
-      if (open.has(ref)) return ref;
-    }
-    if (scope.operationId) {
-      const ref = operationKey(scope);
-      if (open.has(ref)) return ref;
-    }
-    return void 0;
-  }
-  function sweepDescendants(parentRef, endTime) {
-    const doomed = [];
-    const frontier = [parentRef];
-    while (frontier.length > 0) {
-      const current = frontier.pop();
-      for (const record of open.values()) {
-        if (record.parentRef !== current) continue;
-        doomed.push(record.ref);
-        frontier.push(record.ref);
-      }
-    }
-    const intents = [];
-    for (const ref of doomed.reverse()) {
-      const record = open.get(ref);
-      if (!record) continue;
-      intents.push({
-        kind: "close",
-        ref,
-        ...endTime ? { endTime } : {},
-        error: { type: "interrupted" }
-      });
-      open.delete(ref);
-      if (record.isTask) taskTurnCounts.delete(ref);
-    }
-    return intents;
-  }
-  function drain(endTime) {
-    const intents = [];
-    for (const ref of [...open.keys()].reverse()) {
-      const envelope = envelopes.get(ref);
-      if (envelope) {
-        intents.push({ kind: "update", ref, attributes: envelopeAttributes(envelope, true) });
-      }
-      intents.push({
-        kind: "close",
-        ref,
-        ...endTime ? { endTime } : {},
-        error: { type: "interrupted" }
-      });
-    }
-    open.clear();
-    envelopes.clear();
-    envelopeByChain.clear();
-    envelopeBySubmission.clear();
-    envelopeByOperationId.clear();
-    envelopeByTaskScope.clear();
-    turnPositions.clear();
-    taskTurnCounts.clear();
-    return intents;
-  }
-  return { observe, drain, hasOpenSpan: (ref) => open.has(ref) };
+	const content = resolveContentPolicy(options.content);
+	/** Every open span, in open order, so `drain` can close deepest-first. */
+	const open = /* @__PURE__ */ new Map();
+	const envelopes = /* @__PURE__ */ new Map();
+	/** chainKey → the ref of the envelope currently bounding that agent run. */
+	const envelopeByChain = /* @__PURE__ */ new Map();
+	/**
+	* Index durable envelopes by submissionId: coordinator settlements lack the conversation/session
+	* fields used by run events and cannot share their chain key.
+	*/
+	const envelopeBySubmission = /* @__PURE__ */ new Map();
+	/**
+	* Join child work to its envelope using operationId and task scope. A delegated session has different
+	* chain keys, so chain-only lookup loses its usage.
+	*/
+	const envelopeByOperationId = /* @__PURE__ */ new Map();
+	const envelopeByTaskScope = /* @__PURE__ */ new Map();
+	/** turnKey → its loop position, retained until the owning envelope closes. */
+	const turnPositions = /* @__PURE__ */ new Map();
+	/** Task ref → that sub-agent's own turn counter. */
+	const taskTurnCounts = /* @__PURE__ */ new Map();
+	function observe(observation) {
+		switch (observation.type) {
+			case "operation_start": return onOperationStart(observation);
+			case "operation": return onOperationEnd(observation);
+			case "task_start": return onTaskStart(observation);
+			case "task": return onTaskEnd(observation);
+			case "compaction_start": return onCompactionStart(observation);
+			case "compaction": return onCompactionEnd(observation);
+			case "turn_request": return onTurnRequest(observation);
+			case "turn": return onTurnEnd(observation);
+			case "tool_start": return onToolStart(observation);
+			case "tool": return onToolEnd(observation);
+			case "submission_settled": return onSubmissionSettled(observation);
+			default: return [];
+		}
+	}
+	function onOperationStart(event) {
+		const kind = readString(event, "operationKind");
+		if (kind !== "prompt" && kind !== "skill") return [];
+		const ref = operationKey(event);
+		if (open.has(ref)) return [];
+		if (event.taskId && open.has(taskKey(event))) return [];
+		const parentRef = resolveParentRef(event);
+		const chain = chainKey(event);
+		const isEnvelope = !envelopeByChain.has(chain);
+		if (isEnvelope) {
+			envelopeByChain.set(chain, ref);
+			if (event.submissionId) envelopeBySubmission.set(event.submissionId, ref);
+			if (event.operationId) envelopeByOperationId.set(event.operationId, ref);
+			envelopes.set(ref, freshEnvelope());
+		}
+		open.set(ref, {
+			ref,
+			...parentRef ? { parentRef } : {},
+			chainKey: chain,
+			isTask: false,
+			...isEnvelope ? { scope: {
+				instanceId: event.instanceId,
+				harness: event.harness,
+				conversationId: event.conversationId,
+				session: event.session
+			} } : {}
+		});
+		const agentId = event.agentName ? options.agents?.[event.agentName] : void 0;
+		return [{
+			kind: "open",
+			ref,
+			name: isEnvelope ? event.agentName ? `invoke_agent ${event.agentName}` : "invoke_agent" : `flue.operation ${kind}`,
+			spanKind: "internal",
+			...parentRef ? { parentRef } : {},
+			...event.timestamp ? { startTime: event.timestamp } : {},
+			attributes: {
+				...identifiers(event),
+				[FLUE.operationKind]: kind,
+				...isEnvelope ? { [GEN_AI.operationName]: GEN_AI_OPERATION_INVOKE_AGENT } : {},
+				...isEnvelope && event.agentName ? { [GEN_AI.agentName]: event.agentName } : {},
+				...isEnvelope && event.conversationId ? { [GEN_AI.conversationId]: event.conversationId } : {},
+				...isEnvelope && event.submissionId ? { [RUNTYPE.executionId]: event.submissionId } : {},
+				...isEnvelope && agentId ? { [RUNTYPE.agentId]: agentId } : {},
+				...isEnvelope ? {
+					[RUNTYPE.adapterName]: ADAPTER_NAME,
+					[RUNTYPE.adapterVersion]: ADAPTER_VERSION
+				} : {}
+			}
+		}];
+	}
+	function onOperationEnd(event) {
+		const ref = operationKey(event);
+		const record = open.get(ref);
+		if (!record) return [];
+		const intents = sweepDescendants(ref, event.timestamp);
+		const envelope = envelopes.get(ref);
+		const isError = readBoolean(event, "isError") === true;
+		if (envelope) {
+			intents.push({
+				kind: "update",
+				ref,
+				attributes: envelopeAttributes(envelope, isError)
+			});
+			envelopes.delete(ref);
+			if (envelopeByChain.get(record.chainKey) === ref) envelopeByChain.delete(record.chainKey);
+			for (const [submissionId, submissionRef] of envelopeBySubmission) if (submissionRef === ref) envelopeBySubmission.delete(submissionId);
+			for (const [operationId, operationRef] of envelopeByOperationId) if (operationRef === ref) envelopeByOperationId.delete(operationId);
+			for (const [taskScope, taskEnvelopeRef] of envelopeByTaskScope) if (taskEnvelopeRef === ref) envelopeByTaskScope.delete(taskScope);
+			for (const [key, position] of turnPositions) if (position.envelopeRef === ref) turnPositions.delete(key);
+		}
+		intents.push(closeIntent(ref, event, isError, readErrorInfo(event)));
+		open.delete(ref);
+		return intents;
+	}
+	function onTaskStart(event) {
+		const ref = taskKey(event);
+		if (open.has(ref)) return [];
+		const envelopeRef = event.operationId ? envelopeByOperationId.get(event.operationId) : void 0;
+		if (envelopeRef) envelopeByTaskScope.set(ref, envelopeRef);
+		const parentRef = resolveParentRef({
+			...envelopeRef ? open.get(envelopeRef)?.scope ?? {} : {},
+			operationId: event.operationId,
+			turnId: event.turnId,
+			toolCallId: event.toolCallId
+		}) ?? envelopeRef;
+		open.set(ref, {
+			ref,
+			...parentRef ? { parentRef } : {},
+			chainKey: chainKey(event),
+			isTask: true
+		});
+		taskTurnCounts.set(ref, 0);
+		const agent = readString(event, "agent");
+		return [{
+			kind: "open",
+			ref,
+			name: agent ? `flue.task ${agent}` : "flue.task",
+			spanKind: "internal",
+			...parentRef ? { parentRef } : {},
+			...event.timestamp ? { startTime: event.timestamp } : {},
+			attributes: {
+				...identifiers(event),
+				...agent ? { [GEN_AI.agentName]: agent } : {}
+			}
+		}];
+	}
+	function onTaskEnd(event) {
+		const ref = taskKey(event);
+		if (!open.has(ref)) return [];
+		const intents = sweepDescendants(ref, event.timestamp);
+		intents.push(closeIntent(ref, event, readBoolean(event, "isError") === true, readErrorInfo(event)));
+		open.delete(ref);
+		taskTurnCounts.delete(ref);
+		return intents;
+	}
+	function onCompactionStart(event) {
+		const ref = compactionKey(event);
+		if (open.has(ref)) return [];
+		const parentRef = resolveParentRef(event);
+		open.set(ref, {
+			ref,
+			...parentRef ? { parentRef } : {},
+			chainKey: chainKey(event),
+			isTask: false
+		});
+		const reason = readString(event, "reason");
+		return [{
+			kind: "open",
+			ref,
+			name: "flue.compaction",
+			spanKind: "internal",
+			requiresParent: true,
+			...parentRef ? { parentRef } : {},
+			...event.timestamp ? { startTime: event.timestamp } : {},
+			attributes: {
+				...identifiers(event),
+				...reason ? { [FLUE.compactionReason]: reason } : {}
+			}
+		}];
+	}
+	function onCompactionEnd(event) {
+		const ref = compactionKey(event);
+		if (!open.has(ref)) return [];
+		if (!event.taskId) {
+			const envelope = resolveEnvelopeRef(event);
+			const state = envelope ? envelopes.get(envelope) : void 0;
+			if (state) state.compacted = true;
+		}
+		const intents = sweepDescendants(ref, event.timestamp);
+		intents.push(closeIntent(ref, event, readBoolean(event, "isError") === true, readErrorInfo(event)));
+		open.delete(ref);
+		return intents;
+	}
+	function onTurnRequest(event) {
+		const ref = turnKey(event);
+		if (open.has(ref)) return [];
+		const request = readRecord(event, "request");
+		if (!request) return [];
+		const purpose = readString(event, "purpose") ?? "agent";
+		const compactionRef = compactionKey(event);
+		const parentRef = purpose !== "agent" && open.has(compactionRef) ? compactionRef : resolveParentRef(event);
+		open.set(ref, {
+			ref,
+			...parentRef ? { parentRef } : {},
+			chainKey: chainKey(event),
+			isTask: false
+		});
+		const envelopeRef = resolveEnvelopeRef(event);
+		const envelope = envelopeRef ? envelopes.get(envelopeRef) : void 0;
+		let position;
+		if (purpose === "agent") {
+			if (!event.taskId && envelope && envelopeRef) {
+				position = {
+					turnId: event.turnId ?? "",
+					index: envelope.turnCount,
+					atEnvelopeScope: true,
+					envelopeRef
+				};
+				envelope.turnCount += 1;
+				envelope.maxIteration = position.index;
+			} else if (event.taskId) {
+				const taskRef = taskKey(event);
+				const index = taskTurnCounts.get(taskRef) ?? 0;
+				taskTurnCounts.set(taskRef, index + 1);
+				position = {
+					turnId: event.turnId ?? "",
+					index,
+					atEnvelopeScope: false,
+					...envelopeRef ? { envelopeRef } : {}
+				};
+			}
+			if (position) turnPositions.set(ref, position);
+		}
+		if (envelope) {
+			if (!envelope.modelPinned && purpose === "agent") envelope.requestModel = request.requestedModel;
+			if (Array.isArray(request.input?.tools)) envelope.toolsReported = true;
+			if (position?.atEnvelopeScope) captureInput(envelope, request);
+		}
+		return [{
+			kind: "open",
+			ref,
+			name: request.requestedModel ? `${GEN_AI_OPERATION_CHAT} ${request.requestedModel}` : GEN_AI_OPERATION_CHAT,
+			spanKind: "client",
+			...parentRef ? { parentRef } : {},
+			...event.timestamp ? { startTime: event.timestamp } : {},
+			attributes: {
+				...identifiers(event),
+				[GEN_AI.operationName]: GEN_AI_OPERATION_CHAT,
+				[FLUE.turnPurpose]: purpose,
+				...request.providerName ? { [GEN_AI.providerName]: request.providerName } : {},
+				...request.requestedModel ? { [GEN_AI.requestModel]: request.requestedModel } : {},
+				...event.agentName ? { [GEN_AI.agentName]: event.agentName } : {},
+				...event.conversationId ? { [GEN_AI.conversationId]: event.conversationId } : {},
+				...request.reasoningLevel ? { [GEN_AI.reasoningLevel]: request.reasoningLevel } : {},
+				...typeof request.maxTokens === "number" ? { [GEN_AI.maxTokens]: request.maxTokens } : {},
+				...typeof request.temperature === "number" ? { [GEN_AI.temperature]: request.temperature } : {},
+				...request.serverAddress ? { [GEN_AI.serverAddress]: request.serverAddress } : {},
+				...typeof request.serverPort === "number" ? { [GEN_AI.serverPort]: request.serverPort } : {},
+				...request.contextCompacted ? { [GEN_AI.conversationCompacted]: true } : {},
+				...positionAttributes(position)
+			}
+		}];
+	}
+	function onTurnEnd(event) {
+		const ref = turnKey(event);
+		if (!open.has(ref)) return [];
+		const response = readRecord(event, "response") ?? {};
+		const purpose = readString(event, "purpose") ?? "agent";
+		const isError = readBoolean(event, "isError") === true;
+		const envelopeRef = resolveEnvelopeRef(event);
+		const envelope = envelopeRef ? envelopes.get(envelopeRef) : void 0;
+		if (envelope) {
+			if (!envelope.modelPinned && purpose === "agent") {
+				envelope.responseModel = response.responseModel;
+				envelope.modelPinned = true;
+			}
+			foldUsage(envelope, response.usage);
+			if (purpose === "agent" && response.finishReason) envelope.lastFinishReason = response.finishReason;
+			if (content.outputMessages && purpose === "agent" && !event.taskId && !isError) {
+				const output = projectFlueMessage(response.output);
+				if (output?.role === "assistant") envelope.outputMessage = output;
+			}
+		}
+		const attributes = {
+			...response.responseModel ? { [GEN_AI.responseModel]: response.responseModel } : {},
+			...response.responseId ? { [GEN_AI.responseId]: response.responseId } : {},
+			...response.finishReason ? { [GEN_AI.finishReasons]: [response.finishReason] } : {},
+			...usageAttributes(response.usage),
+			...response.providerFinishReason ? { [RUNTYPE.providerFinishReason]: response.providerFinishReason } : {},
+			...response.gatewayLogId ? { [RUNTYPE.gatewayLogId]: response.gatewayLogId } : {}
+		};
+		const intents = [];
+		if (Object.keys(attributes).length > 0) intents.push({
+			kind: "update",
+			ref,
+			attributes
+		});
+		intents.push(closeIntent(ref, event, isError, response.error ?? readErrorInfo(event)));
+		open.delete(ref);
+		return intents;
+	}
+	function onToolStart(event) {
+		const toolName = readString(event, "toolName");
+		const toolCallId = readString(event, "toolCallId");
+		if (!toolName || !toolCallId) return [];
+		const ref = toolKey(event);
+		if (open.has(ref)) return [];
+		const parentRef = resolveParentRef(event);
+		open.set(ref, {
+			ref,
+			...parentRef ? { parentRef } : {},
+			chainKey: chainKey(event),
+			isTask: false
+		});
+		const position = turnPositions.get(turnKey(event));
+		if (isCallerShellCall(toolName, event)) return [{
+			kind: "open",
+			ref,
+			name: "flue.operation shell",
+			spanKind: "internal",
+			requiresParent: true,
+			...parentRef ? { parentRef } : {},
+			...event.timestamp ? { startTime: event.timestamp } : {},
+			attributes: {
+				...identifiers(event),
+				...event.origin ? { [FLUE.toolOrigin]: event.origin } : {},
+				...positionAttributes(position)
+			}
+		}];
+		const isDelegation = isTaskDelegationTool(toolName, event);
+		const toolType = resolveToolType(toolName, event);
+		const args = content.toolArguments ? encodeContentValue(readUnknown(event, "args"), content, {
+			kind: "arguments",
+			toolName
+		}) : void 0;
+		return [{
+			kind: "open",
+			ref,
+			name: `${GEN_AI_OPERATION_EXECUTE_TOOL} ${toolName}`,
+			spanKind: "internal",
+			...parentRef ? { parentRef } : {},
+			...event.timestamp ? { startTime: event.timestamp } : {},
+			attributes: {
+				...identifiers(event),
+				[GEN_AI.operationName]: GEN_AI_OPERATION_EXECUTE_TOOL,
+				[GEN_AI.toolName]: toolName,
+				[GEN_AI.toolCallId]: toolCallId,
+				...args !== void 0 ? { [GEN_AI_CONTENT.toolCallArguments]: args } : {},
+				...isDelegation ? {} : { [GEN_AI.toolType]: "function" },
+				...toolType ? { [RUNTYPE.toolType]: toolType } : {},
+				...event.origin ? { [FLUE.toolOrigin]: event.origin } : {},
+				...event.agentName ? { [GEN_AI.agentName]: event.agentName } : {},
+				...event.conversationId ? { [GEN_AI.conversationId]: event.conversationId } : {},
+				...positionAttributes(position)
+			}
+		}];
+	}
+	function onToolEnd(event) {
+		const ref = toolKey(event);
+		if (!open.has(ref)) return [];
+		const intents = sweepDescendants(ref, event.timestamp);
+		const isError = readBoolean(event, "isError") === true;
+		const toolName = readString(event, "toolName");
+		if (content.toolResults && !isError && toolName && !isCallerShellCall(toolName, event)) {
+			const result = encodeContentValue(readToolResult(event), content, {
+				kind: "result",
+				toolName
+			});
+			if (result !== void 0) intents.push({
+				kind: "update",
+				ref,
+				attributes: { [GEN_AI_CONTENT.toolCallResult]: result }
+			});
+		}
+		intents.push(closeIntent(ref, event, isError, readErrorInfo(event)));
+		open.delete(ref);
+		return intents;
+	}
+	function onSubmissionSettled(event) {
+		const outcome = readString(event, "outcome");
+		if (!outcome) return [];
+		const stopReason = mapSettlementOutcome(outcome);
+		if (!stopReason) return [];
+		const submissionId = readString(event, "submissionId");
+		if (!submissionId) return [];
+		const ref = envelopeBySubmission.get(submissionId);
+		const envelope = ref ? envelopes.get(ref) : void 0;
+		if (envelope) envelope.settlementStopReason = stopReason;
+		return [];
+	}
+	/**
+	* Fold the run-level facts onto the envelope. Applied once, at close, so a
+	* split export cannot ship a half-summed total: the batch carrying the
+	* terminal carries the complete roll-up by construction.
+	*/
+	function envelopeAttributes(envelope, isError) {
+		const stopReason = isError ? "error" : envelope.settlementStopReason ?? mapFinishReason(envelope.lastFinishReason);
+		return {
+			...envelope.requestModel ? { [GEN_AI.requestModel]: envelope.requestModel } : {},
+			...envelope.responseModel ? { [GEN_AI.responseModel]: envelope.responseModel } : {},
+			...envelope.sawUsage ? {
+				[GEN_AI.usageInputTokens]: envelope.inputTokens,
+				[GEN_AI.usageOutputTokens]: envelope.outputTokens,
+				[GEN_AI.usageCacheReadTokens]: envelope.cacheReadTokens,
+				[GEN_AI.usageCacheCreationTokens]: envelope.cacheCreationTokens
+			} : {},
+			...stopReason ? { [RUNTYPE.stopReason]: stopReason } : {},
+			...envelope.toolsReported ? { [RUNTYPE.toolsReported]: true } : {},
+			...envelope.maxIteration !== null ? { [RUNTYPE.iteration]: envelope.maxIteration } : {},
+			...envelopeContentAttributes(envelope)
+		};
+	}
+	/**
+	* The first agent turn's history is the conversation the run was given. Later turns re-capture it
+	* plus any user message dispatched mid-run, but never the run's own assistant rows (the tool spans
+	* and the output carry those) and never a post-compaction summary in place of an earlier capture.
+	*/
+	function captureInput(envelope, request) {
+		const input = request.input;
+		if (envelope.inputRaw && (envelope.compacted || isCompactedHistory(input?.messages))) return;
+		if (content.inputMessages && Array.isArray(input?.messages) && input.messages.length > 0) {
+			envelope.inputRaw = input.messages;
+			envelope.inputBaseCount ??= input.messages.length;
+		}
+		if (content.systemInstructions && typeof input?.systemPrompt === "string") envelope.systemInstructions = input.systemPrompt;
+	}
+	/**
+	* Flue does not flag a compacted request on either line, so the summary row it puts first is the
+	* signal; the `compaction` observation is the other, and both are honoured.
+	*/
+	function isCompactedHistory(messages) {
+		if (!Array.isArray(messages) || messages.length === 0) return false;
+		const first = messages[0];
+		if (!first || first.role !== "user") return false;
+		return flueMessageText(first.content).startsWith(COMPACTION_SUMMARY_PREFIX);
+	}
+	/** The seed: the first turn's history plus later user rows, never the run's own assistant rows. */
+	function projectInput(envelope) {
+		const raw = envelope.inputRaw ?? [];
+		const base = envelope.inputBaseCount ?? raw.length;
+		return [...projectFlueMessages(raw.slice(0, base)), ...projectFlueMessages(raw.slice(base)).filter((message) => message.role !== "assistant")];
+	}
+	/** Encoded once, at close, so the redaction hook and the size ceiling run once per run. */
+	function envelopeContentAttributes(envelope) {
+		const input = envelope.inputRaw ? encodeMessagesValue(projectInput(envelope), content, "input_messages") : void 0;
+		const system = envelope.systemInstructions ? encodeSystemInstructionsValue(envelope.systemInstructions, content) : void 0;
+		const output = envelope.outputMessage ? encodeMessagesValue([envelope.outputMessage], content, "output_messages") : void 0;
+		return {
+			...input !== void 0 ? { [GEN_AI_CONTENT.inputMessages]: input } : {},
+			...system !== void 0 ? { [GEN_AI_CONTENT.systemInstructions]: system } : {},
+			...output !== void 0 ? { [GEN_AI_CONTENT.outputMessages]: output } : {}
+		};
+	}
+	/**
+	* Find the enclosing task, tool, or operation span. Undefined lets the driver inherit the
+	* interceptor's active context for nesting not expressible in correlation fields.
+	*/
+	/**
+	* The envelope a span's work belongs to.
+	*
+	* Task-scoped events resolve through the task index, because a delegated
+	* sub-agent's chain fields describe its own child session and can never match
+	* the caller's. Everything else resolves by chain, as before.
+	*/
+	function resolveEnvelopeRef(event) {
+		if (event.taskId) {
+			const viaTask = envelopeByTaskScope.get(taskKey(event));
+			if (viaTask) return viaTask;
+		}
+		return envelopeByChain.get(chainKey(event));
+	}
+	function resolveParentRef(scope) {
+		if (scope.taskId) {
+			const ref = taskKey(scope);
+			if (open.has(ref)) return ref;
+		}
+		if (scope.toolCallId) {
+			const ref = toolKey(scope);
+			if (open.has(ref)) return ref;
+		}
+		if (scope.operationId) {
+			const ref = operationKey(scope);
+			if (open.has(ref)) return ref;
+		}
+	}
+	/**
+	* Close descendants deepest-first using recorded parentRef links; delegated task keys need not share a
+	* prefix with their parent.
+	*/
+	function sweepDescendants(parentRef, endTime) {
+		const doomed = [];
+		const frontier = [parentRef];
+		while (frontier.length > 0) {
+			const current = frontier.pop();
+			for (const record of open.values()) {
+				if (record.parentRef !== current) continue;
+				doomed.push(record.ref);
+				frontier.push(record.ref);
+			}
+		}
+		const intents = [];
+		for (const ref of doomed.reverse()) {
+			const record = open.get(ref);
+			if (!record) continue;
+			intents.push({
+				kind: "close",
+				ref,
+				...endTime ? { endTime } : {},
+				error: { type: "interrupted" }
+			});
+			open.delete(ref);
+			if (record.isTask) taskTurnCounts.delete(ref);
+		}
+		return intents;
+	}
+	function drain(endTime) {
+		const intents = [];
+		for (const ref of [...open.keys()].reverse()) {
+			const envelope = envelopes.get(ref);
+			if (envelope) intents.push({
+				kind: "update",
+				ref,
+				attributes: envelopeAttributes(envelope, true)
+			});
+			intents.push({
+				kind: "close",
+				ref,
+				...endTime ? { endTime } : {},
+				error: { type: "interrupted" }
+			});
+		}
+		open.clear();
+		envelopes.clear();
+		envelopeByChain.clear();
+		envelopeBySubmission.clear();
+		envelopeByOperationId.clear();
+		envelopeByTaskScope.clear();
+		turnPositions.clear();
+		taskTurnCounts.clear();
+		return intents;
+	}
+	return {
+		observe,
+		drain,
+		hasOpenSpan: (ref) => open.has(ref)
+	};
 }
 function freshEnvelope() {
-  return {
-    turnCount: 0,
-    maxIteration: null,
-    modelPinned: false,
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheReadTokens: 0,
-    cacheCreationTokens: 0,
-    sawUsage: false,
-    toolsReported: false
-  };
+	return {
+		turnCount: 0,
+		maxIteration: null,
+		modelPinned: false,
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheCreationTokens: 0,
+		sawUsage: false,
+		toolsReported: false
+	};
 }
 function foldUsage(envelope, usage) {
-  if (!usage) return;
-  const input = positiveNumber(usage.input);
-  const output = positiveNumber(usage.output);
-  const cacheRead = positiveNumber(usage.cacheRead);
-  const cacheWrite = positiveNumber(usage.cacheWrite);
-  if (input === 0 && output === 0 && cacheRead === 0 && cacheWrite === 0) return;
-  envelope.sawUsage = true;
-  envelope.inputTokens += input + cacheRead + cacheWrite;
-  envelope.outputTokens += output;
-  envelope.cacheReadTokens += cacheRead;
-  envelope.cacheCreationTokens += cacheWrite;
+	if (!usage) return;
+	const input = positiveNumber(usage.input);
+	const output = positiveNumber(usage.output);
+	const cacheRead = positiveNumber(usage.cacheRead);
+	const cacheWrite = positiveNumber(usage.cacheWrite);
+	if (input === 0 && output === 0 && cacheRead === 0 && cacheWrite === 0) return;
+	envelope.sawUsage = true;
+	envelope.inputTokens += input + cacheRead + cacheWrite;
+	envelope.outputTokens += output;
+	envelope.cacheReadTokens += cacheRead;
+	envelope.cacheCreationTokens += cacheWrite;
 }
 function usageAttributes(usage) {
-  if (!usage) return {};
-  const cacheRead = positiveNumber(usage.cacheRead);
-  const cacheWrite = positiveNumber(usage.cacheWrite);
-  return {
-    [GEN_AI.usageInputTokens]: positiveNumber(usage.input) + cacheRead + cacheWrite,
-    [GEN_AI.usageOutputTokens]: positiveNumber(usage.output),
-    [GEN_AI.usageCacheReadTokens]: cacheRead,
-    [GEN_AI.usageCacheCreationTokens]: cacheWrite,
-    ...typeof usage.totalTokens === "number" ? { [FLUE.usageTotalTokens]: usage.totalTokens } : {}
-  };
+	if (!usage) return {};
+	const cacheRead = positiveNumber(usage.cacheRead);
+	const cacheWrite = positiveNumber(usage.cacheWrite);
+	return {
+		[GEN_AI.usageInputTokens]: positiveNumber(usage.input) + cacheRead + cacheWrite,
+		[GEN_AI.usageOutputTokens]: positiveNumber(usage.output),
+		[GEN_AI.usageCacheReadTokens]: cacheRead,
+		[GEN_AI.usageCacheCreationTokens]: cacheWrite,
+		...typeof usage.totalTokens === "number" ? { [FLUE.usageTotalTokens]: usage.totalTokens } : {}
+	};
 }
 function positionAttributes(position) {
-  if (!position) return {};
-  return {
-    ...position.turnId ? { [RUNTYPE.turnId]: position.turnId } : {},
-    [RUNTYPE.turnIndex]: position.index,
-    // WHY(packages/flue-otel/src/projection.ts): Do not stamp delegated turns with root iteration positions; they would inflate the run iteration count.
-    ...position.atEnvelopeScope ? { [RUNTYPE.iteration]: position.index } : {}
-  };
+	if (!position) return {};
+	return {
+		...position.turnId ? { [RUNTYPE.turnId]: position.turnId } : {},
+		[RUNTYPE.turnIndex]: position.index,
+		...position.atEnvelopeScope ? { [RUNTYPE.iteration]: position.index } : {}
+	};
 }
+/**
+* The vendor correlation identifiers, on every span. These are what the
+* server-side Flue normalizer detects on, and what a customer's existing
+* dashboards are grouped by; see the note on `FLUE` in `semconv.ts`.
+*/
 function identifiers(event) {
-  return {
-    ...event.instanceId ? { [FLUE.instanceId]: event.instanceId } : {},
-    ...event.submissionId ? { [FLUE.submissionId]: event.submissionId } : {},
-    ...event.agentName ? { [FLUE.agentName]: event.agentName } : {},
-    ...event.harness ? { [FLUE.harnessName]: event.harness } : {},
-    ...event.session ? { [FLUE.sessionName]: event.session } : {},
-    ...event.parentSession ? { [FLUE.parentSessionName]: event.parentSession } : {},
-    ...event.operationId ? { [FLUE.operationId]: event.operationId } : {},
-    ...event.turnId ? { [FLUE.turnId]: event.turnId } : {},
-    ...event.taskId ? { [FLUE.taskId]: event.taskId } : {},
-    ...typeof event.eventIndex === "number" ? { [FLUE.eventIndex]: event.eventIndex } : {}
-  };
+	return {
+		...event.instanceId ? { [FLUE.instanceId]: event.instanceId } : {},
+		...event.submissionId ? { [FLUE.submissionId]: event.submissionId } : {},
+		...event.agentName ? { [FLUE.agentName]: event.agentName } : {},
+		...event.harness ? { [FLUE.harnessName]: event.harness } : {},
+		...event.session ? { [FLUE.sessionName]: event.session } : {},
+		...event.parentSession ? { [FLUE.parentSessionName]: event.parentSession } : {},
+		...event.operationId ? { [FLUE.operationId]: event.operationId } : {},
+		...event.turnId ? { [FLUE.turnId]: event.turnId } : {},
+		...event.taskId ? { [FLUE.taskId]: event.taskId } : {},
+		...typeof event.eventIndex === "number" ? { [FLUE.eventIndex]: event.eventIndex } : {}
+	};
 }
 function closeIntent(ref, event, isError, errorInfo) {
-  return {
-    kind: "close",
-    ref,
-    ...event.timestamp ? { endTime: event.timestamp } : {},
-    ...isError ? {
-      error: {
-        type: errorInfo?.type ?? "_OTHER",
-        ...errorInfo?.name ? { exceptionType: errorInfo.name } : {}
-      }
-    } : {}
-  };
+	return {
+		kind: "close",
+		ref,
+		...event.timestamp ? { endTime: event.timestamp } : {},
+		...isError ? { error: {
+			type: errorInfo?.type ?? "_OTHER",
+			...errorInfo?.name ? { exceptionType: errorInfo.name } : {}
+		} } : {}
+	};
 }
 function readErrorInfo(event) {
-  const detail = event.errorInfo;
-  return detail !== null && typeof detail === "object" ? detail : void 0;
+	const detail = event.errorInfo;
+	return detail !== null && typeof detail === "object" ? detail : void 0;
 }
 function readUnknown(event, key) {
-  return event[key];
+	return event[key];
 }
+/**
+* Prefer effectiveResult when the key exists, even if undefined: it is the post-processed value the
+* model saw. Fall back to raw result only when the key is absent.
+*/
 function readToolResult(event) {
-  const record = event;
-  return Object.prototype.hasOwnProperty.call(record, "effectiveResult") ? record.effectiveResult : record.result;
+	const record = event;
+	return Object.prototype.hasOwnProperty.call(record, "effectiveResult") ? record.effectiveResult : record.result;
 }
 function readString(event, key) {
-  const value = event[key];
-  return typeof value === "string" && value.length > 0 ? value : void 0;
+	const value = event[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function readBoolean(event, key) {
-  const value = event[key];
-  return typeof value === "boolean" ? value : void 0;
+	const value = event[key];
+	return typeof value === "boolean" ? value : void 0;
 }
 function readRecord(event, key) {
-  const value = event[key];
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+	const value = event[key];
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function positiveNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }
+/**
+* Scope one run by instance, harness, conversation, and session. Excluding operation/submission ids
+* relies on Flue serializing operations per session; adding them would disconnect turn-to-envelope
+* lookup.
+*/
 function chainKey(value) {
-  return identityKey("chain", [
-    value.instanceId,
-    value.harness,
-    value.conversationId,
-    value.session
-  ]);
+	return identityKey("chain", [
+		value.instanceId,
+		value.harness,
+		value.conversationId,
+		value.session
+	]);
 }
 function operationKey(value) {
-  return identityKey("operation", [
-    value.instanceId,
-    value.harness,
-    value.conversationId,
-    value.session,
-    value.taskId,
-    value.operationId
-  ]);
+	return identityKey("operation", [
+		value.instanceId,
+		value.harness,
+		value.conversationId,
+		value.session,
+		value.taskId,
+		value.operationId
+	]);
 }
 function taskKey(value) {
-  return identityKey("task", [
-    value.instanceId,
-    value.harness,
-    value.conversationId,
-    value.session,
-    value.taskId
-  ]);
+	return identityKey("task", [
+		value.instanceId,
+		value.harness,
+		value.conversationId,
+		value.session,
+		value.taskId
+	]);
 }
 function compactionKey(value) {
-  return identityKey("compaction", [
-    value.instanceId,
-    value.harness,
-    value.conversationId,
-    value.session,
-    value.taskId,
-    value.operationId
-  ]);
+	return identityKey("compaction", [
+		value.instanceId,
+		value.harness,
+		value.conversationId,
+		value.session,
+		value.taskId,
+		value.operationId
+	]);
 }
 function turnKey(value) {
-  return identityKey("turn", [
-    value.instanceId,
-    value.harness,
-    value.conversationId,
-    value.session,
-    value.taskId,
-    value.operationId,
-    value.turnId
-  ]);
+	return identityKey("turn", [
+		value.instanceId,
+		value.harness,
+		value.conversationId,
+		value.session,
+		value.taskId,
+		value.operationId,
+		value.turnId
+	]);
 }
 function toolKey(value) {
-  return identityKey("tool", [
-    value.instanceId,
-    value.harness,
-    value.conversationId,
-    value.session,
-    value.taskId,
-    value.operationId,
-    value.turnId,
-    value.toolCallId
-  ]);
+	return identityKey("tool", [
+		value.instanceId,
+		value.harness,
+		value.conversationId,
+		value.session,
+		value.taskId,
+		value.operationId,
+		value.turnId,
+		value.toolCallId
+	]);
 }
 function identityKey(kind, fields) {
-  return JSON.stringify([kind, ...fields.map((value) => value ?? null)]);
+	return JSON.stringify([kind, ...fields.map((value) => value ?? null)]);
 }
-// src/spans.ts
-var import_api = require("@opentelemetry/api");
+//#endregion
+//#region src/spans.ts
 function createSpanDriver(tracer) {
-  const live = /* @__PURE__ */ new Map();
-  function apply(intents) {
-    for (const intent of intents) {
-      switch (intent.kind) {
-        case "open": {
-          if (live.has(intent.ref)) break;
-          const parent = intent.parentRef ? live.get(intent.parentRef) : void 0;
-          const active = import_api.context.active();
-          const parentContext = parent ? import_api.trace.setSpan(active, parent) : import_api.trace.getSpanContext(active) ? active : void 0;
-          if (parentContext === void 0 && intent.requiresParent) break;
-          const span = tracer.startSpan(
-            intent.name,
-            {
-              kind: intent.spanKind === "client" ? import_api.SpanKind.CLIENT : import_api.SpanKind.INTERNAL,
-              root: parentContext === void 0,
-              ...intent.startTime ? { startTime: toDate(intent.startTime) } : {},
-              attributes: intent.attributes
-            },
-            parentContext
-          );
-          live.set(intent.ref, span);
-          break;
-        }
-        case "update": {
-          live.get(intent.ref)?.setAttributes(intent.attributes);
-          break;
-        }
-        case "close": {
-          const span = live.get(intent.ref);
-          if (!span) break;
-          if (intent.error) {
-            span.setAttribute(GEN_AI.errorType, intent.error.type);
-            span.setStatus({ code: import_api.SpanStatusCode.ERROR });
-            if (intent.error.exceptionType) {
-              span.recordException({ name: intent.error.exceptionType });
-            }
-          }
-          span.end(intent.endTime ? toDate(intent.endTime) : void 0);
-          live.delete(intent.ref);
-          break;
-        }
-      }
-    }
-  }
-  return { apply, spanFor: (ref) => live.get(ref) };
+	const live = /* @__PURE__ */ new Map();
+	function apply(intents) {
+		for (const intent of intents) switch (intent.kind) {
+			case "open": {
+				if (live.has(intent.ref)) break;
+				const parent = intent.parentRef ? live.get(intent.parentRef) : void 0;
+				const active = _opentelemetry_api.context.active();
+				const parentContext = parent ? _opentelemetry_api.trace.setSpan(active, parent) : _opentelemetry_api.trace.getSpanContext(active) ? active : void 0;
+				if (parentContext === void 0 && intent.requiresParent) break;
+				const span = tracer.startSpan(intent.name, {
+					kind: intent.spanKind === "client" ? _opentelemetry_api.SpanKind.CLIENT : _opentelemetry_api.SpanKind.INTERNAL,
+					root: parentContext === void 0,
+					...intent.startTime ? { startTime: toDate(intent.startTime) } : {},
+					attributes: intent.attributes
+				}, parentContext);
+				live.set(intent.ref, span);
+				break;
+			}
+			case "update":
+				live.get(intent.ref)?.setAttributes(intent.attributes);
+				break;
+			case "close": {
+				const span = live.get(intent.ref);
+				if (!span) break;
+				if (intent.error) {
+					span.setAttribute(GEN_AI.errorType, intent.error.type);
+					span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+					if (intent.error.exceptionType) span.recordException({ name: intent.error.exceptionType });
+				}
+				span.end(intent.endTime ? toDate(intent.endTime) : void 0);
+				live.delete(intent.ref);
+				break;
+			}
+		}
+	}
+	return {
+		apply,
+		spanFor: (ref) => live.get(ref)
+	};
 }
+/**
+* Prefer the span for this operation, then the dispatched W3C traceCarrier. Carrier extraction needs
+* an application-registered propagator; the no-op propagator otherwise preserves context.
+*/
 function contextForOperation(span, carrier) {
-  if (span) return import_api.trace.setSpan(import_api.context.active(), span);
-  if (carrier) {
-    return import_api.propagation.extract(import_api.context.active(), carrier, {
-      keys: () => carrier.tracestate ? ["traceparent", "tracestate"] : ["traceparent"],
-      get: (value, key) => value[key]
-    });
-  }
-  return void 0;
+	if (span) return _opentelemetry_api.trace.setSpan(_opentelemetry_api.context.active(), span);
+	if (carrier) return _opentelemetry_api.propagation.extract(_opentelemetry_api.context.active(), carrier, {
+		keys: () => carrier.tracestate ? ["traceparent", "tracestate"] : ["traceparent"],
+		get: (value, key) => value[key]
+	});
 }
+/**
+* Flue timestamps are ISO-8601 strings. An unparseable one would make
+* `span.end()` throw inside the runtime's own emit path, so it degrades to the
+* SDK's clock instead: a span on the wrong clock is a smaller problem than an
+* instrumentation that can break the agent it observes.
+*/
 function toDate(value) {
-  const date = new Date(value);
-  return Number.isNaN(date.getTime()) ? void 0 : date;
+	const date = new Date(value);
+	return Number.isNaN(date.getTime()) ? void 0 : date;
 }
-// src/index.ts
-var RUNTYPE_FLUE_INSTRUMENTATION_KEY = /* @__PURE__ */ Symbol.for(
-  "@runtypelabs/flue-otel"
-);
+//#endregion
+//#region src/index.ts
+/**
+* The instrumentation key. Distinct from stock's
+* `Symbol.for('@flue/opentelemetry')` so `instrument()` treats the two as
+* different subscribers and composes them rather than replacing one.
+*/
+const RUNTYPE_FLUE_INSTRUMENTATION_KEY = Symbol.for("@runtypelabs/flue-otel");
+/**
+* Build an observe/interceptor pair for Flue's instrument(). The interceptor activates spans and joins
+* dispatched trace carriers. Configure the OTel SDK externally, and point only one instrumentation at
+* Runtype to avoid double counting.
+*/
 function createRuntypeFlueInstrumentation(options = {}) {
-  const tracer = options.tracer ?? import_api2.trace.getTracer(ADAPTER_NAME);
-  const projection = createFlueProjection(options);
-  const driver = createSpanDriver(tracer);
-  let disposed = false;
-  const observe = (observation) => {
-    if (disposed) return;
-    try {
-      driver.apply(projection.observe(observation));
-    } catch {
-    }
-  };
-  const interceptor = (operation, executionContext, next) => {
-    if (disposed) return next();
-    const span = spanForOperation(operation, executionContext);
-    const active = contextForOperation(span, executionContext.traceCarrier);
-    if (!active) return next();
-    return import_api2.context.with(active, next);
-  };
-  function spanForOperation(operation, executionContext) {
-    switch (operation.type) {
-      case "agent":
-        return driver.spanFor(
-          operationKey({ ...executionContext, operationId: readIdField(operation, "operationId") })
-        );
-      case "model":
-        return driver.spanFor(
-          turnKey({ ...executionContext, turnId: readIdField(operation, "turnId") })
-        );
-      case "tool":
-        return driver.spanFor(
-          toolKey({ ...executionContext, toolCallId: readIdField(operation, "toolCallId") })
-        );
-      case "task":
-        return driver.spanFor(
-          taskKey({ ...executionContext, taskId: readIdField(operation, "taskId") })
-        );
-      default:
-        return void 0;
-    }
-  }
-  return {
-    key: RUNTYPE_FLUE_INSTRUMENTATION_KEY,
-    observe,
-    interceptor,
-    dispose() {
-      if (disposed) return;
-      disposed = true;
-      try {
-        driver.apply(projection.drain((/* @__PURE__ */ new Date()).toISOString()));
-      } catch {
-      }
-    }
-  };
+	const tracer = options.tracer ?? _opentelemetry_api.trace.getTracer("@runtypelabs/flue-otel");
+	const projection = createFlueProjection(options);
+	const driver = createSpanDriver(tracer);
+	let disposed = false;
+	const observe = (observation) => {
+		if (disposed) return;
+		try {
+			driver.apply(projection.observe(observation));
+		} catch {}
+	};
+	const interceptor = (operation, executionContext, next) => {
+		if (disposed) return next();
+		const active = contextForOperation(spanForOperation(operation, executionContext), executionContext.traceCarrier);
+		if (!active) return next();
+		return _opentelemetry_api.context.with(active, next);
+	};
+	function spanForOperation(operation, executionContext) {
+		switch (operation.type) {
+			case "agent": return driver.spanFor(operationKey({
+				...executionContext,
+				operationId: readIdField(operation, "operationId")
+			}));
+			case "model": return driver.spanFor(turnKey({
+				...executionContext,
+				turnId: readIdField(operation, "turnId")
+			}));
+			case "tool": return driver.spanFor(toolKey({
+				...executionContext,
+				toolCallId: readIdField(operation, "toolCallId")
+			}));
+			case "task": return driver.spanFor(taskKey({
+				...executionContext,
+				taskId: readIdField(operation, "taskId")
+			}));
+			default: return;
+		}
+	}
+	return {
+		key: RUNTYPE_FLUE_INSTRUMENTATION_KEY,
+		observe,
+		interceptor,
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			try {
+				driver.apply(projection.drain((/* @__PURE__ */ new Date()).toISOString()));
+			} catch {}
+		}
+	};
 }
+/**
+* Read a correlation id off the operation. The `FlueExecutionOperation` union
+* carries an open `{ type: string }` arm so an unknown future kind falls
+* through rather than failing to compile, which defeats discriminated-union
+* narrowing — hence the keyed read instead of a property access.
+*/
 function readIdField(operation, key) {
-  const value = operation[key];
-  return typeof value === "string" && value.length > 0 ? value : void 0;
+	const value = operation[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ADAPTER_NAME,
-  ADAPTER_VERSION,
-  DEFAULT_CONTENT_MAX_CHARS,
-  GEN_AI,
-  GEN_AI_CONTENT,
-  INGEST_CONTENT_ATTRIBUTE_CEILING,
-  RUNTYPE,
-  RUNTYPE_FLUE_INSTRUMENTATION_KEY,
-  RUNTYPE_SCHEMA_VERSION,
-  RUNTYPE_STOP_REASONS,
-  RUNTYPE_TOOL_TYPES,
-  createRuntypeFlueInstrumentation,
-  runtypeFlueResourceAttributes
-});
+//#endregion
+exports.ADAPTER_NAME = ADAPTER_NAME;
+exports.ADAPTER_VERSION = ADAPTER_VERSION;
+exports.DEFAULT_CONTENT_MAX_CHARS = DEFAULT_CONTENT_MAX_CHARS;
+exports.GEN_AI = GEN_AI;
+exports.GEN_AI_CONTENT = GEN_AI_CONTENT;
+exports.INGEST_CONTENT_ATTRIBUTE_CEILING = INGEST_CONTENT_ATTRIBUTE_CEILING;
+exports.RUNTYPE = RUNTYPE;
+exports.RUNTYPE_FLUE_INSTRUMENTATION_KEY = RUNTYPE_FLUE_INSTRUMENTATION_KEY;
+exports.RUNTYPE_SCHEMA_VERSION = RUNTYPE_SCHEMA_VERSION;
+exports.RUNTYPE_STOP_REASONS = RUNTYPE_STOP_REASONS;
+exports.RUNTYPE_TOOL_TYPES = RUNTYPE_TOOL_TYPES;
+exports.createRuntypeFlueInstrumentation = createRuntypeFlueInstrumentation;
+exports.runtypeFlueResourceAttributes = runtypeFlueResourceAttributes;