@cognipeer/agent-sdk 0.16.0 → 0.18.0

package/dist/index.mjs

@@ -6,6 +6,8 @@ import path from 'path';
 import { Buffer as Buffer$1 } from 'buffer';
 import { nanoid } from 'nanoid';
 import crypto, { createHash, randomUUID, createHmac } from 'crypto';
+import { gzip } from 'zlib';
+import { promisify } from 'util';
 import AjvModule from 'ajv';
 
 var __defProp = Object.defineProperty;
@@ -1221,9 +1223,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$1.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$1.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 = promisify(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$1.from(body, "utf8") : body);
+          headers["content-encoding"] = "gzip";
+        }
+        Object.assign(headers, env.headers);
+        const bytes = typeof body === "string" ? Buffer$1.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 };
@@ -1249,8 +2640,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();
@@ -1323,23 +2715,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;
@@ -1370,8 +2762,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;
@@ -1389,8 +2781,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;
@@ -1452,12 +2844,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") {
@@ -1467,6 +2865,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) {
@@ -1479,7 +2888,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" };
   }
@@ -1497,11 +2906,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) {
@@ -1594,206 +3003,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 {
@@ -1813,10 +3039,16 @@ function generateEventId(sequence) {
   return `evt_${String(sequence).padStart(4, "0")}_${nanoid(4)}`;
 }
 function generateTraceId() {
-  return crypto.randomBytes(16).toString("hex");
+  for (; ; ) {
+    const id = crypto.randomBytes(16).toString("hex");
+    if (/[1-9a-f]/.test(id)) return id;
+  }
 }
 function generateSpanId() {
-  return crypto.randomBytes(8).toString("hex");
+  for (; ; ) {
+    const id = crypto.randomBytes(8).toString("hex");
+    if (/[1-9a-f]/.test(id)) return id;
+  }
 }
 function defaultEventLabel(type) {
   switch (type) {
@@ -2093,9 +3325,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,
@@ -2109,15 +3396,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,
@@ -2136,7 +3440,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;
@@ -2203,7 +3520,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;
@@ -2252,10 +3569,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,
@@ -2286,6 +3613,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,
@@ -2307,6 +3644,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") {
@@ -2349,6 +3695,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)) {
@@ -2359,7 +3768,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) {
@@ -2393,6 +3803,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
     });
   }
@@ -2416,24 +3827,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) {
@@ -2529,6 +3978,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 {
@@ -2568,6 +4034,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,
@@ -2590,7 +4122,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();
       }
@@ -2609,6 +4146,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) {
@@ -2616,6 +4155,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;
@@ -2637,7 +4178,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 } : {}
                   });
                 }
               }
@@ -2661,7 +4203,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();
       }
@@ -3035,7 +4583,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)) {
@@ -3057,7 +4606,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;
@@ -3951,7 +5501,7 @@ var CCRStore = class _CCRStore {
   }
   static hashOf(value) {
     const serialized = typeof value === "string" ? value : JSON.stringify(value);
-    return createHash("sha1").update(serialized).digest("hex").slice(0, 16);
+    return createHash("sha256").update(serialized).digest("hex").slice(0, 16);
   }
 };
 var DedupTracker = class {
@@ -3964,7 +5514,7 @@ var DedupTracker = class {
    * first time it has been seen.
    */
   checkAndRegister(content, executionId, toolName) {
-    const hash = createHash("sha1").update(content).digest("hex");
+    const hash = createHash("sha256").update(content).digest("hex");
     const existing = this.seen.get(hash);
     if (!existing) {
       this.seen.set(hash, { executionId, toolName });
@@ -4501,7 +6051,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) => {
@@ -4714,8 +6264,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 {
@@ -4744,9 +6295,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) => {
@@ -4760,12 +6314,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 } });
@@ -4781,8 +6339,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
         });
@@ -4790,8 +6349,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)) {
@@ -4837,12 +6398,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;
         }
@@ -4895,6 +6458,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",
@@ -4911,11 +6476,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);
@@ -4926,6 +6493,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);
@@ -4938,8 +6508,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 = [
     {
@@ -4963,14 +6539,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);
@@ -5004,12 +6580,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) {
@@ -5049,13 +6632,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 = [
@@ -5074,7 +6664,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) {
@@ -5121,7 +6711,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) } : {}
+    })]
   });
 }
 
@@ -5227,9 +6824,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;
@@ -5487,6 +7086,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({
@@ -5558,6 +7159,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({
@@ -5694,10 +7297,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,
@@ -5711,6 +7317,7 @@ function createToolsNode(initialTools, opts) {
         toolCount += 1;
         return { status: "error" };
       }
+      let traceSpanId;
       try {
         if (cachedHit !== void 0) {
           const executionId2 = nanoid();
@@ -5756,6 +7363,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,
@@ -5790,7 +7400,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);
@@ -5973,9 +7592,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,
@@ -6035,15 +7658,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,
@@ -6158,6 +7784,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({
@@ -6324,7 +7952,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 {};
     }
@@ -6995,7 +8623,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,
@@ -7335,7 +8963,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: {
@@ -7440,7 +9068,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
       });
@@ -7495,6 +9123,7 @@ function createPluginHost(plugins = [], options = {}) {
   let contributions = {
     tools: [],
     toolDescriptions: {},
+    traceExporters: [],
     guardrails: [],
     applySystemPrompt: (base) => base,
     applyModelWrappers: (model) => model
@@ -7503,6 +9132,7 @@ function createPluginHost(plugins = [], options = {}) {
   async function runSetup(setupInput) {
     const tools = [];
     const toolDescriptions = {};
+    const traceExporters = [];
     const guardrails = [];
     const promptSteps = [];
     const modelWrappers = [];
@@ -7540,6 +9170,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 });
@@ -7555,6 +9186,7 @@ function createPluginHost(plugins = [], options = {}) {
     contributions = {
       tools,
       toolDescriptions,
+      traceExporters,
       guardrails,
       applySystemPrompt: (base) => promptSteps.reduce((current, step) => {
         try {
@@ -8278,19 +9910,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;
         }
@@ -8575,7 +10210,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,
@@ -8600,7 +10238,9 @@ function createAgent(opts) {
     const inheritedSession = config?.__pluginSession;
     ctx.__runId = inheritedSession?.runId ?? traceSession?.sessionId ?? `run_${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,
@@ -8725,7 +10365,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) {
@@ -8746,7 +10386,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) };
@@ -8843,7 +10486,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 : [];
@@ -8876,6 +10519,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;
@@ -8891,7 +10561,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,
@@ -8968,9 +10645,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;
     }
@@ -8981,7 +10659,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;
@@ -8998,8 +10676,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);
@@ -9650,7 +11329,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) => {
@@ -9681,6 +11360,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",
@@ -9722,6 +11402,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;
@@ -9758,7 +11439,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) => {
@@ -9914,10 +11595,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(),
@@ -11054,11 +12741,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(6)}`;
+  const spawnId = opts.record?.spawnId ?? `sa_${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 });
   };
@@ -11066,6 +12794,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",
@@ -11164,6 +12901,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 {
@@ -11204,8 +12942,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 };
       }
@@ -11227,8 +12971,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 };
       }
@@ -11332,7 +13082,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;
@@ -11377,7 +13127,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;
@@ -11460,7 +13210,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." };
         }
@@ -11912,6 +13663,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;
@@ -11990,11 +13765,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;
@@ -12021,6 +13800,7 @@ ${pluginAppend}`;
             const result = await trySummarize(state, rawMessages, stateRef);
             state = result.state;
             rawMessages = result.rawMessages;
+            noteTraceHandoff(state);
             continue;
           }
           if (state.ctx?.__finalizedDueToStructuredOutput) break;
@@ -12032,6 +13812,7 @@ ${pluginAppend}`;
               const result = await trySummarize(state, rawMessages, stateRef);
               state = result.state;
               rawMessages = result.rawMessages;
+              noteTraceHandoff(state);
               if (result.compressed) continue;
             }
           }
@@ -12042,6 +13823,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 };
@@ -12061,8 +13843,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) {
@@ -12108,6 +13894,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;
       }
@@ -13024,7 +14815,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);
@@ -13122,7 +14913,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();
@@ -13229,9 +15020,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`
           );
@@ -13728,7 +15519,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 = {}) {
@@ -13749,7 +15540,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))) {
@@ -13811,7 +15602,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;
@@ -14579,7 +16370,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 = () => {
@@ -14636,7 +16427,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);
       }
@@ -15732,18 +17523,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
@@ -15751,67 +17545,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 } : {} } : {}
+          }
+        });
       }
     }
   };
@@ -18847,9 +20615,9 @@ function mapAnthropicStopReason(reason) {
       return "stop";
   }
 }
-function safeJsonParse(str) {
+function safeJsonParse(str2) {
   try {
-    return JSON.parse(str);
+    return JSON.parse(str2);
   } catch {
     return {};
   }
@@ -19719,9 +21487,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 {};
   }
@@ -20118,10 +21886,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 } : {}
         });
       }
@@ -20161,12 +21932,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 } : {}
         });
       }
@@ -20219,12 +21993,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 {};
   }
@@ -20252,6 +22026,6 @@ function createProvider(config) {
   }
 }
 
-export { ASK_USER_TOOL_NAME, AnthropicProvider, AzureProvider, BaseProvider, BedrockProvider, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, GuardrailPhase, HOOK_CONTRACT_VERSION, HOOK_NAMES, HookTimeoutError, InMemoryMemoryStore, JevProvider, LAST_SUMMARIZATION_CALL_KEY, MAX_ADJUSTMENTS, MODEL_RULES, ModelRequestError, NativeJsonSchemaStrategy, OpenAICompatibleProvider, OpenAIProvider, PREOPEN_TOOL_CALL_PREFIX, ProviderError, SMALL_TIER_SKILL_POLICY, StructuredOutputManager, TOOL_INPUT_DIGEST_KEY, ToolBasedStrategy, VertexProvider, agentVerdictRule, allowsSampling, appendBoundTools, applyDropParams, asModelRequestError, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, clearLearnedModelRules, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentPartToText, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, describeContentPart, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, effortBudget, emptyUsage, evaluateGuardrails, extractLatestUserQuery, extractMessageText, fileCheckpointStore, fileSink, findSubagent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getLearnedModelRulePatch, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasMediaPart, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isTraceSessionOpen, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, listLearnedModelRules, loadSkillsFromDisk, mapConsoleHookVerdict, mapReasoningEffort, mapTextParts, mcp, mediaKindOf, mediaPolicy, mergeRulePatch, modelIdCandidates, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseModelError, parseSkillFrontmatter, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, readTraceContinuation, recordOrDeferTraceEvent, redactText, regexGuardrail, regexRule, rememberModelRulePatch, replaceTextContent, replayDeferredTraceEvents, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveModelRule, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, runWithModelAdjustments, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, supportsAdaptiveThinking, textFromContent, toMessageUsage, toModelResult, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceContinuationOf, traceSectionsFromMessages, traceSessionToOtlp, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };
+export { ASK_USER_TOOL_NAME, AnthropicProvider, AzureProvider, BaseProvider, BedrockProvider, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, GENAI_SEMCONV_COMMIT, GuardrailPhase, HOOK_CONTRACT_VERSION, HOOK_NAMES, HookTimeoutError, InMemoryMemoryStore, JevProvider, LAST_SUMMARIZATION_CALL_KEY, MAX_ADJUSTMENTS, MODEL_RULES, ModelRequestError, NativeJsonSchemaStrategy, OpenAICompatibleProvider, OpenAIProvider, PREOPEN_TOOL_CALL_PREFIX, ProviderError, SMALL_TIER_SKILL_POLICY, StructuredOutputManager, TOOL_INPUT_DIGEST_KEY, ToolBasedStrategy, VertexProvider, agentVerdictRule, allowsSampling, appendBoundTools, applyDropParams, asModelRequestError, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, clearLearnedModelRules, closeTraceContinuation, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentPartToText, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createOtlpExporter, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, describeContentPart, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, effortBudget, emptyUsage, evaluateGuardrails, extractLatestUserQuery, extractMessageText, fileCheckpointStore, fileSink, findSubagent, foldSupersededSpans, formatTraceparent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getLearnedModelRulePatch, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasMediaPart, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isTraceSessionOpen, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, listLearnedModelRules, loadSkillsFromDisk, mapConsoleHookVerdict, mapReasoningEffort, mapTextParts, mcp, mediaKindOf, mediaPolicy, mergeRulePatch, modelIdCandidates, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseModelError, parseSkillFrontmatter, parseTraceparent, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, readTraceContinuation, recordOrDeferTraceEvent, redactText, regexGuardrail, regexRule, rememberModelRulePatch, replaceTextContent, replayDeferredTraceEvents, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveModelRule, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, runWithModelAdjustments, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, supportsAdaptiveThinking, textFromContent, toMessageUsage, toModelResult, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceContinuationOf, traceSectionsFromMessages, traceSessionToOtlp, traceparentOf, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map