@cognipeer/agent-sdk 0.16.0 → 0.18.0

package/dist/index.cjs

@@ -8,6 +8,8 @@ var path = require('path');
 var buffer = require('buffer');
 var nanoid = require('nanoid');
 var crypto = require('crypto');
+var zlib = require('zlib');
+var util = require('util');
 var AjvModule = require('ajv');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -1231,9 +1233,1398 @@ function splitUsage(usage) {
   }
   return { own, subagent, ownCalls: ownEntries.length, subagentCalls: subagentEntries.length, ownEntries, subagentEntries };
 }
+function cacheWriteTokensOf(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const details = raw.prompt_tokens_details || raw.promptTokensDetails || raw.input_token_details || raw.inputTokenDetails || {};
+  const candidates = [
+    details.cache_write_tokens,
+    details.cacheWriteTokens,
+    details.cache_creation,
+    raw.cache_write_tokens,
+    raw.cacheWriteTokens,
+    raw.cache_creation_input_tokens,
+    raw.cacheCreationInputTokens,
+    raw.cacheWriteInputTokens,
+    raw.cacheWriteInputTokenCount
+  ];
+  for (const value of candidates) {
+    const n = Number(value);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return void 0;
+}
 
 // src/utils/tracing.ts
 init_content();
+
+// src/version.ts
+var SDK_VERSION = "0.18.0";
+
+// src/utils/otlp/content.ts
+init_content();
+
+// src/utils/otlp/semconv.ts
+var GENAI_SEMCONV_COMMIT = "547934a";
+var ATTR = {
+  operationName: "gen_ai.operation.name",
+  providerName: "gen_ai.provider.name",
+  requestModel: "gen_ai.request.model",
+  responseModel: "gen_ai.response.model",
+  responseId: "gen_ai.response.id",
+  finishReasons: "gen_ai.response.finish_reasons",
+  requestStream: "gen_ai.request.stream",
+  outputType: "gen_ai.output.type",
+  conversationId: "gen_ai.conversation.id",
+  agentName: "gen_ai.agent.name",
+  agentVersion: "gen_ai.agent.version",
+  toolName: "gen_ai.tool.name",
+  toolCallId: "gen_ai.tool.call.id",
+  toolType: "gen_ai.tool.type",
+  usageInput: "gen_ai.usage.input_tokens",
+  usageOutput: "gen_ai.usage.output_tokens",
+  usageCacheRead: "gen_ai.usage.cache_read.input_tokens",
+  usageCacheWrite: "gen_ai.usage.cache_write.input_tokens",
+  usageReasoning: "gen_ai.usage.reasoning.output_tokens",
+  errorType: "error.type",
+  // Content (opt-in).
+  systemInstructions: "gen_ai.system_instructions",
+  inputMessages: "gen_ai.input.messages",
+  outputMessages: "gen_ai.output.messages",
+  toolDefinitions: "gen_ai.tool.definitions",
+  toolCallArguments: "gen_ai.tool.call.arguments",
+  toolCallResult: "gen_ai.tool.call.result"
+};
+var OPERATION = {
+  chat: "chat",
+  executeTool: "execute_tool",
+  invokeAgent: "invoke_agent"
+};
+var PROVIDERS = {
+  openai: "openai",
+  chatopenai: "openai",
+  azure: "azure.ai.openai",
+  azureopenai: "azure.ai.openai",
+  azurechatopenai: "azure.ai.openai",
+  azureaiopenai: "azure.ai.openai",
+  azureaiinference: "azure.ai.inference",
+  anthropic: "anthropic",
+  chatanthropic: "anthropic",
+  bedrock: "aws.bedrock",
+  awsbedrock: "aws.bedrock",
+  chatbedrock: "aws.bedrock",
+  chatbedrockconverse: "aws.bedrock",
+  vertex: "gcp.vertex_ai",
+  vertexai: "gcp.vertex_ai",
+  gcpvertexai: "gcp.vertex_ai",
+  chatvertexai: "gcp.vertex_ai",
+  gemini: "gcp.gemini",
+  gcpgemini: "gcp.gemini",
+  chatgooglegenerativeai: "gcp.gemini",
+  // Gemini API or Vertex: the name alone does not say which.
+  google: "gcp.gen_ai",
+  gcpgenai: "gcp.gen_ai",
+  mistral: "mistral",
+  mistralai: "mistral",
+  chatmistralai: "mistral",
+  groq: "groq",
+  chatgroq: "groq",
+  deepseek: "deepseek",
+  chatdeepseek: "deepseek",
+  cohere: "cohere",
+  chatcohere: "cohere",
+  xai: "x_ai",
+  chatxai: "x_ai",
+  perplexity: "perplexity",
+  chatperplexity: "perplexity",
+  watsonx: "ibm.watsonx.ai",
+  ibmwatsonxai: "ibm.watsonx.ai"
+};
+function genAiProviderName(hint) {
+  if (!hint) return void 0;
+  const key = hint.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return key ? PROVIDERS[key] : void 0;
+}
+function errorTypeOf(error) {
+  if (!error) return "_OTHER";
+  if (typeof error.type === "string" && error.type.length > 0) return error.type;
+  if (typeof error.stack === "string") {
+    const match = /^\s*([A-Za-z_$][\w$.]*)\s*(?::|$)/m.exec(error.stack.split("\n", 1)[0] ?? "");
+    if (match) return match[1];
+  }
+  return "_OTHER";
+}
+function genAiUsageOf(event) {
+  const num2 = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+  const input = num2(event.inputTokens);
+  const output = num2(event.outputTokens);
+  const cacheRead = num2(event.cachedInputTokens);
+  const cacheWrite = num2(event.cacheWriteTokens);
+  const reasoning = num2(event.reasoningTokens);
+  if (input + output + cacheRead + cacheWrite + reasoning + num2(event.totalTokens) === 0) return void 0;
+  const basis = event.usageBasis ?? {};
+  return {
+    input: basis.inputExcludesCache ? input + cacheRead + cacheWrite : input,
+    output: basis.outputExcludesReasoning ? output + reasoning : output,
+    ...cacheRead > 0 ? { cacheRead } : {},
+    ...cacheWrite > 0 ? { cacheWrite } : {},
+    ...reasoning > 0 ? { reasoning } : {}
+  };
+}
+
+// src/utils/otlp/content.ts
+var CAPTURE = Symbol.for("cognipeer.agent-sdk.traceCapture");
+var DEFAULTS = {
+  maxStringChars: 4096,
+  maxMessages: 32,
+  maxAttributeBytes: 32768
+};
+var FIELDS = ["system", "input", "output", "tools", "toolArgs", "toolResults", "sections"];
+function resolveContentOptions(content) {
+  const given = typeof content === "object" && content !== null ? content : {};
+  const enabled = typeof content === "boolean" ? content : given.enabled === true;
+  const positive = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.floor(value) : fallback;
+  return {
+    enabled,
+    include: Array.isArray(given.include) ? given.include.filter((field) => FIELDS.includes(field)) : [...FIELDS],
+    maxStringChars: positive(given.maxStringChars, DEFAULTS.maxStringChars),
+    maxMessages: positive(given.maxMessages, DEFAULTS.maxMessages),
+    maxAttributeBytes: positive(given.maxAttributeBytes, DEFAULTS.maxAttributeBytes),
+    redact: typeof given.redact === "function" ? given.redact : void 0,
+    encoding: given.encoding === "structured" ? "structured" : "json"
+  };
+}
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function plain(value) {
+  if (value === void 0) return void 0;
+  try {
+    const text = JSON.stringify(value);
+    return text === void 0 ? void 0 : JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+var TRUNCATED_MARKER = /\.\.\.\[truncated (\d+) chars\]$/;
+function truncateText(text, max) {
+  const earlier = TRUNCATED_MARKER.exec(text);
+  const body = earlier ? text.slice(0, earlier.index) : text;
+  if (body.length <= max) return text;
+  const lost = body.length - max + (earlier ? Number(earlier[1]) : 0);
+  return `${body.slice(0, max)}...[truncated ${lost} chars]`;
+}
+function capStrings(value, max) {
+  if (typeof value === "string") return truncateText(value, max);
+  if (Array.isArray(value)) return value.map((item) => capStrings(item, max));
+  if (isRecord2(value)) {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) out[key] = capStrings(item, max);
+    return out;
+  }
+  return value;
+}
+function asObject(value) {
+  let parsed = value;
+  if (typeof value === "string") {
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      parsed = value;
+    }
+  }
+  const copy = plain(parsed);
+  if (copy === void 0) return void 0;
+  return isRecord2(copy) ? copy : { value: copy };
+}
+var REASONING_PART_TYPES = /* @__PURE__ */ new Set(["thinking", "redacted_thinking", "reasoning", "reasoning_content"]);
+function textOf(content) {
+  if (content == null) return "";
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return contentPartToText(content, () => "");
+  return content.filter((part) => !(isRecord2(part) && REASONING_PART_TYPES.has(String(part.type)))).map((part) => contentPartToText(part, () => "")).filter((text) => text.length > 0).join("\n");
+}
+function toolCallPartsOf(message) {
+  const calls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+  const parts = [];
+  for (const call of calls) {
+    if (!isRecord2(call)) continue;
+    const name = call.name ?? call.function?.name;
+    if (typeof name !== "string" || !name) continue;
+    const args = call.args ?? call.arguments ?? call.function?.arguments;
+    const coerced = asObject(args ?? {});
+    const id = typeof call.id === "string" && call.id && !call.idSynthesized ? call.id : void 0;
+    parts.push({ type: "tool_call", ...id ? { id } : {}, name, arguments: coerced ?? {} });
+  }
+  return parts;
+}
+function messageOf(raw) {
+  if (!isRecord2(raw)) return void 0;
+  const role = typeof raw.role === "string" ? raw.role : "user";
+  const parts = [];
+  if (role === "tool") {
+    const text2 = textOf(raw.content);
+    const parsed = (() => {
+      try {
+        return JSON.parse(text2);
+      } catch {
+        return text2;
+      }
+    })();
+    parts.push({
+      type: "tool_call_response",
+      ...typeof raw.tool_call_id === "string" && raw.tool_call_id ? { id: raw.tool_call_id } : {},
+      response: plain(parsed) ?? text2
+    });
+    return { role, parts, ...typeof raw.name === "string" && raw.name ? { name: raw.name } : {} };
+  }
+  const text = textOf(raw.content);
+  if (text) parts.push({ type: "text", content: text });
+  if (role === "assistant") parts.push(...toolCallPartsOf(raw));
+  if (parts.length === 0 && role !== "assistant") parts.push({ type: "text", content: "" });
+  return { role, parts };
+}
+function buildCapturedContent(source, limits) {
+  const out = {};
+  if (Array.isArray(source.input)) {
+    const system = [];
+    const messages = [];
+    for (const raw of source.input) {
+      const message = messageOf(raw);
+      if (!message) continue;
+      if (message.role === "system") {
+        const content = message.parts.map((part) => part.type === "text" ? part.content : "").join("\n");
+        if (content) system.push({ type: "text", content });
+      } else {
+        messages.push(message);
+      }
+    }
+    if (system.length > 0) out.system = capStrings(system, limits.maxStringChars);
+    const recent = messages.slice(-limits.maxMessages);
+    out.input = capStrings(recent, limits.maxStringChars);
+  }
+  if (source.output !== void 0 && source.output !== null) {
+    const message = messageOf({ ...isRecord2(source.output) ? source.output : { content: String(source.output) }, role: "assistant" });
+    if (message) out.output = capStrings(message, limits.maxStringChars);
+  }
+  if (Array.isArray(source.toolDefinitions) && source.toolDefinitions.length > 0) {
+    out.tools = capStrings(
+      source.toolDefinitions.filter((tool) => tool && typeof tool.name === "string").map((tool) => ({
+        type: "function",
+        name: tool.name,
+        ...tool.description ? { description: tool.description } : {},
+        ...tool.parameters !== void 0 ? { parameters: plain(tool.parameters) } : {}
+      })),
+      limits.maxStringChars
+    );
+  }
+  if (source.toolArguments !== void 0) {
+    const args = asObject(source.toolArguments);
+    if (args !== void 0) out.toolArgs = capStrings(args, limits.maxStringChars);
+  }
+  if (source.hasToolResult || source.toolResult !== void 0) {
+    const result = asObject(source.toolResult);
+    if (result !== void 0) out.toolResults = capStrings(result, limits.maxStringChars);
+  }
+  return out;
+}
+function capturedContentOf(event) {
+  return event?.[CAPTURE];
+}
+function attachCapturedContent(record, content) {
+  Object.defineProperty(record, CAPTURE, { value: content, enumerable: false, configurable: true, writable: true });
+}
+var SEPARATE_SYSTEM = /* @__PURE__ */ new Set(["anthropic", "aws.bedrock", "gcp.vertex_ai", "gcp.gemini"]);
+function toAnyValue(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") return { stringValue: value };
+  if (typeof value === "boolean") return { boolValue: value };
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return void 0;
+    return Number.isInteger(value) && Number.isSafeInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+  }
+  if (Array.isArray(value)) {
+    return { arrayValue: { values: value.map((item) => toAnyValue(item) ?? { stringValue: "" }) } };
+  }
+  if (isRecord2(value)) {
+    const values = [];
+    for (const [key, item] of Object.entries(value)) {
+      const any = toAnyValue(item);
+      if (any) values.push({ key, value: any });
+    }
+    return { kvlistValue: { values } };
+  }
+  return void 0;
+}
+var byteLength = (text) => buffer.Buffer.byteLength(text, "utf8");
+function render(value, field, options, info) {
+  let working = plain(value);
+  if (working === void 0) return void 0;
+  if (options.redact) {
+    try {
+      working = options.redact(plain(working), { field, ...info });
+    } catch {
+      return void 0;
+    }
+    working = plain(working);
+    if (working === void 0 || working === null) return void 0;
+  }
+  working = capStrings(working, options.maxStringChars);
+  if ((field === "input" || field === "system" || field === "sections") && Array.isArray(working) && working.length > options.maxMessages) {
+    working = working.slice(-options.maxMessages);
+  }
+  let text = JSON.stringify(working);
+  if (text === void 0) return void 0;
+  if (byteLength(text) > options.maxAttributeBytes) {
+    if (field === "input" && Array.isArray(working)) {
+      const messages = [...working];
+      while (messages.length > 1 && byteLength(JSON.stringify(messages)) > options.maxAttributeBytes) messages.shift();
+      working = messages;
+      text = JSON.stringify(working);
+    }
+    if (byteLength(text) > options.maxAttributeBytes) {
+      working = { truncated: true };
+      text = JSON.stringify(working);
+    }
+  }
+  return options.encoding === "structured" ? toAnyValue(working) : { stringValue: text };
+}
+function contentAttributes(kind, event, provider, options) {
+  if (!options?.enabled) return [];
+  const captured = capturedContentOf(event);
+  if (!captured) return [];
+  const include = new Set(options.include);
+  const info = {
+    eventType: event.type,
+    ...event.spanId ? { spanId: event.spanId } : {},
+    ...kind === "execute_tool" && event.actor?.name ? { toolName: event.actor.name } : {},
+    ...event.model ? { model: event.model } : {}
+  };
+  const attrs = [];
+  const add = (key, value) => {
+    if (value) attrs.push({ key, value });
+  };
+  if (kind === "chat") {
+    const separate = provider !== void 0 && SEPARATE_SYSTEM.has(provider);
+    const system = captured.system ?? [];
+    if (separate) {
+      if (include.has("system") && system.length > 0) add(ATTR.systemInstructions, render(system, "system", options, info));
+      if (include.has("input") && captured.input) add(ATTR.inputMessages, render(captured.input, "input", options, info));
+    } else if (include.has("input") && (captured.input || system.length > 0)) {
+      const messages = captured.input ?? [];
+      const capped = messages.slice(-options.maxMessages);
+      const withSystem = system.length > 0 ? [{ role: "system", parts: system }, ...capped] : capped;
+      add(ATTR.inputMessages, render(withSystem, "input", { ...options, maxMessages: options.maxMessages + 1 }, info));
+    }
+    if (include.has("output") && captured.output) {
+      const reason = event.rawFinishReason ?? event.finishReason;
+      const finish = reason === "tool_calls" ? "tool_call" : reason;
+      add(ATTR.outputMessages, render([{ ...captured.output, ...finish ? { finish_reason: finish } : {} }], "output", options, info));
+    }
+    if (include.has("tools") && captured.tools) add(ATTR.toolDefinitions, render(captured.tools, "tools", options, info));
+  } else {
+    if (include.has("toolArgs") && captured.toolArgs !== void 0) add(ATTR.toolCallArguments, render(captured.toolArgs, "toolArgs", options, info));
+    if (include.has("toolResults") && captured.toolResults !== void 0) add(ATTR.toolCallResult, render(captured.toolResults, "toolResults", options, info));
+  }
+  return attrs;
+}
+function sectionsAttribute(sections, event, options) {
+  if (!sections || sections.length === 0) return void 0;
+  const identity2 = sections.filter((section) => section.identity === true);
+  const payload = sections.filter((section) => section.identity !== true);
+  let kept = [];
+  if (options?.enabled && options.include.includes("sections") && payload.length > 0) {
+    kept = redactedSections(payload, options, event);
+  }
+  const max = options?.maxAttributeBytes ?? DEFAULTS.maxAttributeBytes;
+  const encode = (list) => {
+    try {
+      return JSON.stringify(list);
+    } catch {
+      return void 0;
+    }
+  };
+  let text = encode([...identity2, ...kept]);
+  while (text !== void 0 && kept.length > 0 && byteLength(text) > max) {
+    kept.shift();
+    text = encode([...identity2, ...kept]);
+  }
+  if (text === void 0) {
+    text = encode(identity2);
+  }
+  if (text === void 0 || text === "[]") return void 0;
+  return { key: "cognipeer.sections", value: { stringValue: text } };
+}
+function redactedSections(payload, options, event) {
+  let working = plain(payload);
+  if (working === void 0) return [];
+  if (options.redact) {
+    try {
+      working = plain(options.redact(plain(working), {
+        field: "sections",
+        eventType: event.type,
+        ...event.spanId ? { spanId: event.spanId } : {},
+        ...event.model ? { model: event.model } : {}
+      }));
+    } catch {
+      return [];
+    }
+    if (!Array.isArray(working)) return [];
+  }
+  const capped = capStrings(working, options.maxStringChars);
+  return Array.isArray(capped) ? capped.slice(-options.maxMessages) : [];
+}
+
+// src/utils/otlp/convert.ts
+var SCOPE_NAME = "cognipeer-agent-sdk";
+var SPAN_KIND_INTERNAL = 1;
+var SPAN_KIND_CLIENT = 3;
+var FLAG_HAS_PARENT = 256;
+var FLAG_REMOTE_PARENT = 512;
+var MAX_STATUS_MESSAGE = 1024;
+var str = (key, value) => value != null && value !== "" ? { key, value: { stringValue: value } } : null;
+var strAllowEmpty = (key, value) => value != null ? { key, value: { stringValue: value } } : null;
+var int = (key, value) => typeof value === "number" && Number.isFinite(value) ? { key, value: { intValue: String(Math.trunc(value)) } } : null;
+var dbl = (key, value) => typeof value === "number" && Number.isFinite(value) ? { key, value: { doubleValue: value } } : null;
+var bool = (key, value) => typeof value === "boolean" ? { key, value: { boolValue: value } } : null;
+var strArray = (key, values) => ({
+  key,
+  value: { arrayValue: { values: values.map((value) => ({ stringValue: value })) } }
+});
+var compact = (list) => list.filter((entry) => Boolean(entry));
+function msToNs(ms) {
+  const whole = Math.floor(ms);
+  return BigInt(whole) * 1000000n + BigInt(Math.round((ms - whole) * 1e6));
+}
+function parseMs(iso) {
+  if (!iso) return void 0;
+  const value = Date.parse(iso);
+  return Number.isNaN(value) ? void 0 : value;
+}
+function durationNs(durationMs) {
+  return typeof durationMs === "number" && Number.isFinite(durationMs) && durationMs > 0 ? msToNs(durationMs) : 0n;
+}
+function classify(event) {
+  if (event.type === "ai_call" || event.type === "summarization") {
+    if (event.skipReason === "cancelled") return "chat";
+    if (event.skipReason || event.status === "skipped") return "plain";
+    return "chat";
+  }
+  if (event.type === "tool_call") {
+    const source = event.debug?.shortCircuitSource;
+    if (event.skipReason || event.status === "skipped" || source === "cache" || source === "plugin") return "plain";
+    if (event.status === "pending") return "plain";
+    return "execute_tool";
+  }
+  if (event.type === "span" && event.actor?.role === "subagent") return "invoke_agent";
+  return "plain";
+}
+var knownModel = (model) => model && model !== "unknown-model" && model !== "unknown_model" ? model : void 0;
+function toolNameOf(event) {
+  if (event.actor?.name) return event.actor.name;
+  const label = event.label.replace(/\s#\d+$/, "");
+  const dash = label.indexOf(" - ");
+  return dash >= 0 ? label.slice(dash + 3) : void 0;
+}
+var stripSequence = (label) => label.replace(/\s#\d+$/, "");
+function cappedMessage(message) {
+  const text = message && message.length > 0 ? message : "Unknown error";
+  return text.length > MAX_STATUS_MESSAGE ? text.slice(0, MAX_STATUS_MESSAGE) : text;
+}
+function exceptionEvent(timeNs, error) {
+  return {
+    timeUnixNano: timeNs.toString(),
+    name: "exception",
+    attributes: compact([
+      str("exception.type", errorTypeOf(error)),
+      strAllowEmpty("exception.message", error.message ?? "Unknown error"),
+      str("exception.stacktrace", error.stack)
+    ])
+  };
+}
+function sessionToOtlp(file, options) {
+  const useCognipeer = options.semconv !== "gen_ai";
+  const useGenAi = options.semconv !== "cognipeer";
+  const traceId = file.traceId || generateTraceId();
+  const rootSpanId = file.rootSpanId || generateSpanId();
+  const parent = options.parent;
+  const traceState = parent?.traceState || void 0;
+  const traceFlags = (typeof parent?.flags === "number" ? parent.flags : 1) & 255;
+  const flags = traceFlags | FLAG_HAS_PARENT;
+  const rootFlags = parent?.remote ? flags | FLAG_REMOTE_PARENT : flags;
+  const agentName = file.agent?.name;
+  const everyEvent = file.events;
+  const exportedEvents = foldSupersededSpans(everyEvent).filter(
+    (event) => options.terminal || !(event.type === "span" && event.status === "pending")
+  );
+  const startMs = parseMs(file.startedAt);
+  const nodes = exportedEvents.map((event) => {
+    const endMs = parseMs(event.timestamp) ?? startMs ?? Date.now();
+    const endNs = msToNs(endMs);
+    let startNs = endNs - durationNs(event.durationMs);
+    if (startNs < 0n) startNs = 0n;
+    return {
+      event,
+      spanId: event.spanId || generateSpanId(),
+      parentId: event.parentSpanId || rootSpanId,
+      startNs,
+      endNs
+    };
+  });
+  const childrenOf = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const list = childrenOf.get(node.parentId);
+    if (list) list.push(node);
+    else childrenOf.set(node.parentId, [node]);
+  }
+  const settled = /* @__PURE__ */ new Set();
+  const inProgress = /* @__PURE__ */ new Set();
+  const widen = (node) => {
+    if (settled.has(node) || inProgress.has(node)) return;
+    inProgress.add(node);
+    for (const child of childrenOf.get(node.spanId) ?? []) {
+      if (child === node) continue;
+      widen(child);
+      if (child.startNs < node.startNs) node.startNs = child.startNs;
+      if (child.endNs > node.endNs) node.endNs = child.endNs;
+    }
+    inProgress.delete(node);
+    settled.add(node);
+  };
+  for (const node of nodes) widen(node);
+  const byId = /* @__PURE__ */ new Map();
+  for (const event of everyEvent) if (event.spanId) byId.set(event.spanId, event);
+  const agentOf = (event) => {
+    let cursor = event;
+    for (let hops = 0; cursor && hops < 64; hops++) {
+      if (cursor !== event && cursor.type === "span" && cursor.actor?.role === "subagent") return cursor.actor.name;
+      cursor = cursor.parentSpanId ? byId.get(cursor.parentSpanId) : void 0;
+    }
+    return agentName;
+  };
+  const spans = [];
+  const sessionErrors = (file.errors ?? []).filter((error) => error.eventId === "session");
+  if (options.terminal) {
+    const earliestChild = nodes.reduce(
+      (earliest, node) => earliest === void 0 || node.startNs < earliest ? node.startNs : earliest,
+      void 0
+    );
+    let rootStart = startMs !== void 0 ? msToNs(startMs) : earliestChild ?? msToNs(Date.now());
+    let rootEnd = msToNs(parseMs(file.endedAt) ?? (startMs !== void 0 ? startMs + (file.durationMs ?? 0) : Date.now()));
+    for (const node of childrenOf.get(rootSpanId) ?? []) {
+      if (node.startNs < rootStart) rootStart = node.startNs;
+      if (node.endNs > rootEnd) rootEnd = node.endNs;
+    }
+    if (rootEnd < rootStart) rootEnd = rootStart;
+    const rootName = useGenAi ? agentName ? `${OPERATION.invokeAgent} ${agentName}` : OPERATION.invokeAgent : `agent_session: ${agentName || "agent"}`;
+    const summary = file.summary;
+    const cumulativeEvents = summary?.eventCounts ? Object.values(summary.eventCounts).reduce((total, count) => total + (Number(count) || 0), 0) : file.events.length;
+    const attributes = [];
+    if (useCognipeer) {
+      attributes.push(
+        ...compact([
+          strAllowEmpty("cognipeer.session.status", options.cancelled ? "partial" : file.status),
+          dbl("cognipeer.session.duration_ms", file.durationMs),
+          int("cognipeer.session.total_input_tokens", summary?.totalInputTokens),
+          int("cognipeer.session.total_output_tokens", summary?.totalOutputTokens),
+          int("cognipeer.session.total_cached_input_tokens", summary?.totalCachedInputTokens),
+          int("cognipeer.session.total_bytes_in", summary?.totalBytesIn),
+          int("cognipeer.session.total_bytes_out", summary?.totalBytesOut),
+          int("cognipeer.session.event_count", cumulativeEvents)
+        ])
+      );
+      for (const [key, count] of Object.entries(summary?.eventCounts ?? {})) {
+        attributes.push({ key: `cognipeer.session.event_count.${key}`, value: { intValue: String(count) } });
+      }
+    }
+    if (useGenAi) {
+      attributes.push(
+        ...compact([
+          str(ATTR.operationName, OPERATION.invokeAgent),
+          str(ATTR.agentName, agentName),
+          str(ATTR.agentVersion, file.agent?.version),
+          str(ATTR.requestModel, knownModel(file.agent?.model)),
+          str(ATTR.conversationId, file.threadId)
+        ])
+      );
+    }
+    const root = {
+      traceId,
+      spanId: rootSpanId,
+      parentSpanId: parent?.spanId ?? "",
+      ...traceState ? { traceState } : {},
+      flags: rootFlags,
+      name: rootName,
+      kind: SPAN_KIND_INTERNAL,
+      startTimeUnixNano: rootStart.toString(),
+      endTimeUnixNano: rootEnd.toString(),
+      attributes,
+      status: { code: 0 }
+    };
+    if (sessionErrors.length > 0) {
+      root.status = {
+        code: 2,
+        message: cappedMessage(sessionErrors.map((error) => error.message).join("; "))
+      };
+      if (useGenAi) root.attributes.push({ key: ATTR.errorType, value: { stringValue: errorTypeOf({ type: sessionErrors[0].errorName, stack: sessionErrors[0].stack }) } });
+      root.events = sessionErrors.map((error) => {
+        const at = parseMs(error.timestamp);
+        return exceptionEvent(at !== void 0 ? msToNs(at) : rootEnd, {
+          message: error.message,
+          stack: error.stack,
+          type: error.errorName
+        });
+      });
+    }
+    spans.push(root);
+  }
+  for (const node of nodes) {
+    const event = node.event;
+    const kind = classify(event);
+    const failed = event.status === "error";
+    const cancelledChat = kind === "chat" && event.skipReason === "cancelled";
+    const attributes = [];
+    if (useCognipeer) {
+      attributes.push(
+        ...compact([
+          strAllowEmpty("cognipeer.event.type", event.type),
+          strAllowEmpty("cognipeer.event.label", event.label),
+          int("cognipeer.event.sequence", event.sequence),
+          strAllowEmpty("cognipeer.actor.scope", event.actor?.scope),
+          strAllowEmpty("cognipeer.actor.name", event.actor?.name),
+          strAllowEmpty("cognipeer.actor.role", event.actor?.role),
+          strAllowEmpty("cognipeer.model", event.model),
+          int("cognipeer.tokens.reasoning", event.reasoningTokens),
+          strAllowEmpty("cognipeer.finish_reason", event.finishReason),
+          strAllowEmpty("cognipeer.provider", event.provider),
+          strAllowEmpty("cognipeer.tool.details", event.toolDetails ? JSON.stringify(event.toolDetails) : void 0),
+          int("cognipeer.tokens.input", event.inputTokens),
+          int("cognipeer.tokens.output", event.outputTokens),
+          int("cognipeer.tokens.total", event.totalTokens),
+          int("cognipeer.tokens.cached_input", event.cachedInputTokens),
+          int("cognipeer.bytes.request", event.requestBytes),
+          int("cognipeer.bytes.response", event.responseBytes),
+          strAllowEmpty("cognipeer.tool.execution_id", event.toolExecutionId),
+          strAllowEmpty("cognipeer.retry_of", event.retryOf),
+          strAllowEmpty("cognipeer.event.id", event.id)
+        ])
+      );
+      const sectionsAttr = sectionsAttribute(event.data?.sections, event, options.content);
+      if (sectionsAttr) attributes.push(sectionsAttr);
+      attributes.push({ key: "cognipeer.event.status", value: { stringValue: event.status } });
+    }
+    let name = event.label || event.type;
+    let spanKind = SPAN_KIND_INTERNAL;
+    if (kind === "chat") spanKind = SPAN_KIND_CLIENT;
+    if (useGenAi) {
+      const conversation = str(ATTR.conversationId, file.threadId);
+      if (kind === "chat") {
+        const model = knownModel(event.model);
+        name = model ? `${OPERATION.chat} ${model}` : OPERATION.chat;
+        attributes.push(
+          ...compact([
+            str(ATTR.operationName, OPERATION.chat),
+            str(ATTR.providerName, genAiProviderName(event.provider)),
+            str(ATTR.requestModel, model),
+            str(ATTR.responseModel, event.responseModel),
+            str(ATTR.responseId, event.responseId),
+            bool(ATTR.requestStream, event.streaming),
+            str(ATTR.outputType, event.outputType)
+          ])
+        );
+        if (failed || cancelledChat) {
+          attributes.push(strArray(ATTR.finishReasons, ["error"]));
+        } else {
+          const reason = event.rawFinishReason ?? event.finishReason;
+          if (reason) attributes.push(strArray(ATTR.finishReasons, [reason]));
+        }
+        const usageAllowed = !failed && !cancelledChat && (event.type !== "summarization" || event.debug?.usageFromModel === true);
+        const usage = usageAllowed ? genAiUsageOf(event) : void 0;
+        if (usage) {
+          attributes.push(
+            ...compact([
+              int(ATTR.usageInput, usage.input),
+              int(ATTR.usageOutput, usage.output),
+              int(ATTR.usageCacheRead, usage.cacheRead),
+              int(ATTR.usageCacheWrite, usage.cacheWrite),
+              int(ATTR.usageReasoning, usage.reasoning)
+            ])
+          );
+        }
+        if (conversation) attributes.push(conversation);
+        attributes.push(...contentAttributes("chat", event, genAiProviderName(event.provider), options.content));
+      } else if (kind === "execute_tool") {
+        const tool = toolNameOf(event);
+        name = tool ? `${OPERATION.executeTool} ${tool}` : OPERATION.executeTool;
+        attributes.push(
+          ...compact([
+            str(ATTR.operationName, OPERATION.executeTool),
+            str(ATTR.toolName, tool),
+            str(ATTR.toolCallId, event.toolCallId),
+            str(ATTR.toolType, "function"),
+            str(ATTR.agentName, agentOf(event)),
+            conversation
+          ])
+        );
+        attributes.push(...contentAttributes("execute_tool", event, void 0, options.content));
+      } else if (kind === "invoke_agent") {
+        const child = event.actor?.name;
+        name = child ? `${OPERATION.invokeAgent} ${child}` : OPERATION.invokeAgent;
+        attributes.push(...compact([str(ATTR.operationName, OPERATION.invokeAgent), str(ATTR.agentName, child), conversation]));
+      } else {
+        name = stripSequence(name);
+      }
+    }
+    const span = {
+      traceId: event.traceId || traceId,
+      spanId: node.spanId,
+      parentSpanId: node.parentId,
+      ...traceState ? { traceState } : {},
+      flags,
+      name,
+      kind: spanKind,
+      startTimeUnixNano: node.startNs.toString(),
+      endTimeUnixNano: node.endNs.toString(),
+      attributes,
+      status: { code: 0 }
+    };
+    if (failed) {
+      const error = event.error ?? { message: "Unknown error" };
+      span.status = { code: 2, message: cappedMessage(error.message) };
+      if (useGenAi) attributes.push({ key: ATTR.errorType, value: { stringValue: errorTypeOf(error) } });
+      span.events = [exceptionEvent(node.endNs, error)];
+    }
+    spans.push(span);
+  }
+  return {
+    resourceSpans: [
+      {
+        resource: { attributes: resourceAttributesOf(file, options, useCognipeer) },
+        scopeSpans: [{ scope: { name: SCOPE_NAME, version: SDK_VERSION }, spans }]
+      }
+    ]
+  };
+}
+function resourceAttributesOf(file, options, useCognipeer) {
+  const custom = options.resourceAttributes ?? {};
+  const serviceName = options.serviceName || custom["service.name"] || file.agent?.name || "cognipeer-agent";
+  const attributes = compact([
+    str("service.name", serviceName),
+    str("service.version", file.agent?.version)
+  ]);
+  if (useCognipeer) {
+    attributes.push(
+      ...compact([
+        str("cognipeer.session.id", file.sessionId),
+        str("cognipeer.thread.id", file.threadId),
+        str("cognipeer.agent.model", file.agent?.model),
+        str("cognipeer.agent.provider", file.agent?.provider),
+        ...Object.entries(file.metadata ?? {}).map(([key, value]) => str(`cognipeer.metadata.${key}`, value))
+      ])
+    );
+  }
+  attributes.push(
+    ...compact([
+      str("telemetry.sdk.name", SCOPE_NAME),
+      str("telemetry.sdk.language", "nodejs"),
+      str("telemetry.sdk.version", SDK_VERSION)
+    ])
+  );
+  for (const [key, value] of Object.entries(custom)) {
+    if (key === "service.name") continue;
+    const index = attributes.findIndex((attr) => attr.key === key);
+    const entry = str(key, value);
+    if (!entry) continue;
+    if (index >= 0) attributes[index] = entry;
+    else attributes.push(entry);
+  }
+  return attributes;
+}
+function countSpans(request) {
+  let total = 0;
+  for (const rs of request.resourceSpans) for (const ss of rs.scopeSpans) total += ss.spans.length;
+  return total;
+}
+
+// src/utils/otlp/env.ts
+var warned = /* @__PURE__ */ new Set();
+function warnOnce(message) {
+  if (warned.has(message)) return;
+  warned.add(message);
+  if (typeof console !== "undefined" && typeof console.warn === "function") console.warn(message);
+}
+function pick(env, ...names) {
+  for (const name of names) {
+    const value = env[name];
+    if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  }
+  return void 0;
+}
+function decode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function parseKeyValueList(raw) {
+  const out = {};
+  if (!raw) return out;
+  for (const part of raw.split(",")) {
+    const index = part.indexOf("=");
+    if (index <= 0) continue;
+    const key = part.slice(0, index).trim();
+    if (!key) continue;
+    out[key] = decode(part.slice(index + 1).trim());
+  }
+  return out;
+}
+function tracesEndpointFrom(base) {
+  return `${base.replace(/\/+$/, "")}/v1/traces`;
+}
+function protocolFrom(raw, fallback) {
+  if (!raw) return fallback;
+  const value = raw.toLowerCase();
+  if (value === "http/protobuf" || value === "http/json") return value;
+  warnOnce(
+    value === "grpc" ? `[agent-sdk] OTLP/gRPC is not supported; exporting over ${fallback} instead.` : `[agent-sdk] OTLP protocol "${raw}" is not supported (use http/json or http/protobuf); falling back to ${fallback}.`
+  );
+  return fallback;
+}
+function resolveOtlpEnv(env, explicit) {
+  const explicitEndpoint = typeof explicit.endpoint === "string" ? explicit.endpoint.trim() : "";
+  const envDriven = explicitEndpoint.length === 0;
+  const resourceAttributes = parseKeyValueList(pick(env, "OTEL_RESOURCE_ATTRIBUTES"));
+  const serviceName = pick(env, "OTEL_SERVICE_NAME");
+  if (!envDriven) {
+    return {
+      envDriven,
+      endpoint: explicitEndpoint,
+      headers: { ...explicit.headers ?? {} },
+      protocol: explicit.protocol ?? "http/json",
+      compression: explicit.compression ?? "none",
+      timeoutMs: explicit.timeoutMs,
+      serviceName,
+      resourceAttributes,
+      disabled: false
+    };
+  }
+  const tracesEndpoint = pick(env, "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT");
+  const baseEndpoint = pick(env, "OTEL_EXPORTER_OTLP_ENDPOINT");
+  const endpoint = tracesEndpoint ?? (baseEndpoint ? tracesEndpointFrom(baseEndpoint) : void 0);
+  const envHeaders = {
+    ...parseKeyValueList(pick(env, "OTEL_EXPORTER_OTLP_HEADERS")),
+    ...parseKeyValueList(pick(env, "OTEL_EXPORTER_OTLP_TRACES_HEADERS"))
+  };
+  const timeoutRaw = pick(env, "OTEL_EXPORTER_OTLP_TRACES_TIMEOUT", "OTEL_EXPORTER_OTLP_TIMEOUT");
+  const timeout = timeoutRaw !== void 0 ? Number(timeoutRaw) : void 0;
+  const compressionRaw = pick(env, "OTEL_EXPORTER_OTLP_TRACES_COMPRESSION", "OTEL_EXPORTER_OTLP_COMPRESSION")?.toLowerCase();
+  return {
+    envDriven,
+    endpoint,
+    headers: { ...envHeaders, ...explicit.headers ?? {} },
+    protocol: explicit.protocol ?? protocolFrom(pick(env, "OTEL_EXPORTER_OTLP_TRACES_PROTOCOL", "OTEL_EXPORTER_OTLP_PROTOCOL"), "http/protobuf"),
+    compression: explicit.compression ?? (compressionRaw === "gzip" ? "gzip" : "none"),
+    timeoutMs: explicit.timeoutMs ?? (timeout !== void 0 && Number.isFinite(timeout) && timeout > 0 ? timeout : void 0),
+    serviceName,
+    resourceAttributes,
+    disabled: pick(env, "OTEL_SDK_DISABLED")?.toLowerCase() === "true" || pick(env, "OTEL_TRACES_EXPORTER")?.toLowerCase() === "none"
+  };
+}
+function currentEnv() {
+  return typeof process !== "undefined" && process.env ? process.env : {};
+}
+var WIRE_VARINT = 0;
+var WIRE_FIXED64 = 1;
+var WIRE_LEN = 2;
+var WIRE_FIXED32 = 5;
+var textEncoder = new TextEncoder();
+var Writer = class {
+  constructor() {
+    this.buf = new Uint8Array(128);
+    this.len = 0;
+    this.view = new DataView(this.buf.buffer);
+  }
+  ensure(extra) {
+    if (this.len + extra <= this.buf.length) return;
+    let size = this.buf.length * 2;
+    while (size < this.len + extra) size *= 2;
+    const next = new Uint8Array(size);
+    next.set(this.buf.subarray(0, this.len));
+    this.buf = next;
+    this.view = new DataView(next.buffer);
+  }
+  byte(value) {
+    this.ensure(1);
+    this.buf[this.len++] = value;
+  }
+  varint(value) {
+    if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+      let n2 = value;
+      while (n2 >= 128) {
+        this.byte(n2 % 128 | 128);
+        n2 = Math.floor(n2 / 128);
+      }
+      this.byte(n2);
+      return;
+    }
+    let n = BigInt.asUintN(64, BigInt(value));
+    while (n >= 128n) {
+      this.byte(Number(n & 127n) | 128);
+      n >>= 7n;
+    }
+    this.byte(Number(n));
+  }
+  tag(field, wire) {
+    this.varint(field * 8 + wire);
+  }
+  raw(bytes) {
+    this.ensure(bytes.length);
+    this.buf.set(bytes, this.len);
+    this.len += bytes.length;
+  }
+  fixed64(value) {
+    this.ensure(8);
+    this.view.setBigUint64(this.len, BigInt.asUintN(64, value), true);
+    this.len += 8;
+  }
+  fixed32(value) {
+    this.ensure(4);
+    this.view.setUint32(this.len, value >>> 0, true);
+    this.len += 4;
+  }
+  double(value) {
+    this.ensure(8);
+    this.view.setFloat64(this.len, value, true);
+    this.len += 8;
+  }
+  finish() {
+    return this.buf.slice(0, this.len);
+  }
+};
+function lenField(w, field, bytes) {
+  w.tag(field, WIRE_LEN);
+  w.varint(bytes.length);
+  w.raw(bytes);
+}
+function stringField(w, field, value) {
+  if (!value) return;
+  lenField(w, field, textEncoder.encode(value));
+}
+function hexBytes(hex, bytes) {
+  if (!hex) return void 0;
+  const out = new Uint8Array(bytes);
+  for (let i = 0; i < bytes; i++) {
+    const pair = hex.slice(i * 2, i * 2 + 2);
+    const value = /^[0-9a-fA-F]{2}$/.test(pair) ? parseInt(pair, 16) : 0;
+    out[i] = value;
+  }
+  return out;
+}
+function base64Bytes(value) {
+  return new Uint8Array(buffer.Buffer.from(value, "base64"));
+}
+function encodeAnyValue(value) {
+  const w = new Writer();
+  if (value.stringValue !== void 0) {
+    lenField(w, 1, textEncoder.encode(value.stringValue));
+  } else if (value.boolValue !== void 0) {
+    w.tag(2, WIRE_VARINT);
+    w.varint(value.boolValue ? 1 : 0);
+  } else if (value.intValue !== void 0) {
+    w.tag(3, WIRE_VARINT);
+    w.varint(BigInt(value.intValue));
+  } else if (value.doubleValue !== void 0) {
+    w.tag(4, WIRE_FIXED64);
+    w.double(value.doubleValue);
+  } else if (value.arrayValue !== void 0) {
+    const inner = new Writer();
+    for (const item of value.arrayValue.values) lenField(inner, 1, encodeAnyValue(item));
+    lenField(w, 5, inner.finish());
+  } else if (value.kvlistValue !== void 0) {
+    const inner = new Writer();
+    for (const kv of value.kvlistValue.values) lenField(inner, 1, encodeKeyValue(kv));
+    lenField(w, 6, inner.finish());
+  } else if (value.bytesValue !== void 0) {
+    lenField(w, 7, base64Bytes(value.bytesValue));
+  }
+  return w.finish();
+}
+function encodeKeyValue(kv) {
+  const w = new Writer();
+  stringField(w, 1, kv.key);
+  lenField(w, 2, encodeAnyValue(kv.value));
+  return w.finish();
+}
+function encodeSpanEvent(event) {
+  const w = new Writer();
+  w.tag(1, WIRE_FIXED64);
+  w.fixed64(BigInt(event.timeUnixNano));
+  stringField(w, 2, event.name);
+  for (const attr of event.attributes) lenField(w, 3, encodeKeyValue(attr));
+  return w.finish();
+}
+function encodeSpan(span) {
+  const w = new Writer();
+  const traceId = hexBytes(span.traceId, 16);
+  if (traceId) lenField(w, 1, traceId);
+  const spanId = hexBytes(span.spanId, 8);
+  if (spanId) lenField(w, 2, spanId);
+  stringField(w, 3, span.traceState);
+  const parent = hexBytes(span.parentSpanId, 8);
+  if (parent) lenField(w, 4, parent);
+  stringField(w, 5, span.name);
+  if (span.kind) {
+    w.tag(6, WIRE_VARINT);
+    w.varint(span.kind);
+  }
+  w.tag(7, WIRE_FIXED64);
+  w.fixed64(BigInt(span.startTimeUnixNano));
+  w.tag(8, WIRE_FIXED64);
+  w.fixed64(BigInt(span.endTimeUnixNano));
+  for (const attr of span.attributes) lenField(w, 9, encodeKeyValue(attr));
+  for (const event of span.events ?? []) lenField(w, 11, encodeSpanEvent(event));
+  const status = new Writer();
+  stringField(status, 2, span.status.message);
+  if (span.status.code) {
+    status.tag(3, WIRE_VARINT);
+    status.varint(span.status.code);
+  }
+  lenField(w, 15, status.finish());
+  if (span.flags) {
+    w.tag(16, WIRE_FIXED32);
+    w.fixed32(span.flags);
+  }
+  return w.finish();
+}
+function encodeExportTraceServiceRequest(request) {
+  const w = new Writer();
+  for (const rs of request.resourceSpans) {
+    const resourceSpans = new Writer();
+    const resource = new Writer();
+    for (const attr of rs.resource.attributes) lenField(resource, 1, encodeKeyValue(attr));
+    lenField(resourceSpans, 1, resource.finish());
+    for (const ss of rs.scopeSpans) {
+      const scopeSpans = new Writer();
+      const scope = new Writer();
+      stringField(scope, 1, ss.scope.name);
+      stringField(scope, 2, ss.scope.version);
+      lenField(scopeSpans, 1, scope.finish());
+      for (const span of ss.spans) lenField(scopeSpans, 2, encodeSpan(span));
+      lenField(resourceSpans, 2, scopeSpans.finish());
+    }
+    stringField(resourceSpans, 3, rs.schemaUrl);
+    lenField(w, 1, resourceSpans.finish());
+  }
+  return w.finish();
+}
+var Reader = class {
+  constructor(bytes) {
+    this.bytes = bytes;
+    this.pos = 0;
+  }
+  get done() {
+    return this.pos >= this.bytes.length;
+  }
+  varint() {
+    let result = 0n;
+    let shift = 0n;
+    for (; ; ) {
+      if (this.pos >= this.bytes.length) throw new Error("truncated varint");
+      const byte = this.bytes[this.pos++];
+      result |= BigInt(byte & 127) << shift;
+      if ((byte & 128) === 0) return result;
+      shift += 7n;
+      if (shift > 70n) throw new Error("varint too long");
+    }
+  }
+  slice(length) {
+    if (this.pos + length > this.bytes.length) throw new Error("truncated field");
+    const out = this.bytes.subarray(this.pos, this.pos + length);
+    this.pos += length;
+    return out;
+  }
+  skip(wire) {
+    if (wire === WIRE_VARINT) this.varint();
+    else if (wire === WIRE_FIXED64) this.slice(8);
+    else if (wire === WIRE_FIXED32) this.slice(4);
+    else if (wire === WIRE_LEN) this.slice(Number(this.varint()));
+    else throw new Error(`unsupported wire type ${wire}`);
+  }
+};
+function decodeExportTraceServiceResponse(bytes) {
+  const top = new Reader(bytes);
+  let result;
+  while (!top.done) {
+    const key = Number(top.varint());
+    const field = key >>> 3;
+    const wire = key & 7;
+    if (field === 1 && wire === WIRE_LEN) {
+      const inner = new Reader(top.slice(Number(top.varint())));
+      let rejected = 0n;
+      let message;
+      while (!inner.done) {
+        const innerKey = Number(inner.varint());
+        const innerField = innerKey >>> 3;
+        const innerWire = innerKey & 7;
+        if (innerField === 1 && innerWire === WIRE_VARINT) rejected = BigInt.asIntN(64, inner.varint());
+        else if (innerField === 2 && innerWire === WIRE_LEN) message = new TextDecoder().decode(inner.slice(Number(inner.varint())));
+        else inner.skip(innerWire);
+      }
+      result = { rejectedSpans: Number(rejected), ...message ? { message } : {} };
+    } else {
+      top.skip(wire);
+    }
+  }
+  return result;
+}
+
+// src/utils/otlp/exporter.ts
+var gzipAsync = util.promisify(zlib.gzip);
+var DEFAULT_TIMEOUT_MS = 1e4;
+var RETRY_DEFAULTS = {
+  maxAttempts: 3,
+  initialDelayMs: 250,
+  maxDelayMs: 4e3,
+  maxElapsedMs: 25e3
+};
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+function retryPolicy(retry) {
+  if (retry === false) return { ...RETRY_DEFAULTS, maxAttempts: 1 };
+  const merged = { ...RETRY_DEFAULTS, ...retry ?? {} };
+  return { ...merged, maxAttempts: Math.max(1, Math.floor(merged.maxAttempts)) };
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function retryAfterMs(response) {
+  let raw;
+  try {
+    raw = response?.headers?.get?.("retry-after");
+  } catch {
+    return void 0;
+  }
+  if (typeof raw !== "string" || raw.trim() === "") return void 0;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const date = Date.parse(raw);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+async function attemptOnce(fetchFn, url, init, timeoutMs, protocol) {
+  const controller = new AbortController();
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`timed out after ${timeoutMs} ms`));
+    }, timeoutMs);
+  });
+  try {
+    const pending = fetchFn(url, { ...init, signal: controller.signal });
+    Promise.resolve(pending).catch(() => void 0);
+    const response = await Promise.race([pending, timeout]);
+    const status = typeof response?.status === "number" ? response.status : response?.ok ? 200 : 0;
+    const ok = typeof response?.ok === "boolean" ? response.ok : status >= 200 && status < 300;
+    if (ok) {
+      const lateBody = timeout.catch(() => void 0);
+      const partialSuccess = await Promise.race([readPartialSuccess(response, protocol), lateBody]);
+      return { kind: "ok", status, ...partialSuccess ? { partialSuccess } : {} };
+    }
+    let body = "";
+    try {
+      if (typeof response?.text === "function") body = String(await response.text());
+    } catch {
+    }
+    const statusText = typeof response?.statusText === "string" && response.statusText ? ` ${response.statusText}` : "";
+    return {
+      kind: "http",
+      status,
+      message: `HTTP ${status}${statusText}${body ? ` - ${body.slice(0, 200)}` : ""}`,
+      retryable: RETRYABLE_STATUS.has(status),
+      retryAfter: retryAfterMs(response)
+    };
+  } catch (err) {
+    return { kind: "network", message: err instanceof Error ? err.message : String(err) };
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+async function readPartialSuccess(response, protocol) {
+  try {
+    if (protocol === "http/protobuf") {
+      if (typeof response?.arrayBuffer !== "function") return void 0;
+      const bytes = new Uint8Array(await response.arrayBuffer());
+      if (bytes.length === 0) return void 0;
+      const decoded = decodeExportTraceServiceResponse(bytes);
+      return decoded && (decoded.rejectedSpans > 0 || decoded.message) ? decoded : void 0;
+    }
+    if (typeof response?.text !== "function") return void 0;
+    const text = String(await response.text());
+    if (!text.trim()) return void 0;
+    const partial = JSON.parse(text)?.partialSuccess;
+    if (!partial || typeof partial !== "object") return void 0;
+    const rejectedSpans = Number(partial.rejectedSpans ?? 0);
+    const message = typeof partial.errorMessage === "string" && partial.errorMessage ? partial.errorMessage : void 0;
+    if (!(rejectedSpans > 0) && !message) return void 0;
+    return { rejectedSpans: Number.isFinite(rejectedSpans) ? rejectedSpans : 0, ...message ? { message } : {} };
+  } catch {
+    return void 0;
+  }
+}
+function createOtlpExporter(options = {}) {
+  const env = resolveOtlpEnv(currentEnv(), options);
+  if (!env.endpoint && !env.disabled) {
+    throw new Error(
+      "[agent-sdk] OTLP export needs an `endpoint` (or OTEL_EXPORTER_OTLP_ENDPOINT / OTEL_EXPORTER_OTLP_TRACES_ENDPOINT in the environment)."
+    );
+  }
+  const semconv = options.semconv ?? "both";
+  const protocol = env.protocol;
+  const compression = env.compression;
+  const timeoutMs = env.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const policy = retryPolicy(options.retry);
+  const serviceName = options.serviceName ?? env.serviceName;
+  const resourceAttributes = { ...env.resourceAttributes, ...options.resourceAttributes ?? {} };
+  const endpoint = env.endpoint ?? "";
+  const content = resolveContentOptions(options.content);
+  return {
+    name: options.name ?? "otlp",
+    endpoint,
+    semconv,
+    protocol,
+    wantsContent: content.enabled,
+    contentOptions: content,
+    async exportSession(file, run) {
+      try {
+        if (env.disabled) {
+          return { ok: true, skipped: true, reason: "disabled by the environment (OTEL_SDK_DISABLED / OTEL_TRACES_EXPORTER)", attempts: 0, spans: 0, bytes: 0 };
+        }
+        const convertOptions = {
+          semconv,
+          serviceName,
+          resourceAttributes,
+          terminal: run.terminal,
+          cancelled: run.cancelled,
+          parent: run.parent,
+          content
+        };
+        const request = sessionToOtlp(file, convertOptions);
+        const spans = countSpans(request);
+        if (spans === 0) return { ok: true, skipped: true, reason: "no spans to export", attempts: 0, spans: 0, bytes: 0 };
+        const fetchFn = options.fetch ?? (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0);
+        if (!fetchFn) return { ok: false, attempts: 0, spans, bytes: 0, error: "OTLP export requires fetch to be available in this runtime." };
+        let body = protocol === "http/protobuf" ? encodeExportTraceServiceRequest(request) : JSON.stringify(request);
+        const headers = {
+          "content-type": protocol === "http/protobuf" ? "application/x-protobuf" : "application/json"
+        };
+        if (compression === "gzip") {
+          body = await gzipAsync(typeof body === "string" ? buffer.Buffer.from(body, "utf8") : body);
+          headers["content-encoding"] = "gzip";
+        }
+        Object.assign(headers, env.headers);
+        const bytes = typeof body === "string" ? buffer.Buffer.byteLength(body, "utf8") : body.length;
+        const started = Date.now();
+        let attempts = 0;
+        let lastError = "export failed";
+        let lastStatus;
+        for (; ; ) {
+          attempts += 1;
+          const remaining = policy.maxElapsedMs - (Date.now() - started);
+          const outcome = await attemptOnce(
+            fetchFn,
+            env.endpoint,
+            { method: "POST", headers, body },
+            Math.max(1, Math.min(timeoutMs, remaining)),
+            protocol
+          );
+          if (outcome.kind === "ok") {
+            return { ok: true, attempts, status: outcome.status, spans, bytes, ...outcome.partialSuccess ? { partialSuccess: outcome.partialSuccess } : {} };
+          }
+          lastError = outcome.message;
+          lastStatus = outcome.kind === "http" ? outcome.status : void 0;
+          const retryable = outcome.kind === "network" || outcome.retryable;
+          if (!retryable || attempts >= policy.maxAttempts) break;
+          const ceiling = Math.min(policy.maxDelayMs, policy.initialDelayMs * 2 ** (attempts - 1));
+          const wait = outcome.kind === "http" && outcome.retryAfter !== void 0 ? Math.min(outcome.retryAfter, policy.maxDelayMs) : Math.random() * ceiling;
+          if (Date.now() - started + wait >= policy.maxElapsedMs) break;
+          await sleep(wait);
+        }
+        return { ok: false, attempts, ...lastStatus !== void 0 ? { status: lastStatus } : {}, spans, bytes, error: lastError };
+      } catch (err) {
+        return { ok: false, attempts: 0, spans: 0, bytes: 0, error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+  };
+}
+
+// src/utils/otlp/context.ts
+var TRACEPARENT = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(-.*)?$/;
+var ALL_ZERO_TRACE = /^0{32}$/;
+var ALL_ZERO_SPAN = /^0{16}$/;
+var MAX_TRACESTATE = 512;
+function parseTraceparent(header) {
+  if (typeof header !== "string") return void 0;
+  const match = TRACEPARENT.exec(header.trim());
+  if (!match) return void 0;
+  const [, version, traceId, spanId, flagsHex, rest] = match;
+  if (version === "ff") return void 0;
+  if (version === "00" && rest) return void 0;
+  if (ALL_ZERO_TRACE.test(traceId) || ALL_ZERO_SPAN.test(spanId)) return void 0;
+  const flags = parseInt(flagsHex, 16);
+  return { traceId, spanId, flags, sampled: (flags & 1) === 1 };
+}
+function formatTraceparent(parts) {
+  const flags = typeof parts.flags === "number" ? parts.flags & 255 : parts.sampled === false ? 0 : 1;
+  return `00-${parts.traceId}-${parts.spanId}-${flags.toString(16).padStart(2, "0")}`;
+}
+function traceparentOf(ctx) {
+  if (!ctx?.traceId || !ctx.traceSpanId) return void 0;
+  return formatTraceparent({ traceId: ctx.traceId, spanId: ctx.traceSpanId, flags: ctx.traceFlags ?? 1 });
+}
+function cleanTraceState(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > MAX_TRACESTATE || !/^[\x20-\x7e]+$/.test(trimmed)) return void 0;
+  return trimmed;
+}
+function resolveTraceParent(input) {
+  if (input === void 0 || input === null) return void 0;
+  const header = typeof input === "string" ? input : input?.traceparent;
+  const parsed = parseTraceparent(header);
+  if (!parsed) {
+    warnOnce("[agent-sdk] Ignoring an invalid W3C traceparent; the trace starts a new root.");
+    return void 0;
+  }
+  const traceState = typeof input === "object" ? cleanTraceState(input.tracestate) : void 0;
+  return {
+    traceId: parsed.traceId,
+    spanId: parsed.spanId,
+    flags: parsed.flags,
+    sampled: parsed.sampled,
+    remote: true,
+    ...traceState ? { traceState } : {}
+  };
+}
+function persistedParentOf(parent) {
+  if (!parent) return void 0;
+  return { spanId: parent.spanId, flags: parent.flags, ...parent.traceState ? { traceState: parent.traceState } : {} };
+}
+function readPersistedParent(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const raw = value;
+  if (typeof raw.spanId !== "string" || !/^[0-9a-f]{16}$/.test(raw.spanId) || ALL_ZERO_SPAN.test(raw.spanId)) return void 0;
+  const flags = Number(raw.flags);
+  if (!Number.isInteger(flags) || flags < 0 || flags > 255) return void 0;
+  const traceState = cleanTraceState(raw.traceState);
+  return { spanId: raw.spanId, flags, ...traceState ? { traceState } : {} };
+}
+function restoreParent(persisted, traceId) {
+  return {
+    traceId,
+    spanId: persisted.spanId,
+    flags: persisted.flags,
+    sampled: (persisted.flags & 1) === 1,
+    remote: true,
+    ...persisted.traceState ? { traceState: persisted.traceState } : {}
+  };
+}
+
+// src/utils/tracing.ts
 var DEFAULT_COGNIPEER_URL = "https://console.cognipeer.com/api/client/v1/tracing/sessions";
 function fileSink(path2) {
   return { type: "file", path: path2 };
@@ -1259,8 +2650,9 @@ function cognipeerSink(first, second) {
 function httpSink(url, headers) {
   return { type: "http", url, headers };
 }
-function otlpSink(endpoint, headers) {
-  return { type: "otlp", endpoint, headers };
+function otlpSink(first, headers, options) {
+  if (first !== null && typeof first === "object") return { type: "otlp", ...first };
+  return { type: "otlp", endpoint: first, headers, ...options ?? {} };
 }
 function resolveLogsBaseDir(customPath, ensureDirectory = true) {
   const root = process.cwd();
@@ -1333,23 +2725,23 @@ function extractMetadata(model, paths) {
   if (!model) return void 0;
   for (const path2 of paths) {
     const value = getNestedValue2(model, path2);
-    const str = coerceToString(value);
-    if (str) return str;
+    const str2 = coerceToString(value);
+    if (str2) return str2;
   }
   const maybeLc = model?._lc;
   if (maybeLc) {
     for (const path2 of paths) {
       const value = getNestedValue2(maybeLc, path2);
-      const str = coerceToString(value);
-      if (str) return str;
+      const str2 = coerceToString(value);
+      if (str2) return str2;
     }
   }
   const maybeClient = model?.client || model?.api || model?.service;
   if (maybeClient) {
     for (const path2 of paths) {
       const value = getNestedValue2(maybeClient, path2);
-      const str = coerceToString(value);
-      if (str) return str;
+      const str2 = coerceToString(value);
+      if (str2) return str2;
     }
   }
   const constructorName = model?.constructor?.name;
@@ -1380,8 +2772,8 @@ function inferModelFromMessages(messageList) {
     if (!message) continue;
     for (const path2 of messagePaths) {
       const value = getNestedValue2(message, path2);
-      const str = coerceToString(value);
-      if (str) return str;
+      const str2 = coerceToString(value);
+      if (str2) return str2;
     }
   }
   return void 0;
@@ -1399,8 +2791,8 @@ function inferProviderFromMessages(messageList) {
     if (!message) continue;
     for (const path2 of messagePaths) {
       const value = getNestedValue2(message, path2);
-      const str = coerceToString(value);
-      if (str) return str;
+      const str2 = coerceToString(value);
+      if (str2) return str2;
     }
   }
   return void 0;
@@ -1462,12 +2854,18 @@ function resolveSink(sink) {
       return headers ? { type: "http", url, headers } : { type: "http", url };
     }
     case "otlp": {
-      const endpoint = typeof candidate.endpoint === "string" ? candidate.endpoint.trim() : "";
-      if (!endpoint) {
+      const given = candidate.endpoint;
+      if (given !== void 0 && (typeof given !== "string" || given.trim().length === 0)) {
+        throw new Error("otlp sink requires a non-empty endpoint");
+      }
+      let exporter;
+      try {
+        exporter = createOtlpExporter({ ...candidate, endpoint: given?.trim() });
+      } catch {
         throw new Error("otlp sink requires a non-empty endpoint");
       }
       const headers = candidate.headers ? { ...candidate.headers } : void 0;
-      return headers ? { type: "otlp", endpoint, headers } : { type: "otlp", endpoint };
+      return headers ? { type: "otlp", endpoint: exporter.endpoint, headers, exporter } : { type: "otlp", endpoint: exporter.endpoint, exporter };
     }
     default: {
       if (typeof console !== "undefined" && typeof console.warn === "function") {
@@ -1477,6 +2875,17 @@ function resolveSink(sink) {
     }
   }
 }
+function withoutUserinfo(endpoint) {
+  try {
+    const url = new URL(endpoint);
+    if (!url.username && !url.password) return endpoint;
+    url.username = "";
+    url.password = "";
+    return url.toString();
+  } catch {
+    return endpoint;
+  }
+}
 function snapshotSink(runtime) {
   const sink = runtime.resolvedConfig.sink;
   switch (sink.type) {
@@ -1489,7 +2898,7 @@ function snapshotSink(runtime) {
     case "http":
       return { type: "http", url: sink.url };
     case "otlp":
-      return { type: "otlp", endpoint: sink.endpoint };
+      return { type: "otlp", endpoint: withoutUserinfo(sink.endpoint) };
     default:
       return { type: "custom" };
   }
@@ -1507,11 +2916,11 @@ var TRACE_HTTP_RETRYABLE_STATUS = /* @__PURE__ */ new Set([404, 408, 425, 429, 5
 var TRACE_HTTP_RETRY_BASE_MS = 250;
 var TRACE_HTTP_RETRY_MAX_MS = 4e3;
 var RetryableHttpError = class extends Error {
-  constructor(status, message, retryAfterMs) {
+  constructor(status, message, retryAfterMs2) {
     super(message);
     this.name = "RetryableHttpError";
     this.status = status;
-    this.retryAfterMs = retryAfterMs;
+    this.retryAfterMs = retryAfterMs2;
   }
 };
 function traceSleep(ms) {
@@ -1604,206 +3013,23 @@ async function postStreamingSessionEnd(baseUrl, headers, payload) {
   const url = `${baseUrl.replace(/\/$/, "")}/stream/${payload.sessionId}/end`;
   await postJsonReliable(url, headers, payload, { retry: true });
 }
-function isoToUnixNano(iso) {
-  const ms = new Date(iso).getTime();
-  return `${ms}000000`;
-}
-function toOtlpStatusCode(status) {
-  if (status === "error") return 2;
-  if (status === "success" || status === "completed") return 1;
-  return 0;
-}
-function toOtlpSpanKind(type) {
-  switch (type) {
-    case "ai_call":
-    case "summarization":
-      return 3;
-    // CLIENT — outgoing LLM request (the summarizer is one too)
-    case "tool_call":
-      return 1;
-    // INTERNAL
-    case "agent_iteration":
-      return 1;
-    // INTERNAL
-    default:
-      return 1;
-  }
-}
-function stringAttr(key, val) {
-  return val != null ? { key, value: { stringValue: val } } : null;
-}
-function intAttr(key, val) {
-  return val != null && !Number.isNaN(val) ? { key, value: { intValue: String(val) } } : null;
-}
-function doubleAttr(key, val) {
-  return val != null && !Number.isNaN(val) ? { key, value: { doubleValue: val } } : null;
-}
-function eventToOtlpSpan(event) {
-  const startNano = isoToUnixNano(event.timestamp);
-  const endNano = event.durationMs != null ? `${new Date(new Date(event.timestamp).getTime() + event.durationMs).getTime()}000000` : startNano;
-  const attrs = [
-    stringAttr("cognipeer.event.type", event.type),
-    stringAttr("cognipeer.event.label", event.label),
-    intAttr("cognipeer.event.sequence", event.sequence),
-    stringAttr("cognipeer.actor.scope", event.actor?.scope),
-    stringAttr("cognipeer.actor.name", event.actor?.name),
-    stringAttr("cognipeer.actor.role", event.actor?.role),
-    stringAttr("cognipeer.model", event.model),
-    intAttr("cognipeer.tokens.reasoning", event.reasoningTokens),
-    stringAttr("cognipeer.finish_reason", event.finishReason),
-    stringAttr("cognipeer.provider", event.provider),
-    stringAttr("cognipeer.tool.details", event.toolDetails ? JSON.stringify(event.toolDetails) : void 0),
-    intAttr("cognipeer.tokens.input", event.inputTokens),
-    intAttr("cognipeer.tokens.output", event.outputTokens),
-    intAttr("cognipeer.tokens.total", event.totalTokens),
-    intAttr("cognipeer.tokens.cached_input", event.cachedInputTokens),
-    intAttr("cognipeer.bytes.request", event.requestBytes),
-    intAttr("cognipeer.bytes.response", event.responseBytes),
-    stringAttr("cognipeer.tool.execution_id", event.toolExecutionId),
-    stringAttr("cognipeer.retry_of", event.retryOf),
-    stringAttr("cognipeer.event.id", event.id)
-  ].filter(Boolean);
-  if (event.data?.sections && event.data.sections.length > 0) {
-    try {
-      attrs.push({ key: "cognipeer.sections", value: { stringValue: JSON.stringify(event.data.sections) } });
-    } catch {
-    }
-  }
-  const span = {
-    traceId: event.traceId,
-    spanId: event.spanId,
-    parentSpanId: event.parentSpanId || "",
-    name: event.label || event.type,
-    kind: toOtlpSpanKind(event.type),
-    startTimeUnixNano: startNano,
-    endTimeUnixNano: endNano,
-    attributes: attrs,
-    status: {
-      code: toOtlpStatusCode(event.status),
-      ...event.status === "error" && event.error?.message ? { message: event.error.message } : {}
-    }
-  };
-  if (event.error) {
-    span.events = [{
-      timeUnixNano: startNano,
-      name: "exception",
-      attributes: [
-        { key: "exception.message", value: { stringValue: event.error.message } },
-        ...event.error.stack ? [{ key: "exception.stacktrace", value: { stringValue: event.error.stack } }] : []
-      ]
-    }];
-  }
-  return span;
-}
-function traceSessionToOtlp(session) {
-  const traceId = session.traceId || generateTraceId();
-  const rootSpanId = session.rootSpanId || generateSpanId();
-  const startNano = isoToUnixNano(session.startedAt);
-  const endNano = session.endedAt ? isoToUnixNano(session.endedAt) : startNano;
-  const resourceAttrs = [
-    { key: "service.name", value: { stringValue: session.agent?.name || "cognipeer-agent" } },
-    stringAttr("service.version", session.agent?.version),
-    stringAttr("cognipeer.session.id", session.sessionId),
-    stringAttr("cognipeer.thread.id", session.threadId),
-    stringAttr("cognipeer.agent.model", session.agent?.model),
-    stringAttr("cognipeer.agent.provider", session.agent?.provider),
-    ...Object.entries(session.metadata || {}).map(([key, value]) => stringAttr(`cognipeer.metadata.${key}`, value))
-  ].filter(Boolean);
-  const rootAttrs = [
-    stringAttr("cognipeer.session.status", session.status),
-    doubleAttr("cognipeer.session.duration_ms", session.durationMs),
-    intAttr("cognipeer.session.total_input_tokens", session.summary.totalInputTokens),
-    intAttr("cognipeer.session.total_output_tokens", session.summary.totalOutputTokens),
-    intAttr("cognipeer.session.total_cached_input_tokens", session.summary.totalCachedInputTokens),
-    intAttr("cognipeer.session.total_bytes_in", session.summary.totalBytesIn),
-    intAttr("cognipeer.session.total_bytes_out", session.summary.totalBytesOut),
-    intAttr("cognipeer.session.event_count", session.events.length)
-  ].filter(Boolean);
-  if (session.summary.eventCounts) {
-    for (const [key, count] of Object.entries(session.summary.eventCounts)) {
-      rootAttrs.push({ key: `cognipeer.session.event_count.${key}`, value: { intValue: String(count) } });
-    }
-  }
-  const rootSpan = {
-    traceId,
-    spanId: rootSpanId,
-    parentSpanId: "",
-    name: `agent_session: ${session.agent?.name || "agent"}`,
-    kind: 1,
-    // INTERNAL
-    startTimeUnixNano: startNano,
-    endTimeUnixNano: endNano,
-    attributes: rootAttrs,
-    status: {
-      code: toOtlpStatusCode(session.status),
-      ...session.status === "error" && session.errors.length > 0 ? { message: session.errors.map((e) => e.message).join("; ") } : {}
-    }
-  };
-  if (session.errors.length > 0) {
-    rootSpan.events = session.errors.map((err) => ({
-      timeUnixNano: err.timestamp ? isoToUnixNano(err.timestamp) : startNano,
-      name: "exception",
-      attributes: [
-        { key: "exception.message", value: { stringValue: err.message } },
-        ...err.stack ? [{ key: "exception.stacktrace", value: { stringValue: err.stack } }] : [],
-        ...err.type ? [{ key: "exception.type", value: { stringValue: err.type } }] : []
-      ]
-    }));
-  }
-  const childSpans = session.events.map((event) => {
-    const span = eventToOtlpSpan({
-      ...event,
-      traceId: event.traceId || traceId,
-      spanId: event.spanId || generateSpanId(),
-      parentSpanId: event.parentSpanId || rootSpanId
-    });
-    return span;
+function traceSessionToOtlp(session, options = {}) {
+  return sessionToOtlp(session, {
+    semconv: "both",
+    terminal: session.status !== "paused" && session.status !== "in_progress",
+    ...options,
+    content: resolveContentOptions(options.content)
   });
-  return {
-    resourceSpans: [{
-      resource: { attributes: resourceAttrs },
-      scopeSpans: [{
-        scope: {
-          name: "cognipeer-agent-sdk",
-          version: "1.0.0"
-        },
-        spans: [rootSpan, ...childSpans]
-      }]
-    }]
-  };
 }
-async function postOtlpTraces(endpoint, headers, payload) {
-  const fetchFn = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
-  if (!fetchFn) {
-    throw new Error("OTLP sink requires fetch to be available in this runtime.");
-  }
-  const finalHeaders = {
-    "content-type": "application/json",
-    ...headers || {}
+function traceErrorOf(err) {
+  const e = err;
+  const message = typeof e?.message === "string" && e.message ? e.message : String(err);
+  const type = err instanceof Error && typeof err.name === "string" && err.name ? err.name : void 0;
+  return {
+    message,
+    ...typeof e?.stack === "string" ? { stack: e.stack } : {},
+    ...type ? { type } : {}
   };
-  try {
-    const response = await fetchFn(endpoint, {
-      method: "POST",
-      headers: finalHeaders,
-      body: JSON.stringify(payload)
-    });
-    if (!response.ok) {
-      let responseText = "";
-      try {
-        responseText = await response.text();
-      } catch {
-      }
-      const statusLine = `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
-      const bodyPreview = responseText ? ` - ${responseText.slice(0, 200)}` : "";
-      throw new Error(`${statusLine}${bodyPreview}`);
-    }
-  } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    if (typeof console !== "undefined" && typeof console.error === "function") {
-      console.error("[Tracing] OTLP export failed:", errMsg);
-    }
-    throw err;
-  }
 }
 function createEmptySummary() {
   return {
@@ -1823,10 +3049,16 @@ function generateEventId(sequence) {
   return `evt_${String(sequence).padStart(4, "0")}_${nanoid.nanoid(4)}`;
 }
 function generateTraceId() {
-  return crypto__default.default.randomBytes(16).toString("hex");
+  for (; ; ) {
+    const id = crypto__default.default.randomBytes(16).toString("hex");
+    if (/[1-9a-f]/.test(id)) return id;
+  }
 }
 function generateSpanId() {
-  return crypto__default.default.randomBytes(8).toString("hex");
+  for (; ; ) {
+    const id = crypto__default.default.randomBytes(8).toString("hex");
+    if (/[1-9a-f]/.test(id)) return id;
+  }
 }
 function defaultEventLabel(type) {
   switch (type) {
@@ -2103,9 +3335,64 @@ function readTraceContinuation(value) {
     nextSequence,
     part,
     summary,
-    errors: Array.isArray(raw.errors) ? raw.errors : []
+    errors: Array.isArray(raw.errors) ? raw.errors : [],
+    ...(() => {
+      const parent = readPersistedParent(raw.parent);
+      return parent ? { parent } : {};
+    })(),
+    ...(() => {
+      const pendingSpans = readPendingSpans(raw.pendingSpans);
+      return pendingSpans.length > 0 ? { pendingSpans } : {};
+    })()
   };
 }
+var MAX_CARRIED_SPANS = 64;
+var isSubagentSpanRecord = (event) => event.type === "span" && event.actor?.role === "subagent";
+function carriedSpanOf(record) {
+  const identity2 = (record.data?.sections ?? []).filter(
+    (section) => section.kind === "metadata" && section.identity === true
+  );
+  return {
+    sessionId: record.sessionId,
+    traceId: record.traceId,
+    spanId: record.spanId,
+    parentSpanId: record.parentSpanId,
+    id: record.id,
+    type: record.type,
+    label: record.label,
+    sequence: record.sequence,
+    timestamp: record.timestamp,
+    actor: record.actor,
+    status: record.status,
+    durationMs: record.durationMs,
+    ...identity2.length > 0 ? { data: { sections: identity2 } } : {}
+  };
+}
+function readPendingSpans(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const item of value.slice(0, MAX_CARRIED_SPANS)) {
+    if (!item || typeof item !== "object") continue;
+    const raw = item;
+    if (typeof raw.spanId !== "string" || raw.spanId.length === 0) continue;
+    if (raw.status !== "pending" || !isSubagentSpanRecord(raw)) continue;
+    if (typeof raw.sequence !== "number" || !Number.isInteger(raw.sequence) || raw.sequence < 1) continue;
+    if (typeof raw.timestamp !== "string" || Number.isNaN(Date.parse(raw.timestamp))) continue;
+    if (typeof raw.label !== "string" || typeof raw.id !== "string" || typeof raw.sessionId !== "string") continue;
+    if (raw.parentSpanId !== void 0 && typeof raw.parentSpanId !== "string") continue;
+    if (raw.durationMs !== void 0 && (typeof raw.durationMs !== "number" || !Number.isFinite(raw.durationMs))) continue;
+    out.push(carriedSpanOf(raw));
+  }
+  return out;
+}
+function pendingSpansOf(session) {
+  const candidates = [
+    ...session.carriedSpans ?? [],
+    ...session.events.filter(isSubagentSpanRecord)
+  ];
+  if (candidates.length === 0) return [];
+  return foldSupersededSpans(candidates).filter((event) => event.status === "pending").slice(-MAX_CARRIED_SPANS).map(carriedSpanOf);
+}
 function traceContinuationOf(session) {
   return {
     v: 1,
@@ -2119,15 +3406,32 @@ function traceContinuationOf(session) {
     summary: JSON.parse(JSON.stringify(session.summary)),
     // Sink failures belong to the part that hit them; carrying them on would
     // mark every later part `partial`.
-    errors: session.errors.filter((error) => error.type !== "sink")
+    errors: session.errors.filter((error) => error.type !== "sink"),
+    // Where the root hangs, so the leg that ends the run exports it under the same remote parent.
+    ...session.parent ? { parent: persistedParentOf(session.parent) } : {},
+    ...(() => {
+      const pendingSpans = pendingSpansOf(session);
+      return pendingSpans.length > 0 ? { pendingSpans } : {};
+    })()
   };
 }
-function createTraceSession(opts, continuation) {
+function createTraceSession(opts, continuation, extras) {
   const cfg = withDefaults(opts.tracing);
   if (!cfg.enabled) return void 0;
+  let parent;
+  if (continuation) {
+    if (continuation.parent && continuation.traceId) parent = restoreParent(continuation.parent, continuation.traceId);
+  } else {
+    parent = resolveTraceParent(extras?.traceParent ?? opts.tracing?.parent);
+  }
+  const exporters = [...extras?.exporters ?? []];
+  const contentExporters = [
+    ...cfg.sink.type === "otlp" ? [cfg.sink.exporter] : [],
+    ...exporters
+  ].filter((exporter) => exporter.wantsContent);
   const providedSessionId = opts.tracing?.sessionId?.trim();
   const sessionId = continuation?.sessionId || providedSessionId || generateSessionId();
-  const traceId = continuation?.traceId || generateTraceId();
+  const traceId = continuation?.traceId || parent?.traceId || generateTraceId();
   const rootSpanId = continuation?.rootSpanId || generateSpanId();
   const runtime = {
     sessionId,
@@ -2146,7 +3450,20 @@ function createTraceSession(opts, continuation) {
     // again would reset a streaming receiver's copy.
     sessionStarted: Boolean(continuation),
     sequenceOffset: continuation ? continuation.nextSequence - 1 : 0,
-    part: continuation ? continuation.part + 1 : 1
+    part: continuation ? continuation.part + 1 : 1,
+    ...continuation?.pendingSpans?.length ? { carriedSpans: continuation.pendingSpans } : {},
+    ...exporters.length ? { exporters } : {},
+    exportReports: [],
+    ...parent ? { parent } : {},
+    ...contentExporters.length > 0 ? {
+      captureContent: true,
+      captureLimits: {
+        // Headroom over the export cap: a redact hook runs before the cap and must see a
+        // secret whole, even one that straddles the point where the export cuts.
+        maxStringChars: 4 * Math.max(...contentExporters.map((exporter) => exporter.contentOptions?.maxStringChars ?? 4096)),
+        maxMessages: Math.max(...contentExporters.map((exporter) => exporter.contentOptions?.maxMessages ?? 32))
+      }
+    } : {}
   };
   if (cfg.sink.type === "file") {
     const baseDir = cfg.sink.baseDir;
@@ -2213,7 +3530,7 @@ function recordTraceEvent(session, event) {
   const baseLabel = event.label?.trim().length ? event.label.trim() : defaultEventLabel(event.type);
   const eventLabel = `${baseLabel} #${sequence}`;
   const durationMs = event.durationMs !== void 0 ? Number(event.durationMs) : void 0;
-  if (!Number.isNaN(durationMs ?? NaN) && durationMs !== void 0) {
+  if (!Number.isNaN(durationMs ?? NaN) && durationMs !== void 0 && event.countDuration !== false && !isSubagentTraceScope(session)) {
     session.summary.totalDurationMs += durationMs;
   }
   const inputTokens = event.inputTokens !== void 0 ? Number(event.inputTokens) : void 0;
@@ -2262,10 +3579,20 @@ function recordTraceEvent(session, event) {
       }
     }
   }
+  if (!session.resolvedConfig.logData && event.sections?.length) {
+    const identity2 = event.sections.filter((section) => section.kind === "metadata" && section.identity === true);
+    if (identity2.length > 0) sections = ensureUniqueSections(id, identity2);
+  }
+  if (event.alwaysSections?.length) {
+    const identity2 = event.alwaysSections.map(
+      (section) => section.kind === "metadata" ? { ...section, identity: true } : section
+    );
+    sections = ensureUniqueSections(id, [...identity2, ...sections ?? []]);
+  }
   const resolvedModel = event.model ?? inferModelFromMessages(event.messageList);
   const resolvedProvider = event.provider ?? inferProviderFromMessages(event.messageList);
   const isAiCall = event.type === "ai_call";
-  const spanId = generateSpanId();
+  const spanId = event.spanId || generateSpanId();
   const parentSpanId = event.parentSpanId || session.currentIterationSpanId || session.rootSpanId;
   const record = {
     sessionId: session.sessionId,
@@ -2296,6 +3623,16 @@ function recordTraceEvent(session, event) {
     // different facts, and a zero would erase the difference.
     ...reasoningTokens !== void 0 && !Number.isNaN(reasoningTokens) ? { reasoningTokens } : {},
     ...event.finishReason ? { finishReason: event.finishReason } : {},
+    // Provider facts: absent when the provider did not say, never zero or empty.
+    ...event.responseId ? { responseId: event.responseId } : {},
+    ...event.responseModel ? { responseModel: event.responseModel } : {},
+    ...event.rawFinishReason ? { rawFinishReason: event.rawFinishReason } : {},
+    ...typeof event.cacheWriteTokens === "number" && event.cacheWriteTokens > 0 ? { cacheWriteTokens: event.cacheWriteTokens } : {},
+    ...event.usageBasis && (event.usageBasis.inputExcludesCache || event.usageBasis.outputExcludesReasoning) ? { usageBasis: { ...event.usageBasis } } : {},
+    ...event.streaming ? { streaming: true } : {},
+    ...event.outputType ? { outputType: event.outputType } : {},
+    ...event.toolCallId ? { toolCallId: event.toolCallId } : {},
+    ...event.skipReason ? { skipReason: event.skipReason } : {},
     requestBytes,
     responseBytes,
     model: resolvedModel,
@@ -2317,6 +3654,15 @@ function recordTraceEvent(session, event) {
       timestamp: timestampIso
     });
   }
+  if (session.captureContent && event.capture) {
+    try {
+      attachCapturedContent(
+        record,
+        buildCapturedContent(event.capture, session.captureLimits ?? { maxStringChars: 4096, maxMessages: 32 })
+      );
+    } catch {
+    }
+  }
   session.events.push(record);
   const sink = session.resolvedConfig.sink;
   if (sink.type === "custom" && typeof sink.onEvent === "function") {
@@ -2359,6 +3705,69 @@ var DEFERRED_TRACE_EVENTS_KEY = "__deferredTraceEvents";
 function isTraceSessionOpen(session) {
   return Boolean(session) && !session.closed;
 }
+var SUBAGENT_TRACE_SCOPE = Symbol("subagentTraceScope");
+function createSubagentTraceScope(parent, info) {
+  const scope = { ...info, iterations: info.iterations ?? 0 };
+  let currentIterationSpanId;
+  return new Proxy(parent, {
+    get(target, prop) {
+      if (prop === SUBAGENT_TRACE_SCOPE) return scope;
+      if (prop === "rootSpanId") return scope.agentSpanId;
+      if (prop === "currentIterationSpanId") return currentIterationSpanId;
+      return Reflect.get(target, prop);
+    },
+    set(target, prop, value) {
+      if (prop === "currentIterationSpanId") {
+        currentIterationSpanId = value;
+        return true;
+      }
+      return Reflect.set(target, prop, value);
+    }
+  });
+}
+function subagentTraceScopeOf(session) {
+  if (!session) return void 0;
+  return session[SUBAGENT_TRACE_SCOPE];
+}
+function canPauseForHuman(session) {
+  return subagentTraceScopeOf(session)?.hitl !== false;
+}
+function isSubagentTraceScope(session) {
+  return subagentTraceScopeOf(session) !== void 0;
+}
+function recordSubagentSpan(session, span) {
+  const sections = [];
+  if (session.resolvedConfig.logData) {
+    if (span.task !== void 0) sections.push({ kind: "message", label: "Task", role: "user", content: span.task });
+    if (span.result) sections.push({ kind: "message", label: "Result", role: "assistant", content: span.result });
+  }
+  recordTraceEvent(session, {
+    type: "span",
+    spanId: span.spanId,
+    parentSpanId: span.parentSpanId,
+    label: `Sub-agent ${span.name}`,
+    actor: { scope: "agent", name: span.name, role: "subagent" },
+    status: span.status,
+    durationMs: span.durationMs,
+    // The child's own calls and the delegating tool_call already hold this time.
+    countDuration: false,
+    ...span.error ? { error: { message: span.error } } : {},
+    // The Console reads which sub-agent ran from here, so it survives logData off.
+    alwaysSections: [{ kind: "metadata", label: "Sub-agent", data: sanitizeTracePayload(span.info) }],
+    sections
+  });
+}
+function foldSupersededSpans(events) {
+  const rank = (event, index) => typeof event.sequence === "number" && Number.isFinite(event.sequence) ? event.sequence : index;
+  const winner = /* @__PURE__ */ new Map();
+  for (let i = 0; i < events.length; i++) {
+    const id = events[i].spanId;
+    if (!id) continue;
+    const current = winner.get(id);
+    if (current === void 0 || rank(events[i], i) >= rank(events[current], current)) winner.set(id, i);
+  }
+  return events.filter((event, i) => !(event.spanId && event.status === "pending" && winner.get(event.spanId) !== i));
+}
 function recordOrDeferTraceEvent(ctx, event, options) {
   const session = ctx?.__traceSession;
   if (isTraceSessionOpen(session)) {
@@ -2369,7 +3778,8 @@ function recordOrDeferTraceEvent(ctx, event, options) {
   const held = Array.isArray(ctx?.[DEFERRED_TRACE_EVENTS_KEY]) ? ctx[DEFERRED_TRACE_EVENTS_KEY] : [];
   return {
     ...ctx || {},
-    [DEFERRED_TRACE_EVENTS_KEY]: [...held, { ...event, timestamp: event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() }]
+    // `capture` (content for exporters) is never parked on ctx, which callers persist.
+    [DEFERRED_TRACE_EVENTS_KEY]: [...held, { ...event, capture: void 0, timestamp: event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() }]
   };
 }
 function replayDeferredTraceEvents(session, deferred) {
@@ -2403,6 +3813,7 @@ async function finalizeTraceSession(session, params = {}) {
       message: params.error.message || "Unknown error",
       stack: params.error.stack,
       type: "session",
+      ...params.error.name ? { errorName: params.error.name } : {},
       timestamp: endedAtIso
     });
   }
@@ -2426,24 +3837,62 @@ async function finalizeTraceSession(session, params = {}) {
     ...(session.part ?? 1) > 1 ? { continuation: { part: session.part, firstSequence: (session.sequenceOffset ?? 0) + 1 } } : {}
   });
   const payloadForSink = buildPayload(initialStatus);
+  const carried = session.carriedSpans ?? [];
+  const exportPayload = carried.length > 0 ? { ...payloadForSink, events: [...carried, ...payloadForSink.events] } : payloadForSink;
   let sinkFailed = false;
   const sink = session.resolvedConfig.sink;
   const isStreamingMode = session.resolvedConfig.mode === "streaming";
-  if (sink.type === "otlp") {
-    try {
-      const otlpPayload = traceSessionToOtlp(payloadForSink);
-      await postOtlpTraces(sink.endpoint, sink.headers, otlpPayload);
-    } catch (err) {
-      sinkFailed = true;
-      const message = err instanceof Error ? err.message : String(err);
-      session.errors.push({
-        eventId: "sink",
-        message,
-        type: "sink",
-        timestamp: endedAtIso
-      });
-    }
-  } else if (sink.type === "cognipeer" || sink.type === "http") {
+  const terminal = initialStatus !== "paused" && initialStatus !== "in_progress";
+  const exportTargets = [];
+  if (sink.type === "otlp") exportTargets.push({ exporter: sink.exporter, isSink: true });
+  if (!isSubagentTraceScope(session)) {
+    for (const exporter of session.exporters ?? []) exportTargets.push({ exporter, isSink: false });
+  }
+  const unsampled = session.parent !== void 0 && !session.parent.sampled;
+  if (exportTargets.length > 0) {
+    const results = await Promise.all(
+      exportTargets.map(async ({ exporter }) => {
+        if (unsampled) {
+          return { ok: true, skipped: true, reason: "the upstream traceparent is not sampled (sampled=0)", attempts: 0, spans: 0, bytes: 0 };
+        }
+        try {
+          return await exporter.exportSession(exportPayload, {
+            terminal,
+            cancelled: params.cancelled,
+            parent: session.parent
+          });
+        } catch (err) {
+          return { ok: false, attempts: 0, spans: 0, bytes: 0, error: err instanceof Error ? err.message : String(err) };
+        }
+      })
+    );
+    results.forEach((result, index) => {
+      const { exporter, isSink } = exportTargets[index];
+      (session.exportReports ?? (session.exportReports = [])).push({ exporter: exporter.name, endpoint: exporter.endpoint, sink: isSink, terminal, result });
+      if (result.ok) {
+        const rejected = result.partialSuccess?.rejectedSpans ?? 0;
+        if ((rejected > 0 || result.partialSuccess?.message) && typeof console !== "undefined" && typeof console.warn === "function") {
+          const detail = result.partialSuccess?.message ? `: ${result.partialSuccess.message}` : "";
+          console.warn(`[Tracing] OTLP exporter "${exporter.name}": the collector rejected ${rejected} span(s)${detail}`);
+        }
+        return;
+      }
+      const message = result.error ?? "OTLP export failed";
+      if (isSink) {
+        sinkFailed = true;
+        session.errors.push({ eventId: "sink", message, type: "sink", timestamp: endedAtIso });
+        if (typeof console !== "undefined" && typeof console.error === "function") {
+          console.error("[Tracing] OTLP export failed:", message);
+        }
+      } else if (typeof console !== "undefined" && typeof console.warn === "function") {
+        console.warn(`[Tracing] OTLP exporter "${exporter.name}" failed:`, message);
+      }
+    });
+  }
+  if (params.exportOnly) {
+    return buildPayload(payloadForSink.status);
+  }
+  if (sink.type === "cognipeer" || sink.type === "http") {
     try {
       const headers = sink.type === "cognipeer" ? { Authorization: `Bearer ${sink.apiKey}` } : sink.headers;
       if (isStreamingMode && session.sessionStarted) {
@@ -2539,6 +3988,23 @@ async function finalizeTraceSession(session, params = {}) {
   }
   return finalPayload;
 }
+async function closeTraceContinuation(continuation, params = {}) {
+  const parsed = readTraceContinuation(continuation);
+  if (!parsed) return void 0;
+  const tracing = { ...params.tracing ?? {}, enabled: true };
+  const hasOtlpSink = withDefaults(tracing).sink.type === "otlp";
+  if (!hasOtlpSink && !params.exporters?.length) return void 0;
+  const session = createTraceSession({ tracing }, parsed, { exporters: params.exporters });
+  if (!session) return void 0;
+  replayDeferredTraceEvents(session, params.events);
+  const status = params.status ?? "partial";
+  return finalizeTraceSession(session, {
+    agentRuntime: params.agentRuntime,
+    status,
+    error: status === "error" ? params.error ?? { message: "The run ended in an error before it could be resumed." } : null,
+    exportOnly: true
+  });
+}
 function sanitizeTracePayload(value) {
   if (value === void 0) return void 0;
   try {
@@ -2578,6 +4044,72 @@ function estimatePayloadBytes(value) {
     }
   }
 }
+
+// src/providers/wireInfo.ts
+var WIRE_INFO = Symbol.for("cognipeer.agent-sdk.wireInfo");
+function usageBasisOf(provider) {
+  switch (provider) {
+    case "anthropic":
+    case "bedrock":
+      return { inputExcludesCache: true };
+    case "vertex":
+      return { outputExcludesReasoning: true };
+    default:
+      return void 0;
+  }
+}
+function attachWireInfo(message, info) {
+  const clean = {};
+  if (info.provider) clean.provider = info.provider;
+  if (info.responseId) clean.responseId = info.responseId;
+  if (info.responseModel) clean.responseModel = info.responseModel;
+  if (info.rawFinishReason) clean.rawFinishReason = info.rawFinishReason;
+  if (info.streaming) clean.streaming = true;
+  const basis = info.usageBasis ?? usageBasisOf(info.provider);
+  if (basis) clean.usageBasis = basis;
+  message[WIRE_INFO] = clean;
+  return message;
+}
+function wireInfoOf(message) {
+  if (!message || typeof message !== "object") return void 0;
+  return message[WIRE_INFO];
+}
+
+// src/utils/traceFacts.ts
+var nonEmpty2 = (value) => typeof value === "string" && value.trim().length > 0 ? value : void 0;
+var isRunId = (id) => /^(run-|lc_run)/i.test(id);
+function providerHintOf(model, response) {
+  const named = getProviderName(model);
+  if (named) return named;
+  const fromWire = wireInfoOf(response)?.provider;
+  if (fromWire) return fromWire;
+  try {
+    return nonEmpty2(getModelCapabilities(model).provider);
+  } catch {
+    return void 0;
+  }
+}
+function traceResponseFacts(model, response, rawUsage, streaming) {
+  const wire = wireInfoOf(response);
+  const meta = response?.response_metadata ?? {};
+  const message = response;
+  const idCandidate = nonEmpty2(wire?.responseId) ?? nonEmpty2(meta.id) ?? nonEmpty2(message?.id);
+  const responseId = idCandidate && !isRunId(idCandidate) ? idCandidate : void 0;
+  const responseModel = nonEmpty2(wire?.responseModel) ?? nonEmpty2(meta.model_name) ?? nonEmpty2(meta.model) ?? nonEmpty2(meta.modelName);
+  const rawFinishReason = nonEmpty2(wire?.rawFinishReason) ?? nonEmpty2(meta.stop_reason) ?? nonEmpty2(meta.finish_reason) ?? nonEmpty2(meta.finishReason);
+  const cacheWriteTokens = cacheWriteTokensOf(rawUsage);
+  const provider = providerHintOf(model, response);
+  const isStreaming = streaming ?? wire?.streaming;
+  return {
+    ...provider ? { provider } : {},
+    ...responseId ? { responseId } : {},
+    ...responseModel ? { responseModel } : {},
+    ...rawFinishReason ? { rawFinishReason } : {},
+    ...cacheWriteTokens !== void 0 ? { cacheWriteTokens } : {},
+    ...wire?.usageBasis ? { usageBasis: { ...wire.usageBasis } } : {},
+    ...isStreaming ? { streaming: true } : {}
+  };
+}
 function toMessageUsage(u) {
   return {
     prompt_tokens: u.inputTokens,
@@ -2600,7 +4132,12 @@ function fromNativeProvider(provider, options) {
         if (link.signal) request.signal = link.signal;
         request = await applyTransform(request);
         const response = await provider.complete(request);
-        return toBaseChatMessage(response);
+        return attachWireInfo(toBaseChatMessage(response), {
+          provider: provider.providerName,
+          responseId: response.id,
+          responseModel: response.model,
+          rawFinishReason: response.rawFinishReason
+        });
       } finally {
         link.dispose();
       }
@@ -2619,6 +4156,8 @@ function fromNativeProvider(provider, options) {
         let reasoningText = "";
         let finishReason;
         let responseModel;
+        let responseId;
+        let rawFinishReason;
         const toolCallBuffers = /* @__PURE__ */ new Map();
         for await (const chunk of provider.completeStream(request)) {
           if (chunk.delta.content) {
@@ -2626,6 +4165,8 @@ function fromNativeProvider(provider, options) {
             yield chunk.delta.content;
           }
           if (chunk.model) responseModel = chunk.model;
+          if (chunk.id) responseId = chunk.id;
+          if (chunk.rawFinishReason) rawFinishReason = chunk.rawFinishReason;
           if (chunk.finishReason) finishReason = chunk.finishReason;
           if (chunk.delta.reasoning?.blocks?.length) {
             reasoningBlocks = chunk.delta.reasoning.blocks;
@@ -2647,7 +4188,8 @@ function fromNativeProvider(provider, options) {
                     id: tc.id,
                     name: tc.name ?? "",
                     arguments: tc.arguments ?? "",
-                    ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
+                    ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {},
+                    ...tc.idSynthesized ? { idSynthesized: true } : {}
                   });
                 }
               }
@@ -2671,7 +4213,13 @@ function fromNativeProvider(provider, options) {
             ...responseModel ? { model_name: responseModel } : {}
           };
         }
-        yield finalMessage;
+        yield attachWireInfo(finalMessage, {
+          provider: provider.providerName,
+          responseId,
+          responseModel,
+          rawFinishReason,
+          streaming: true
+        });
       } finally {
         link.dispose();
       }
@@ -3045,7 +4593,8 @@ function toBaseChatMessage(response) {
       id: tc.id,
       type: "function",
       function: { name: tc.name, arguments: tc.arguments },
-      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {},
+      ...tc.idSynthesized ? { idSynthesized: true } : {}
     }));
   }
   if (response.reasoning && (response.reasoning.blocks?.length || response.reasoning.summary)) {
@@ -3067,7 +4616,8 @@ function assembleMessage(content, toolCalls, usage) {
       id: tc.id,
       type: "function",
       function: { name: tc.name, arguments: tc.arguments },
-      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {}
+      ...tc.thoughtSignature ? { thoughtSignature: tc.thoughtSignature } : {},
+      ...tc.idSynthesized ? { idSynthesized: true } : {}
     }));
   }
   return msg;
@@ -3961,7 +5511,7 @@ var CCRStore = class _CCRStore {
   }
   static hashOf(value) {
     const serialized = typeof value === "string" ? value : JSON.stringify(value);
-    return crypto.createHash("sha1").update(serialized).digest("hex").slice(0, 16);
+    return crypto.createHash("sha256").update(serialized).digest("hex").slice(0, 16);
   }
 };
 var DedupTracker = class {
@@ -3974,7 +5524,7 @@ var DedupTracker = class {
    * first time it has been seen.
    */
   checkAndRegister(content, executionId, toolName) {
-    const hash = crypto.createHash("sha1").update(content).digest("hex");
+    const hash = crypto.createHash("sha256").update(content).digest("hex");
     const existing = this.seen.get(hash);
     if (!existing) {
       this.seen.set(hash, { executionId, toolName });
@@ -4511,7 +6061,7 @@ function createAgentCoreNode(opts) {
     const actorVersion = runtime.version ?? opts.version;
     let traceToolDefinitions;
     const computeTraceToolDefinitions = (menu) => {
-      if (!traceSession || !traceSession.resolvedConfig.logData || menu.length === 0) return void 0;
+      if (!traceSession || !(traceSession.resolvedConfig.logData || traceSession.captureContent) || menu.length === 0) return void 0;
       try {
         const wire = shouldUseStrictToolCalling ? prepareStrictToolMenu(menu).menu : menu;
         return wire.map((tool) => {
@@ -4724,8 +6274,9 @@ ${append}`;
           // outcome, and an "error" status would flip the whole trace session
           // status to error for a run that behaved exactly as configured.
           status: "skipped",
+          skipReason: "blocked",
           model: getModelName(runtime.model || opts.model),
-          provider: getProviderName(runtime.model || opts.model),
+          provider: providerHintOf(runtime.model || opts.model),
           messageList: state.messages
         });
         return {
@@ -4754,9 +6305,12 @@ ${append}`;
       for (const key of ["usage", "usage_metadata", "response_metadata"]) {
         if (merged[key] === void 0 && original?.[key] !== void 0) merged[key] = original[key];
       }
+      if (wireInfoOf(merged) === void 0 && wireInfoOf(original) !== void 0) merged[WIRE_INFO] = wireInfoOf(original);
       return merged;
     };
     let response;
+    let sentMessages;
+    let streamedCall = false;
     let modelAttempt = 0;
     const maxModelRetries = host?.maxModelRetries ?? 0;
     const finishCancelledTurn = (partialText) => {
@@ -4770,12 +6324,16 @@ ${append}`;
         // "skipped", not "error": the call did not fail, the caller ended it —
         // and an "error" would flip the whole session to error.
         status: "skipped",
+        // The call reached the provider and was hung up on: still a model call, not a skipped one.
+        skipReason: "cancelled",
+        ...streamedCall ? { streaming: true } : {},
         durationMs: Date.now() - start,
         requestBytes: promptBytes,
         model: getModelName(runtime.model || opts.model),
-        provider: getProviderName(runtime.model || opts.model),
+        provider: providerHintOf(runtime.model || opts.model),
         messageList: state.messages,
-        toolDefinitions: traceToolDefinitions
+        toolDefinitions: traceToolDefinitions,
+        capture: { input: sentMessages ?? wireMessages, toolDefinitions: traceToolDefinitions }
       });
       onEvent?.({ type: "cancelled", stage: "agent", reason });
       onProgress?.({ stage: "agent", message: "Cancelled", detail: { reason } });
@@ -4791,8 +6349,9 @@ ${append}`;
           label: "Assistant (plugin short-circuit)",
           actor: { scope: "agent", name: actorName, role: "assistant", version: actorVersion },
           status: "skipped",
+          skipReason: "short_circuit",
           model: getModelName(runtime.model || opts.model),
-          provider: getProviderName(runtime.model || opts.model),
+          provider: providerHintOf(runtime.model || opts.model),
           messageList: state.messages,
           toolDefinitions: traceToolDefinitions
         });
@@ -4800,8 +6359,10 @@ ${append}`;
         let streamedText = "";
         try {
           const normalizedMessages = normalizeBedrockToolPairing([...wireMessages]);
+          sentMessages = normalizedMessages;
           debugToolPairing(normalizedMessages);
           if (streamingEnabled && typeof modelWithTools.stream === "function") {
+            streamedCall = true;
             let streamedMessage;
             let cutByCancel = false;
             for await (const chunk of modelWithTools.stream(normalizedMessages, invokeParams)) {
@@ -4847,12 +6408,14 @@ ${append}`;
             durationMs: durationMs2,
             requestBytes: promptBytes,
             model: getModelName(runtime.model || opts.model),
-            provider: getProviderName(runtime.model || opts.model),
-            error: { message: err?.message || String(err), stack: err?.stack },
+            provider: providerHintOf(runtime.model || opts.model),
+            error: traceErrorOf(err),
+            ...streamedCall ? { streaming: true } : {},
             messageList: state.messages,
             toolDefinitions: traceToolDefinitions,
             responseFormat: traceResponseFormat,
-            responseFormatStrategy: traceResponseFormatStrategy
+            responseFormatStrategy: traceResponseFormatStrategy,
+            capture: { input: sentMessages ?? wireMessages, toolDefinitions: traceToolDefinitions }
           });
           throw err;
         }
@@ -4905,6 +6468,8 @@ ${append}`;
     const responsePayload = shouldLogResponse ? sanitizeTracePayload(response) : void 0;
     const responseBytes = responsePayload !== void 0 ? estimatePayloadBytes(responsePayload) : void 0;
     const finishReason = response?.response_metadata?.finish_reason ?? response?.response_metadata?.finishReason ?? response?.finishReason;
+    const facts = traceResponseFacts(runtime.model || opts.model, response, rawUsage, streamedCall);
+    const jsonOutput = Boolean(responseFormat) && responseFormat?.response_format?.type !== "text" && responseFormat?.type !== "text";
     recordTraceEvent(traceSession, {
       type: "ai_call",
       label: "Assistant Response",
@@ -4921,11 +6486,13 @@ ${append}`;
       requestBytes: promptBytes,
       responseBytes,
       model: modelName,
-      provider: getProviderName(runtime.model || opts.model),
+      ...facts,
+      outputType: jsonOutput ? "json" : "text",
       messageList: messagesWithResponse,
       toolDefinitions: traceToolDefinitions,
       responseFormat: traceResponseFormat,
-      responseFormatStrategy: traceResponseFormatStrategy
+      responseFormatStrategy: traceResponseFormatStrategy,
+      capture: { input: sentMessages ?? wireMessages, output: response, toolDefinitions: traceToolDefinitions }
     });
     if (normalized) {
       recordUsage(state, modelName, normalized);
@@ -4936,6 +6503,9 @@ ${append}`;
 
 // src/utils/traceDecisions.ts
 var TRACED_KEY = "__outcomeTraced";
+function surfacedFromSubagent(entry) {
+  return Boolean(entry.metadata?.__subagent);
+}
 function waitedMs(from, to) {
   if (!from || !to) return void 0;
   const ms = Date.parse(to) - Date.parse(from);
@@ -4948,8 +6518,14 @@ function sameJson(a, b) {
     return false;
   }
 }
+var idSection = (label, data) => ({
+  kind: "metadata",
+  label,
+  data,
+  identity: true
+});
 function recordApprovalRequested(session, entry) {
-  if (!session) return;
+  if (!session || surfacedFromSubagent(entry) || !canPauseForHuman(session)) return;
   const logData = session.resolvedConfig.logData;
   const sections = [
     {
@@ -4973,14 +6549,14 @@ function recordApprovalRequested(session, entry) {
     timestamp: entry.requestedAt,
     status: "pending",
     actor: { scope: "agent", name: entry.toolName, role: "approval_request" },
-    sections
+    sections: [...sections, idSection("Approval ids", { approvalId: entry.id, toolCallId: entry.toolCallId, status: "pending", requestedAt: entry.requestedAt })]
   });
 }
 function recordHumanDecisions(session, state) {
   if (!session) return;
   const logData = session.resolvedConfig.logData;
   for (const entry of state.pendingApprovals ?? []) {
-    if (!entry.decidedAt || entry.metadata?.[TRACED_KEY]) continue;
+    if (!entry.decidedAt || entry.metadata?.[TRACED_KEY] || surfacedFromSubagent(entry)) continue;
     if (entry.status !== "approved" && entry.status !== "rejected") continue;
     const approved = entry.status === "approved";
     const edited = approved && entry.approvedArgs !== void 0 && !sameJson(entry.approvedArgs, entry.args);
@@ -5014,12 +6590,19 @@ function recordHumanDecisions(session, state) {
       durationMs: waitedMs(entry.requestedAt, entry.decidedAt),
       status: "success",
       actor: { scope: "human", name: entry.decidedBy || "reviewer", role: "approver" },
-      sections
+      sections: [...sections, idSection("Decision ids", {
+        approvalId: entry.id,
+        toolCallId: entry.toolCallId,
+        decision: entry.status,
+        requestedAt: entry.requestedAt,
+        decidedAt: entry.decidedAt,
+        ...waitedMs(entry.requestedAt, entry.decidedAt) !== void 0 ? { waitedMs: waitedMs(entry.requestedAt, entry.decidedAt) } : {}
+      })]
     });
     entry.metadata = { ...entry.metadata || {}, [TRACED_KEY]: true };
   }
   for (const entry of state.pendingUserQuestions ?? []) {
-    if (!entry.answeredAt || entry.metadata?.[TRACED_KEY]) continue;
+    if (!entry.answeredAt || entry.metadata?.[TRACED_KEY] || surfacedFromSubagent(entry)) continue;
     if (entry.status !== "answered" && entry.status !== "cancelled") continue;
     const clientTool = readClientTool(entry);
     if (clientTool) {
@@ -5059,13 +6642,20 @@ function recordHumanDecisions(session, state) {
       durationMs: waitedMs(entry.requestedAt, entry.answeredAt),
       status: cancelled ? "skipped" : "success",
       actor: { scope: "human", name: entry.answeredBy || "user", role: "user" },
-      sections
+      sections: [...sections, idSection("Answer ids", {
+        questionId: entry.id,
+        toolCallId: entry.toolCallId,
+        status: entry.status,
+        requestedAt: entry.requestedAt,
+        answeredAt: entry.answeredAt,
+        ...waitedMs(entry.requestedAt, entry.answeredAt) !== void 0 ? { waitedMs: waitedMs(entry.requestedAt, entry.answeredAt) } : {}
+      })]
     });
     entry.metadata = { ...entry.metadata || {}, [TRACED_KEY]: true };
   }
 }
 function recordClientToolRequested(session, entry) {
-  if (!session) return;
+  if (!session || surfacedFromSubagent(entry) || !canPauseForHuman(session)) return;
   const clientTool = readClientTool(entry);
   if (!clientTool) return;
   const sections = [
@@ -5084,7 +6674,7 @@ function recordClientToolRequested(session, entry) {
     timestamp: entry.requestedAt,
     status: "pending",
     actor: { scope: "client", name: clientTool.name, role: "tool" },
-    sections
+    sections: [...sections, idSection("Client tool ids", { questionId: entry.id, toolCallId: entry.toolCallId, status: "pending", requestedAt: entry.requestedAt })]
   });
 }
 function readClientTool(entry) {
@@ -5131,7 +6721,14 @@ function recordClientToolResult(session, entry, clientTool, toolHistory) {
     durationMs: waitedMs(entry.requestedAt, entry.answeredAt) ?? ranMs,
     status: failed ? "error" : "success",
     actor: { scope: "client", name: clientTool.name, role: "tool" },
-    sections
+    sections: [...sections, idSection("Client tool ids", {
+      questionId: entry.id,
+      toolCallId: entry.toolCallId,
+      status: failed ? "error" : "answered",
+      requestedAt: entry.requestedAt,
+      answeredAt: entry.answeredAt,
+      ...waitedMs(entry.requestedAt, entry.answeredAt) !== void 0 ? { waitedMs: waitedMs(entry.requestedAt, entry.answeredAt) } : {}
+    })]
   });
 }
 
@@ -5237,9 +6834,11 @@ function normalizeToolCall(call) {
   return {
     id: call.id,
     name,
-    args: call.args ?? call.arguments ?? call.input ?? call.function?.arguments ?? call.function_call?.arguments
+    args: call.args ?? call.arguments ?? call.input ?? call.function?.arguments ?? call.function_call?.arguments,
+    ...call.idSynthesized === true ? { idSynthesized: true } : {}
   };
 }
+var providerToolCallId = (tc) => tc.id && !tc.idSynthesized ? tc.id : void 0;
 function normalizeToolSchema(tool, toolName) {
   const schema = tool.schema;
   if (!schema) return void 0;
@@ -5497,6 +7096,8 @@ function createToolsNode(initialTools, opts) {
           label: `Tool Denied - ${toolName}`,
           actor: { scope: "tool", name: toolName, role: "tool" },
           status: "skipped",
+          skipReason: "denied",
+          toolCallId: providerToolCallId(tc),
           toolDetails,
           toolExecutionId: toolCallId,
           sections: buildToolTraceSections({
@@ -5568,6 +7169,8 @@ function createToolsNode(initialTools, opts) {
             label: `Tool Skipped - ${toolName}`,
             actor: { scope: "tool", name: toolName, role: "tool" },
             status: "skipped",
+            skipReason: "skipped",
+            toolCallId: providerToolCallId(tc),
             toolDetails,
             toolExecutionId: tc.id,
             sections: buildToolTraceSections({
@@ -5704,10 +7307,13 @@ function createToolsNode(initialTools, opts) {
           label: `Tool Error - ${toolName}`,
           actor: { scope: "tool", name: toolName, role: "tool" },
           status: "error",
+          // The tool was not run: an open breaker refused the call.
+          skipReason: "skipped",
+          toolCallId: providerToolCallId(tc),
           requestBytes: inputBytes,
           toolDetails,
           toolExecutionId: toolCallId,
-          error: { message: breakerMsg },
+          error: { message: breakerMsg, type: "circuit_breaker_open" },
           sections: buildToolTraceSections({
             args,
             executionId: toolCallId,
@@ -5721,6 +7327,7 @@ function createToolsNode(initialTools, opts) {
         toolCount += 1;
         return { status: "error" };
       }
+      let traceSpanId;
       try {
         if (cachedHit !== void 0) {
           const executionId2 = nanoid.nanoid();
@@ -5766,6 +7373,9 @@ function createToolsNode(initialTools, opts) {
             type: "tool_call",
             label: shortCircuitSource === "plugin" ? `Tool Short-Circuited - ${toolName}` : `Tool Execution - ${toolName}`,
             actor: { scope: "tool", name: toolName, role: "tool" },
+            // Answered from the cache or by a plugin: nothing executed.
+            skipReason: "short_circuit",
+            toolCallId: providerToolCallId(tc),
             durationMs: 0,
             requestBytes: inputBytes,
             responseBytes: outputBytes2,
@@ -5800,7 +7410,16 @@ function createToolsNode(initialTools, opts) {
         onEvent?.({ type: "tool_call", phase: "start", name: toolName, id: tc.id, args });
         onProgress?.({ stage: "tools", message: `Running tool ${tc.name}` });
         const anyTool = tool;
-        const callOptions = { cancellationToken, signal: abortSignal, toolCallId };
+        traceSpanId = traceSession ? generateSpanId() : void 0;
+        const callOptions = {
+          cancellationToken,
+          signal: abortSignal,
+          toolCallId,
+          ...traceSpanId ? { traceSpanId } : {},
+          // So the tool can propagate the trace to what it calls (traceparentOf).
+          ...traceSpanId && traceSession?.traceId ? { traceId: traceSession.traceId } : {},
+          ...traceSpanId && traceSession?.parent ? { traceFlags: traceSession.parent.flags } : {}
+        };
         const invokeOnce = async () => {
           if (typeof anyTool.func === "function") return anyTool.func(args, callOptions);
           if (typeof anyTool.invoke === "function") return anyTool.invoke(args, callOptions);
@@ -5983,9 +7602,13 @@ function createToolsNode(initialTools, opts) {
         const outputBytes = traceSession?.resolvedConfig.logData ? estimatePayloadBytes(sanitizedOutput) : void 0;
         recordTraceEvent(traceSession, {
           type: "tool_call",
+          spanId: traceSpanId,
           label: `Tool Execution - ${toolName}`,
           actor: { scope: "tool", name: toolName, role: "tool" },
-          ...reportedFailure ? { status: "error", error: { message: reportedFailure } } : {},
+          ...reportedFailure ? { status: "error", error: { message: reportedFailure, type: "tool_error" } } : {},
+          toolCallId: providerToolCallId(tc),
+          // `output` is already past postToolUse, so a redaction plugin has applied.
+          capture: reportedFailure ? { toolArguments: args } : { toolArguments: args, toolResult: output, hasToolResult: true },
           durationMs,
           requestBytes: inputBytes,
           responseBytes: outputBytes,
@@ -6045,15 +7668,18 @@ function createToolsNode(initialTools, opts) {
         const errorOutput = { message, stack: host?.has("postToolUse") ? void 0 : error?.stack };
         recordTraceEvent(traceSession, {
           type: "tool_call",
+          spanId: traceSpanId,
           label: `Tool Error - ${toolName}`,
           actor: { scope: "tool", name: toolName, role: "tool" },
           status: "error",
+          toolCallId: providerToolCallId(tc),
+          capture: { toolArguments: args },
           durationMs,
           requestBytes: inputBytes,
           responseBytes: traceSession?.resolvedConfig.logData ? estimatePayloadBytes(errorOutput) : void 0,
           toolDetails,
           toolExecutionId: executionId,
-          error: { message, stack: host?.has("postToolUse") ? void 0 : error?.stack },
+          error: { ...traceErrorOf(error), message, stack: host?.has("postToolUse") ? void 0 : error?.stack },
           sections: buildToolTraceSections({
             args: sanitizedArgs,
             durationMs,
@@ -6168,6 +7794,8 @@ function createToolsNode(initialTools, opts) {
         label: `Tool Skipped - ${tc.name}`,
         actor: { scope: "tool", name: tc.name, role: "tool" },
         status: "skipped",
+        skipReason: "skipped",
+        toolCallId: providerToolCallId(tc),
         toolDetails,
         toolExecutionId: tc.id,
         sections: buildToolTraceSections({
@@ -6334,7 +7962,7 @@ function createReflectionNode(opts, resolved) {
         label: "Reflection error",
         actor: { scope: "agent", name: opts.name || "agent", role: "reflection" },
         status: "error",
-        error: { message: err?.message || String(err) }
+        error: traceErrorOf(err)
       });
       return {};
     }
@@ -7005,7 +8633,7 @@ function createAskUserQuestionTool(stateRef, config) {
         questions: entry.questions,
         allowFreeText
       });
-      recordTraceEvent(ctx.__traceSession, {
+      if (canPauseForHuman(ctx.__traceSession)) recordTraceEvent(ctx.__traceSession, {
         type: "user_question",
         label: "Question to user",
         timestamp: entry.requestedAt,
@@ -7345,7 +8973,7 @@ function buildSubagentCatalogBlock(subagents, policy, toolNames, opts) {
 // src/plugins/host.ts
 init_content();
 var DEFAULT_PRIORITY = 100;
-var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_TIMEOUT_MS2 = 1e4;
 var HOOK_SPECS = {
   sessionStart: { kind: "gate", mutable: ["messages"], collect: ["systemPromptAppend"] },
   userPromptSubmit: {
@@ -7450,7 +9078,7 @@ function collectRegistrations(plugin, registrations, into, orderRef) {
         plugin: plugin.name,
         priority: plugin.priority ?? DEFAULT_PRIORITY,
         failureMode: plugin.failureMode ?? "open",
-        timeoutMs: plugin.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        timeoutMs: plugin.timeoutMs ?? DEFAULT_TIMEOUT_MS2,
         order: orderRef.value++,
         handler
       });
@@ -7505,6 +9133,7 @@ function createPluginHost(plugins = [], options = {}) {
   let contributions = {
     tools: [],
     toolDescriptions: {},
+    traceExporters: [],
     guardrails: [],
     applySystemPrompt: (base) => base,
     applyModelWrappers: (model) => model
@@ -7513,6 +9142,7 @@ function createPluginHost(plugins = [], options = {}) {
   async function runSetup(setupInput) {
     const tools = [];
     const toolDescriptions = {};
+    const traceExporters = [];
     const guardrails = [];
     const promptSteps = [];
     const modelWrappers = [];
@@ -7550,6 +9180,7 @@ function createPluginHost(plugins = [], options = {}) {
         );
       }
       if (plugin.toolDescriptions) Object.assign(toolDescriptions, plugin.toolDescriptions);
+      if (plugin.traceExporters?.length) traceExporters.push(...plugin.traceExporters.filter(Boolean));
       if (plugin.guardrails?.length) guardrails.push(...plugin.guardrails);
       if (typeof plugin.wrapModel === "function") {
         modelWrappers.push({ plugin: plugin.name, wrap: plugin.wrapModel });
@@ -7565,6 +9196,7 @@ function createPluginHost(plugins = [], options = {}) {
     contributions = {
       tools,
       toolDescriptions,
+      traceExporters,
       guardrails,
       applySystemPrompt: (base) => promptSteps.reduce((current, step) => {
         try {
@@ -8288,19 +9920,22 @@ function createAgent(opts) {
             detail: { reason: budget.reason, iteration: iterations }
           });
         }
+        recordHumanDecisions(state.ctx?.__traceSession, state);
         const ctx = { ...state.ctx || {}, __limitBreached: budget.reason };
         state = { ...state, ctx };
         break;
       }
       const traceSession = state.ctx?.__traceSession;
       if (traceSession) {
-        const iterationNumber = (traceSession.summary.eventCounts.agent_iteration ?? 0) + 1;
+        const subagentScope = subagentTraceScopeOf(traceSession);
+        const iterationNumber = subagentScope ? ++subagentScope.iterations : (traceSession.summary.eventCounts.agent_iteration ?? 0) - (traceSession.summary.subagentIterations ?? 0) + 1;
         const iterEvent = recordTraceEvent(traceSession, {
           type: "agent_iteration",
           label: `Iteration ${iterationNumber}`,
           actor: { scope: "agent", name: opts.name || "agent", role: "orchestrator" },
           parentSpanId: traceSession.rootSpanId
         });
+        if (subagentScope) traceSession.summary.subagentIterations = (traceSession.summary.subagentIterations ?? 0) + 1;
         if (iterEvent) {
           traceSession.currentIterationSpanId = iterEvent.spanId;
         }
@@ -8585,7 +10220,10 @@ function createAgent(opts) {
       }
       emit({ type: "progress", ...progress });
     };
-    const traceSession = createTraceSession(opts, readTraceContinuation(input.ctx?.__traceContinuation));
+    const traceSession = createTraceSession(opts, readTraceContinuation(input.ctx?.__traceContinuation), {
+      exporters: pluginHost.contributions.traceExporters,
+      traceParent: config?.traceParent
+    });
     const ctx = {
       ...input.ctx || {},
       __onEvent: onEvent,
@@ -8610,7 +10248,9 @@ function createAgent(opts) {
     const inheritedSession = config?.__pluginSession;
     ctx.__runId = inheritedSession?.runId ?? traceSession?.sessionId ?? `run_${nanoid.nanoid(10)}`;
     const stateHolder = inheritedSession?.stateHolder ?? { value: void 0 };
-    const traceRecorder = createPluginTraceRecorder(() => traceSession);
+    const traceRecorder = createPluginTraceRecorder(
+      () => traceSession ?? (subagentTraceScopeOf(ctx.__traceSession) ? ctx.__traceSession : void 0)
+    );
     const runHost = inheritedSession?.host ?? (pluginHost.hasAny() ? pluginHost.beginRun({
       runId: ctx.__runId,
       agentName: opts.name,
@@ -8735,7 +10375,7 @@ function createAgent(opts) {
       await finalizeTraceSession(traceSession, {
         agentRuntime: runtime,
         status: "error",
-        error: { message: err?.message, stack: err?.stack }
+        error: { message: err?.message, stack: err?.stack, name: err?.name }
       });
       await endSession("error", { error: err instanceof Error ? err : new Error(String(err)), state: stateHolder.value });
       if (userTokenCounter) {
@@ -8756,7 +10396,10 @@ function createAgent(opts) {
     const midTurn = pausedForHuman || Boolean(res.ctx?.__needsSummarization);
     await finalizeTraceSession(traceSession, {
       agentRuntime: res.agent || runtime,
-      status: pausedForHuman ? "paused" : midTurn ? "in_progress" : "success"
+      status: pausedForHuman ? "paused" : midTurn ? "in_progress" : "success",
+      // The file says `success` for a cancelled run (it did not fail); the
+      // exported root says `partial`, the old plugin mapping.
+      cancelled: statusFor(res) === "cancelled"
     });
     if (traceSession && midTurn) {
       res.ctx = { ...res.ctx || {}, __traceContinuation: traceContinuationOf(traceSession) };
@@ -8853,7 +10496,7 @@ function createAgent(opts) {
         name: toolName,
         description: description || `Delegate task to agent ${opts.name || "Agent"}`,
         schema,
-        func: async ({ input }) => {
+        func: async ({ input }, context) => {
           const ref = delegatedTool._stateRef;
           const parentCtx = ref.ctx || {};
           const parentMessages = Array.isArray(ref.messages) ? ref.messages : [];
@@ -8886,6 +10529,33 @@ function createAgent(opts) {
             input
           );
           const childCtx = { __delegationDepth: currentDepth + 1 };
+          const parentSession = parentCtx.__traceSession;
+          const traced = isTraceSessionOpen(parentSession);
+          const agentSpanId = generateSpanId();
+          const parentIterationSpanId = traced ? parentSession.currentIterationSpanId : void 0;
+          if (traced && !withDefaults(opts.tracing).enabled) {
+            childCtx.__traceSession = createSubagentTraceScope(parentSession, {
+              agentSpanId,
+              name: opts.name || "agent",
+              mode: "asTool",
+              hitl: false
+            });
+          }
+          const startedAt = Date.now();
+          const recordSpan = (status, extra) => {
+            if (!traced || !isTraceSessionOpen(parentSession)) return;
+            recordSubagentSpan(parentSession, {
+              spanId: agentSpanId,
+              parentSpanId: context?.traceSpanId ?? parentIterationSpanId,
+              name: opts.name || "agent",
+              status,
+              durationMs: Date.now() - startedAt,
+              error: extra.error,
+              info: { name: opts.name || "agent", mode: "asTool", depth: currentDepth + 1, parentToolCallId: context?.toolCallId, status: status === "success" ? "ok" : "error" },
+              task: input,
+              result: extra.result
+            });
+          };
           const childConfig = {
             onEvent: parentCtx.__onEvent ? (e) => {
               if (e?.type === "finalAnswer" || e?.type === "metadata") return;
@@ -8901,7 +10571,14 @@ function createAgent(opts) {
             stream: Boolean(parentCtx.__streaming),
             cancellationToken: parentCtx.__cancellationToken ?? parentCtx.__abortSignal
           };
-          const res = await instance.invoke({ messages: childMessages, ctx: childCtx }, childConfig);
+          let res;
+          try {
+            res = await instance.invoke({ messages: childMessages, ctx: childCtx }, childConfig);
+          } catch (err) {
+            recordSpan("error", { error: err?.message || String(err) });
+            throw err;
+          }
+          recordSpan("success", { result: res.content });
           return {
             content: res.content,
             output: res.output,
@@ -8978,9 +10655,10 @@ function createAgentNode(opts) {
         durationMs: durationMs2,
         requestBytes: promptBytes,
         model: getModelName(runtime.model || opts.model),
-        provider: getProviderName(runtime.model || opts.model),
-        error: { message: err?.message || String(err), stack: err?.stack },
-        messageList: promptMessages
+        provider: providerHintOf(runtime.model || opts.model),
+        error: traceErrorOf(err),
+        messageList: promptMessages,
+        capture: { input: promptMessages }
       });
       throw err;
     }
@@ -8991,7 +10669,7 @@ function createAgentNode(opts) {
     const rawUsage = response?.usage || response?.usage_metadata || response?.response_metadata?.token_usage || response?.response_metadata?.tokenUsage || response?.response_metadata?.usage || response?.response_metadata?.usage_metadata || response?.response_metadata?.usageMetadata;
     const normalized = normalizeUsage(rawUsage);
     const modelName = getModelName(runtime.model || opts.model) || "unknown_model";
-    const providerName = getProviderName(runtime.model || opts.model);
+    const facts = traceResponseFacts(runtime.model || opts.model, response, rawUsage);
     const durationMs = Date.now() - start;
     const shouldLogResponse = !!traceSession && traceSession.resolvedConfig.logData;
     const responsePayload = shouldLogResponse ? sanitizeTracePayload(response) : void 0;
@@ -9008,8 +10686,9 @@ function createAgentNode(opts) {
       requestBytes: promptBytes,
       responseBytes,
       model: modelName,
-      provider: providerName,
-      messageList: messagesWithResponse
+      ...facts,
+      messageList: messagesWithResponse,
+      capture: { input: promptMessages, output: response }
     });
     if (normalized) {
       recordUsage(state, modelName, normalized);
@@ -9660,7 +11339,7 @@ ${canonicalFacts.length > 0 ? canonicalFacts.map((fact) => `- ${fact.key}: ${fac
     ];
     const inputTokensEstimate = countApproxTokens(summaryPrompt.map((m) => m.content).join("\n"));
     const modelName = getModelName(model);
-    const providerName = getProviderName(model);
+    const providerName = providerHintOf(model);
     const tracingEnabled = Boolean(opts.tracing?.enabled);
     let ctxWithDeferredTrace;
     const traceSummarization = (event) => {
@@ -9691,6 +11370,7 @@ ${canonicalFacts.length > 0 ? canonicalFacts.map((fact) => `- ${fact.key}: ${fac
     let reasoningTokensActual;
     let fallback = false;
     let summarizerError;
+    let responseFacts;
     const directivesSection = () => ({
       kind: "metadata",
       label: "User directives",
@@ -9732,6 +11412,7 @@ ${canonicalFacts.length > 0 ? canonicalFacts.map((fact) => `- ${fact.key}: ${fac
       summaryText = renderStructuredSummary(structuredSummary);
       const rawUsage = response?.usage || response?.response_metadata?.token_usage || response?.response_metadata?.tokenUsage || response?.response_metadata?.usage;
       const normalized = normalizeUsage(rawUsage);
+      responseFacts = traceResponseFacts(model, response, rawUsage);
       if (normalized) {
         inputTokensActual = normalized.prompt_tokens;
         outputTokensActual = normalized.completion_tokens;
@@ -9768,7 +11449,7 @@ ${canonicalFacts.length > 0 ? canonicalFacts.map((fact) => `- ${fact.key}: ${fac
         ...droppedDirectives.length > 0 ? { droppedDirectives } : {}
       };
       onEvent?.(errorEvent);
-      summarizerError = { message: err?.message || String(err), stack: err?.stack };
+      summarizerError = traceErrorOf(err);
     }
     const toolCallIdToAssistantIdx = /* @__PURE__ */ new Map();
     messages.forEach((m, idx) => {
@@ -9924,10 +11605,16 @@ ${canonicalFacts.length > 0 ? canonicalFacts.map((fact) => `- ${fact.key}: ${fac
         outputTokens: outputTokensActual ?? outputTokensEstimate,
         cachedInputTokens,
         totalTokens: totalTokensActual,
-        ...reasoningTokensActual !== void 0 ? { reasoningTokens: reasoningTokensActual } : {}
+        ...reasoningTokensActual !== void 0 ? { reasoningTokens: reasoningTokensActual } : {},
+        // Which counting rules the usage above follows (only when the provider reported it).
+        ...inputTokensActual !== void 0 && responseFacts?.usageBasis ? { usageBasis: responseFacts.usageBasis } : {},
+        ...inputTokensActual !== void 0 && responseFacts?.cacheWriteTokens ? { cacheWriteTokens: responseFacts.cacheWriteTokens } : {}
       },
+      ...responseFacts?.responseId ? { responseId: responseFacts.responseId } : {},
+      ...responseFacts?.responseModel ? { responseModel: responseFacts.responseModel } : {},
+      ...responseFacts?.rawFinishReason ? { rawFinishReason: responseFacts.rawFinishReason } : {},
       ...modelName ? { model: modelName } : {},
-      ...providerName ? { provider: providerName } : {},
+      ...responseFacts?.provider ?? providerName ? { provider: responseFacts?.provider ?? providerName } : {},
       ...summarizerError ? { error: summarizerError } : {},
       sections: [
         ...promptAndOutputSections(),
@@ -11064,11 +12751,52 @@ function mergeChildUsage(ref, childState, baseline, tag) {
 async function runChild(spec, input, deps, ref, opts) {
   const parentCtx = ref.ctx || {};
   const parentOnEvent = parentCtx.__onEvent;
-  const spawnId = `sa_${nanoid.nanoid(6)}`;
+  const spawnId = opts.record?.spawnId ?? `sa_${nanoid.nanoid(6)}`;
   const start = Date.now();
   const usageTag = { name: spec.name, id: spawnId, mode: spec.mode };
   const parentHost = parentCtx.__plugins;
   const childDepth = (Number(parentCtx.__delegationDepth) || 0) + 1;
+  const parentSession = parentCtx.__traceSession;
+  const traced = isTraceSessionOpen(parentSession);
+  const sessionStart = traced ? parentSession.startedAt : void 0;
+  const persistedId = opts.record?.agentSpanId;
+  const agentSpanId = typeof persistedId === "string" && /^[0-9a-f]{16}$/.test(persistedId) ? persistedId : generateSpanId();
+  const persistedStart = opts.record?.startedAt;
+  const startValid = typeof persistedStart === "number" && Number.isFinite(persistedStart) && persistedStart > 0 && persistedStart <= start;
+  const runStartedAt = startValid ? Math.min(start, Math.max(persistedStart, sessionStart ?? persistedStart)) : start;
+  const persistedSegments = opts.record?.segments;
+  const segment = (typeof persistedSegments === "number" && Number.isInteger(persistedSegments) && persistedSegments >= 1 && persistedSegments <= 1e3 ? persistedSegments : 0) + 1;
+  const elapsedMs = () => Math.max(0, Date.now() - runStartedAt);
+  const parentIterationSpanId = traced ? parentSession.currentIterationSpanId : void 0;
+  const traceScope = traced ? createSubagentTraceScope(parentSession, { agentSpanId, name: spec.name, spawnId, mode: spec.mode, hitl: opts.allowHITL, iterations: opts.record?.iterations }) : void 0;
+  const recordSegment = (status, info) => {
+    if (!traced || !isTraceSessionOpen(parentSession)) return;
+    recordSubagentSpan(parentSession, {
+      spanId: agentSpanId,
+      // The tool_call span only exists once the tool returns; a paused child
+      // has not returned, so its span hangs off the iteration.
+      parentSpanId: status === "pending" ? parentIterationSpanId : opts.parentSpanId ?? parentIterationSpanId,
+      name: spec.name,
+      status,
+      durationMs: elapsedMs(),
+      error: info.error,
+      info: {
+        id: spawnId,
+        name: spec.name,
+        mode: spec.mode,
+        parallel: opts.parallel,
+        depth: childDepth,
+        parentToolCallId: opts.parentToolCallId,
+        status: info.subagentStatus,
+        // Only a run that paused has more than one segment to tell about.
+        ...segment > 1 || status === "pending" ? { segments: segment } : {},
+        ...info.note ? { note: info.note } : {},
+        ...spec.metadata ? { metadata: spec.metadata } : {}
+      },
+      task: info.input,
+      result: info.content
+    });
+  };
   const emitStart = (task) => {
     parentOnEvent?.({ type: "subagent", phase: "start", name: spec.name, id: spawnId, mode: spec.mode, parallel: opts.parallel, parentToolCallId: opts.parentToolCallId, input: task });
   };
@@ -11076,6 +12804,15 @@ async function runChild(spec, input, deps, ref, opts) {
     result2.durationMs ?? (result2.durationMs = Date.now() - start);
     deps.registryRef.results.push(result2);
     const message = result2.error || result2.note || result2.status;
+    const traceStatus = result2.status === "ok" || result2.status === "incomplete" ? "success" : result2.status === "blocked" ? "skipped" : "error";
+    recordSegment(traceStatus, {
+      subagentStatus: result2.status,
+      input,
+      // `message` falls back to the status itself ("ok"): only a failed or refused run has an error to show.
+      error: traceStatus === "success" ? void 0 : message,
+      note: result2.note,
+      content: result2.content
+    });
     parentOnEvent?.({
       type: "subagent",
       phase: FAILED_STATUSES.has(result2.status) ? "error" : "result",
@@ -11174,6 +12911,7 @@ async function runChild(spec, input, deps, ref, opts) {
       ctx: { __delegationDepth: currentDepth + 1 }
     };
   }
+  if (traceScope) childInput = { ...childInput, ctx: { ...childInput.ctx || {}, __traceSession: traceScope } };
   const usageBaseline = childInput.usage?.perRequest?.length ?? 0;
   let res;
   try {
@@ -11214,8 +12952,14 @@ async function runChild(spec, input, deps, ref, opts) {
           input,
           childState: cleanChildState(childState),
           pendingKind: "approval",
-          pendingId: childEntry.id
+          pendingId: childEntry.id,
+          spawnId,
+          iterations: traceScope ? subagentTraceScopeOf(traceScope)?.iterations : void 0,
+          agentSpanId,
+          startedAt: runStartedAt,
+          segments: segment
         };
+        recordSegment("pending", { subagentStatus: "paused", input });
         parentOnEvent?.({ type: "subagent", phase: "paused", name: spec.name, id: spawnId, mode: spec.mode, parentToolCallId: opts.parentToolCallId });
         return { kind: "approval", toolCallId: surfaced.toolCallId, approvalId: surfaced.id };
       }
@@ -11237,8 +12981,14 @@ async function runChild(spec, input, deps, ref, opts) {
           input,
           childState: cleanChildState(childState),
           pendingKind: "user_question",
-          pendingId: childEntry.id
+          pendingId: childEntry.id,
+          spawnId,
+          iterations: traceScope ? subagentTraceScopeOf(traceScope)?.iterations : void 0,
+          agentSpanId,
+          startedAt: runStartedAt,
+          segments: segment
         };
+        recordSegment("pending", { subagentStatus: "paused", input });
         parentOnEvent?.({ type: "subagent", phase: "paused", name: spec.name, id: spawnId, mode: spec.mode, parentToolCallId: opts.parentToolCallId });
         return { kind: "user_question", toolCallId: surfaced.toolCallId, id: surfaced.id };
       }
@@ -11342,7 +13092,7 @@ function createDelegateTool(deps) {
         if (!budget.ok) return refusal(budget.reason);
         d.registryRef.spawnedCount += 1;
       }
-      return toToolReturn(await runChild(spec, record?.input ?? input, d, ref, { allowHITL: true, parentToolCallId, isResume: !!record, record, reserved: !record }));
+      return toToolReturn(await runChild(spec, record?.input ?? input, d, ref, { allowHITL: true, parentToolCallId, isResume: !!record, record, reserved: !record, parentSpanId: context?.traceSpanId }));
     }
   });
   tool._deps = deps;
@@ -11387,7 +13137,7 @@ function createSpawnTool(deps) {
         if (!budget.ok) return refusal(budget.reason);
         d.registryRef.spawnedCount += 1;
       }
-      return toToolReturn(await runChild(spec, record?.input ?? args.input, d, ref, { allowHITL: true, parentToolCallId, isResume: !!record, record, reserved: !record }));
+      return toToolReturn(await runChild(spec, record?.input ?? args.input, d, ref, { allowHITL: true, parentToolCallId, isResume: !!record, record, reserved: !record, parentSpanId: context?.traceSpanId }));
     }
   });
   tool._deps = deps;
@@ -11470,7 +13220,8 @@ function createParallelTool(deps) {
             allowHITL: false,
             parentToolCallId: `${parentToolCallId}#${i}`,
             parallel: true,
-            reserved: true
+            reserved: true,
+            parentSpanId: context?.traceSpanId
           });
           results[i] = outcome.kind === "result" ? outcome.result : { name: entry.spec.name, mode: entry.spec.mode, status: "error", input: entry.input, error: "Unexpected pause in parallel child." };
         }
@@ -11922,6 +13673,30 @@ ${pluginAppend}`;
           };
         }
       }
+      const traceHandoff = {};
+      const noteTraceHandoff = (current) => {
+        traceHandoff.continuation = current.ctx?.__traceContinuation;
+        traceHandoff.events = current.ctx?.[DEFERRED_TRACE_EVENTS_KEY];
+      };
+      const closeDanglingTrace = async (status, error) => {
+        const continuation = traceHandoff.continuation;
+        const events = traceHandoff.events;
+        traceHandoff.continuation = void 0;
+        traceHandoff.events = void 0;
+        if (!continuation) return;
+        try {
+          await closeTraceContinuation(continuation, {
+            tracing: opts.tracing,
+            exporters: pluginHost?.contributions.traceExporters,
+            status,
+            error,
+            agentRuntime: base.__runtime,
+            events
+          });
+        } catch (closeError) {
+          console.warn("[agent-sdk] closing the trace failed:", closeError);
+        }
+      };
       try {
         const toolSet = buildInvokeToolSet();
         const stateRef = toolSet.stateRef;
@@ -12000,11 +13775,15 @@ ${pluginAppend}`;
             const result = await trySummarize(state, rawMessages, stateRef);
             state = result.state;
             rawMessages = result.rawMessages;
+            noteTraceHandoff(state);
             if (result.compressed) continue;
           }
           const modelMessages = buildModelMessages(state, resolved);
+          traceHandoff.continuation = void 0;
+          traceHandoff.events = void 0;
           const res = await base.invoke({ ...state, messages: modelMessages }, turnConfig);
           lastResult = res;
+          noteTraceHandoff(res.state ?? state);
           const currentSummaries = state.summaries;
           const currentSummaryRecords = state.summaryRecords;
           const currentPlan = state.plan;
@@ -12031,6 +13810,7 @@ ${pluginAppend}`;
             const result = await trySummarize(state, rawMessages, stateRef);
             state = result.state;
             rawMessages = result.rawMessages;
+            noteTraceHandoff(state);
             continue;
           }
           if (state.ctx?.__finalizedDueToStructuredOutput) break;
@@ -12042,6 +13822,7 @@ ${pluginAppend}`;
               const result = await trySummarize(state, rawMessages, stateRef);
               state = result.state;
               rawMessages = result.rawMessages;
+              noteTraceHandoff(state);
               if (result.compressed) continue;
             }
           }
@@ -12052,6 +13833,7 @@ ${pluginAppend}`;
           lastResult = res;
         }
         if (state.ctx?.[DEFERRED_TRACE_EVENTS_KEY]) {
+          traceHandoff.events = state.ctx[DEFERRED_TRACE_EVENTS_KEY];
           const ctx = { ...state.ctx || {} };
           delete ctx[DEFERRED_TRACE_EVENTS_KEY];
           state = { ...state, ctx };
@@ -12071,8 +13853,12 @@ ${pluginAppend}`;
             const strippedCtx = { ...endCtx };
             delete strippedCtx.__traceContinuation;
             lastResult = { ...lastResult, state: { ...lastResult.state, ctx: strippedCtx } };
+            traceHandoff.continuation = endCtx.__traceContinuation;
+            await closeDanglingTrace("success");
           }
         }
+        traceHandoff.continuation = void 0;
+        traceHandoff.events = void 0;
         if (skillsEnabled && lastResult.state) {
           const persisted = skillStateFromRegistry(toolSet.skillRegistryRef);
           if (persisted) {
@@ -12118,6 +13904,11 @@ ${pluginAppend}`;
         await endSession(endStatus, { result: lastResult });
         return lastResult;
       } catch (err) {
+        await closeDanglingTrace("error", {
+          message: err instanceof Error ? err.message : String(err),
+          stack: err instanceof Error ? err.stack : void 0,
+          name: err instanceof Error ? err.name : void 0
+        });
         await endSession("error", { error: err instanceof Error ? err : new Error(String(err)) });
         throw err;
       }
@@ -13034,7 +14825,7 @@ function isHookImplemented(hook) {
 // src/plugins/builtin/guardrail.ts
 init_content();
 var ALLOW = { action: "allow" };
-var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
+var RETRYABLE_STATUS2 = /* @__PURE__ */ new Set([408, 425, 429, 500, 502, 503, 504]);
 var RetryableGuardrailError = class extends Error {
   constructor(message) {
     super(message);
@@ -13132,7 +14923,7 @@ function httpGuardrail(options) {
       } catch {
       }
       const message = `HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}${text ? ` - ${text.slice(0, 200)}` : ""}`;
-      if (RETRYABLE_STATUS.has(response.status)) throw new RetryableGuardrailError(message);
+      if (RETRYABLE_STATUS2.has(response.status)) throw new RetryableGuardrailError(message);
       throw new Error(message);
     }
     return response.json();
@@ -13239,9 +15030,9 @@ function createGuardrailPlugin(options) {
       });
       const resolved = verdict ?? ALLOW;
       if (resolved.raw?.disabled === true) {
-        const warned = (_b = ctx.store).__disabledWarned ?? (_b.__disabledWarned = /* @__PURE__ */ new Set());
-        if (!warned.has(request.phase)) {
-          warned.add(request.phase);
+        const warned2 = (_b = ctx.store).__disabledWarned ?? (_b.__disabledWarned = /* @__PURE__ */ new Set());
+        if (!warned2.has(request.phase)) {
+          warned2.add(request.phase);
           ctx.logger.warn(
             `guardrail reports it is not active for the "${request.phase}" surface; nothing is being enforced there`
           );
@@ -13738,7 +15529,7 @@ function safeJson(value) {
 function matches(pattern, toolName) {
   return typeof pattern === "string" ? pattern === toolName : pattern.test(toolName);
 }
-function asObject(args) {
+function asObject2(args) {
   return args && typeof args === "object" ? args : {};
 }
 function toolPolicy(config = {}) {
@@ -13759,7 +15550,7 @@ function toolPolicy(config = {}) {
     hooks: {
       preToolUse: ({ toolName, args }, ctx) => {
         var _a;
-        const argObject = asObject(args);
+        const argObject = asObject2(args);
         const isControlPlane = CONTROL_PLANE_TOOL_NAMES.includes(toolName);
         const allowListApplies = !isControlPlane || config.governControlPlaneTools === true;
         if (config.allowOnly && allowListApplies && !config.allowOnly.some((pattern) => matches(pattern, toolName))) {
@@ -13821,7 +15612,7 @@ function pathSandbox(config) {
     hooks: {
       preToolUse: ({ toolName, args }) => {
         if (config.tools && !config.tools.some((pattern) => matches(pattern, toolName))) return void 0;
-        const argObject = asObject(args);
+        const argObject = asObject2(args);
         for (const key of argNames) {
           const value = argObject[key];
           if (typeof value !== "string" || value.length === 0) continue;
@@ -14589,7 +16380,7 @@ function mcp(config) {
 }
 
 // src/plugins/builtin/rateLimit.ts
-function sleep(ms, signal) {
+function sleep2(ms, signal) {
   return new Promise((resolve) => {
     let timer;
     const done = () => {
@@ -14646,7 +16437,7 @@ function rateLimit(config = {}) {
       while (!attempt.ok) {
         const remaining = deadline - Date.now();
         if (!Number.isFinite(attempt.waitMs) || attempt.waitMs > remaining) break;
-        await sleep(Math.max(1, attempt.waitMs), ctx.signal);
+        await sleep2(Math.max(1, attempt.waitMs), ctx.signal);
         if (ctx.signal?.aborted) break;
         attempt = consume(applicable);
       }
@@ -15742,18 +17533,21 @@ function langfuseTracing(config = {}) {
 }
 
 // src/plugins/builtin/otel.ts
-function toSessionStatus(status) {
-  if (status === "success") return "success";
-  if (status === "error") return "error";
-  return status === "paused" ? "in_progress" : "partial";
-}
-function otelTracing(config) {
-  const endpoint = config.endpoint?.trim();
-  if (!endpoint) {
+function otelTracing(config = {}) {
+  if (config.endpoint !== void 0 && !config.endpoint.trim()) {
     throw new Error("[agent-sdk] otelTracing requires a non-empty `endpoint`.");
   }
+  const name = config.name ?? "otel-tracing";
+  let exporter;
+  try {
+    exporter = createOtlpExporter({ ...config, endpoint: config.endpoint?.trim(), name });
+  } catch {
+    throw new Error(
+      "[agent-sdk] otelTracing requires a non-empty `endpoint` (or OTEL_EXPORTER_OTLP_ENDPOINT / OTEL_EXPORTER_OTLP_TRACES_ENDPOINT in the environment)."
+    );
+  }
   return {
-    name: config.name ?? "otel-tracing",
+    name,
     // Registers only the `sessionEnd` observer, and observers run concurrently,
     // so this number orders nothing at runtime. It is set above checkpointing
     // (900) to record intent: this plugin is the last thing interested in the
@@ -15761,67 +17555,41 @@ function otelTracing(config) {
     priority: 950,
     // Observability. A dropped export is a reporting gap, never a safety hole.
     failureMode: "open",
+    traceExporters: [exporter],
     hooks: {
-      sessionEnd: async ({ status, durationMs, error }, ctx) => {
+      sessionEnd: async (_event, ctx) => {
         const state = ctx.state;
         const session = state.ctx?.__traceSession;
+        if (isSubagentTraceScope(session)) return;
         if (!session) {
           const message = "otelTracing exported nothing: the agent has no trace session. Enable the SDK's tracing runtime with `tracing: { enabled: true }` \u2014 the plugin exports the session the runtime records, it does not record one itself.";
           ctx.logger.warn(message);
           ctx.emit({ type: "metadata", otelTracing: { exported: false, reason: message } });
           return;
         }
-        const endedAtMs = Date.now();
-        const startedAtIso = new Date(session.startedAt).toISOString();
-        const errors = error ? [...session.errors, { eventId: "session", message: error.message, stack: error.stack, type: "session" }] : session.errors;
-        const payload = {
-          sessionId: session.sessionId,
-          traceId: session.traceId,
-          rootSpanId: session.rootSpanId,
-          threadId: session.threadId,
-          startedAt: startedAtIso,
-          endedAt: new Date(endedAtMs).toISOString(),
-          durationMs: durationMs ?? endedAtMs - session.startedAt,
-          // `service.name` is read off `agent.name` inside the conversion, so
-          // the override is applied here rather than by editing spans after.
-          agent: {
-            ...session.agentInfo ?? {},
-            name: config.serviceName ?? session.agentInfo?.name ?? session.configAgentName ?? ctx.agentName
-          },
-          metadata: session.configMetadata,
-          // Carried only to satisfy the type: `traceSessionToOtlp` reads the
-          // events, summary and identifiers, never the sink snapshot.
-          config: { enabled: true, logData: session.resolvedConfig.logData, sink: { type: "otlp", endpoint } },
-          summary: session.summary,
-          events: session.events,
-          status: toSessionStatus(status),
-          errors
-        };
-        try {
-          const fetchFn = typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : void 0;
-          if (!fetchFn) {
-            ctx.logger.warn("otelTracing needs fetch to be available in this runtime; export skipped.");
-            return;
-          }
-          const response = await fetchFn(endpoint, {
-            method: "POST",
-            headers: { "content-type": "application/json", ...config.headers ?? {} },
-            body: JSON.stringify(traceSessionToOtlp(payload)),
-            // The run is over, but a host that cancelled it should not be made
-            // to wait on a collector that is refusing to answer.
-            signal: ctx.signal
-          });
-          if (!response.ok) {
-            ctx.logger.warn(`otelTracing export returned HTTP ${response.status}.`);
-            return;
-          }
-          ctx.emit({
-            type: "metadata",
-            otelTracing: { exported: true, endpoint, spans: session.events.length + 1 }
-          });
-        } catch (err) {
-          ctx.logger.warn("otelTracing export failed:", err instanceof Error ? err.message : err);
+        const reports = (session.exportReports ?? []).filter((report2) => !report2.sink && report2.exporter === name);
+        const report = reports[reports.length - 1];
+        if (!report) return;
+        const { result } = report;
+        if (!result.ok) {
+          ctx.logger.warn(`otelTracing export failed: ${result.error ?? "unknown error"}`);
+          return;
+        }
+        if (result.skipped) {
+          ctx.emit({ type: "metadata", otelTracing: { exported: false, reason: result.reason ?? "nothing to export" } });
+          return;
         }
+        ctx.emit({
+          type: "metadata",
+          otelTracing: {
+            exported: true,
+            endpoint: report.endpoint,
+            spans: result.spans,
+            terminal: report.terminal,
+            // A 200 that refused some spans: the collector's count and message.
+            ...result.partialSuccess ? { rejectedSpans: result.partialSuccess.rejectedSpans, ...result.partialSuccess.message ? { rejectionMessage: result.partialSuccess.message } : {} } : {}
+          }
+        });
       }
     }
   };
@@ -18857,9 +20625,9 @@ function mapAnthropicStopReason(reason) {
       return "stop";
   }
 }
-function safeJsonParse(str) {
+function safeJsonParse(str2) {
   try {
-    return JSON.parse(str);
+    return JSON.parse(str2);
   } catch {
     return {};
   }
@@ -19729,9 +21497,9 @@ function mediaTypeToFormat(mediaType) {
   };
   return map[mediaType] ?? "png";
 }
-function safeJsonParse2(str) {
+function safeJsonParse2(str2) {
   try {
-    return JSON.parse(str);
+    return JSON.parse(str2);
   } catch {
     return {};
   }
@@ -20128,10 +21896,13 @@ var VertexProvider = class extends BaseProvider {
           textParts.push(part.text);
         }
       } else if (part.functionCall) {
+        const suppliedId = typeof part.functionCall.id === "string" && part.functionCall.id ? part.functionCall.id : void 0;
+        const position = toolCallIdx++;
         toolCalls.push({
-          id: `call_${toolCallIdx++}`,
+          id: suppliedId ?? `call_${position}`,
           name: part.functionCall.name,
           arguments: JSON.stringify(part.functionCall.args ?? {}),
+          ...suppliedId ? {} : { idSynthesized: true },
           ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
         });
       }
@@ -20171,12 +21942,15 @@ var VertexProvider = class extends BaseProvider {
         }
       } else if (part.functionCall) {
         if (!delta.toolCalls) delta.toolCalls = [];
+        const suppliedId = typeof part.functionCall.id === "string" && part.functionCall.id ? part.functionCall.id : void 0;
+        const position = counter.next++;
         delta.toolCalls.push({
           // Unique across the whole stream: the adapter merges chunks by id.
-          id: `call_${counter.next}`,
-          index: counter.next++,
+          id: suppliedId ?? `call_${position}`,
+          index: position,
           name: part.functionCall.name,
           arguments: JSON.stringify(part.functionCall.args ?? {}),
+          ...suppliedId ? {} : { idSynthesized: true },
           ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
         });
       }
@@ -20229,12 +22003,12 @@ function mapGeminiFinishReason(reason) {
       return "stop";
   }
 }
-function base64url(str) {
-  return Buffer.from(str).toString("base64url");
+function base64url(str2) {
+  return Buffer.from(str2).toString("base64url");
 }
-function safeJsonParse3(str) {
+function safeJsonParse3(str2) {
   try {
-    return JSON.parse(str);
+    return JSON.parse(str2);
   } catch {
     return {};
   }
@@ -20279,6 +22053,7 @@ exports.DEFAULT_SUBAGENT_TOOL_NAMES = DEFAULT_SUBAGENT_TOOL_NAMES;
 exports.DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS = DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS;
 exports.DELEGATION_TOOL_NAMES = DELEGATION_TOOL_NAMES;
 exports.DedupTracker = DedupTracker;
+exports.GENAI_SEMCONV_COMMIT = GENAI_SEMCONV_COMMIT;
 exports.GuardrailPhase = GuardrailPhase;
 exports.HOOK_CONTRACT_VERSION = HOOK_CONTRACT_VERSION;
 exports.HOOK_NAMES = HOOK_NAMES;
@@ -20319,6 +22094,7 @@ exports.canSpawn = canSpawn;
 exports.captureSnapshot = captureSnapshot;
 exports.checkpointing = checkpointing;
 exports.clearLearnedModelRules = clearLearnedModelRules;
+exports.closeTraceContinuation = closeTraceContinuation;
 exports.codePresenceRule = codePresenceRule;
 exports.coerceToolArgs = coerceToolArgs;
 exports.cognipeerGuardrail = cognipeerGuardrail;
@@ -20353,6 +22129,7 @@ exports.createJsonGuardrail = createJsonGuardrail;
 exports.createManageTodoListAliasTool = createManageTodoListAliasTool;
 exports.createManageTodoTool = createManageTodoTool;
 exports.createOpenSkillTool = createOpenSkillTool;
+exports.createOtlpExporter = createOtlpExporter;
 exports.createParallelTool = createParallelTool;
 exports.createPluginHost = createPluginHost;
 exports.createProvider = createProvider;
@@ -20389,6 +22166,8 @@ exports.extractMessageText = extractMessageText;
 exports.fileCheckpointStore = fileCheckpointStore;
 exports.fileSink = fileSink;
 exports.findSubagent = findSubagent;
+exports.foldSupersededSpans = foldSupersededSpans;
+exports.formatTraceparent = formatTraceparent;
 exports.formatZodError = formatZodError;
 exports.fromLangchainModel = fromLangchainModel;
 exports.fromLangchainTools = fromLangchainTools;
@@ -20436,6 +22215,7 @@ exports.outputGuard = outputGuard;
 exports.parseApprovalDecision = parseApprovalDecision;
 exports.parseModelError = parseModelError;
 exports.parseSkillFrontmatter = parseSkillFrontmatter;
+exports.parseTraceparent = parseTraceparent;
 exports.pathSandbox = pathSandbox;
 exports.piiRedaction = piiRedaction;
 exports.pluginCapabilities = pluginCapabilities;
@@ -20490,6 +22270,7 @@ exports.toolPolicy = toolPolicy;
 exports.traceContinuationOf = traceContinuationOf;
 exports.traceSectionsFromMessages = traceSectionsFromMessages;
 exports.traceSessionToOtlp = traceSessionToOtlp;
+exports.traceparentOf = traceparentOf;
 exports.validateReasoningConfig = validateReasoningConfig;
 exports.validateToolArgs = validateToolArgs;
 exports.webhookApproval = webhookApproval;