autotel-devtools 2.0.6 → 2.1.0

package/dist/genai/index.cjs

@@ -0,0 +1,586 @@
+'use strict';
+
+// src/widget/genai/detect.ts
+var GENAI_MARKERS = [
+  "gen_ai.system",
+  "gen_ai.provider.name",
+  "gen_ai.operation.name",
+  "ai.model.provider"
+];
+function isGenAiSpan(span) {
+  const attrs = span.attributes ?? {};
+  for (const key of GENAI_MARKERS) {
+    if (attrs[key] != null) return true;
+  }
+  return false;
+}
+
+// src/widget/genai/prices.ts
+var TABLE = {
+  "openai/gpt-4o": { inputPerMTok: 2.5, outputPerMTok: 10 },
+  "openai/gpt-4o-mini": { inputPerMTok: 0.15, outputPerMTok: 0.6 },
+  "openai/gpt-4-turbo": { inputPerMTok: 10, outputPerMTok: 30 },
+  "openai/gpt-3.5-turbo": { inputPerMTok: 0.5, outputPerMTok: 1.5 },
+  "anthropic/claude-opus-4": { inputPerMTok: 15, outputPerMTok: 75 },
+  "anthropic/claude-sonnet-4": { inputPerMTok: 3, outputPerMTok: 15 },
+  "anthropic/claude-3-5-sonnet": { inputPerMTok: 3, outputPerMTok: 15 },
+  "anthropic/claude-3-5-haiku": { inputPerMTok: 0.8, outputPerMTok: 4 },
+  "anthropic/claude-3-opus": { inputPerMTok: 15, outputPerMTok: 75 },
+  "anthropic/claude-3-haiku": { inputPerMTok: 0.25, outputPerMTok: 1.25 },
+  "google/gemini-2.5-flash": { inputPerMTok: 0.3, outputPerMTok: 2.5 },
+  "google/gemini-2.0-flash": { inputPerMTok: 0.1, outputPerMTok: 0.4 },
+  "google/gemini-1.5-pro": { inputPerMTok: 1.25, outputPerMTok: 5 },
+  "google/gemini-1.5-flash": { inputPerMTok: 0.075, outputPerMTok: 0.3 },
+  "mistral/mistral-large": { inputPerMTok: 2, outputPerMTok: 6 },
+  "mistral/mistral-small": { inputPerMTok: 0.2, outputPerMTok: 0.6 },
+  "groq/llama-3.1-70b": { inputPerMTok: 0.59, outputPerMTok: 0.79 },
+  "deepseek/deepseek-chat": { inputPerMTok: 0.27, outputPerMTok: 1.1 }
+};
+function normalizeProvider(provider) {
+  const p = provider.toLowerCase();
+  if (p === "az.ai.openai" || p === "azure_openai") return "openai";
+  if (p === "vertex_ai" || p === "gcp.vertex_ai" || p === "gcp.gemini") return "google";
+  return p;
+}
+var SORTED_KEYS = Object.keys(TABLE).sort((a, b) => {
+  const am = a.split("/")[1] ?? "";
+  const bm = b.split("/")[1] ?? "";
+  return bm.length - am.length;
+});
+function lookupPrice(provider, model) {
+  const normalizedProvider = normalizeProvider(provider);
+  const normalizedModel = model.toLowerCase();
+  for (const key of SORTED_KEYS) {
+    const [tableProvider, tableModel] = key.split("/");
+    if (tableProvider === normalizedProvider && normalizedModel.startsWith(tableModel)) {
+      return TABLE[key];
+    }
+  }
+  return void 0;
+}
+function priceCall(inputs) {
+  const entry = lookupPrice(inputs.provider, inputs.model);
+  if (!entry) {
+    return { currency: "USD", input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, source: "unknown" };
+  }
+  const cacheReadRate = entry.cacheReadPerMTok ?? entry.inputPerMTok * 0.1;
+  const cacheWriteRate = entry.cacheWritePerMTok ?? entry.inputPerMTok * 1.25;
+  const cacheRead = (inputs.cacheReadInputTokens ?? 0) / 1e6 * cacheReadRate;
+  const cacheWrite = (inputs.cacheCreationInputTokens ?? 0) / 1e6 * cacheWriteRate;
+  const billableInputTokens = Math.max(
+    0,
+    (inputs.inputTokens ?? 0) - (inputs.cacheReadInputTokens ?? 0) - (inputs.cacheCreationInputTokens ?? 0)
+  );
+  const input = billableInputTokens / 1e6 * entry.inputPerMTok;
+  const output = (inputs.outputTokens ?? 0) / 1e6 * entry.outputPerMTok;
+  const total = input + output + cacheRead + cacheWrite;
+  return { currency: "USD", input, output, cacheRead, cacheWrite, total, source: "table" };
+}
+
+// src/widget/genai/normalize.ts
+function str(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function num(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string" && v !== "") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function strArray(v) {
+  if (Array.isArray(v) && v.every((x) => typeof x === "string")) return v;
+  if (typeof v === "string") return [v];
+  return void 0;
+}
+function bool(v) {
+  if (typeof v === "boolean") return v;
+  if (v === "true") return true;
+  if (v === "false") return false;
+  return void 0;
+}
+function parseJson(v) {
+  if (v == null) return void 0;
+  if (typeof v === "object") return v;
+  if (typeof v !== "string") return void 0;
+  try {
+    return JSON.parse(v);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeMessageParts(raw) {
+  if (Array.isArray(raw.parts)) {
+    return raw.parts.map((p) => {
+      const type = p.type ?? "text";
+      if (type === "text") return { kind: "text", text: String(p.content ?? "") };
+      if (type === "image") return { kind: "image", mediaType: "image/*", dataRef: String(p.content ?? "") };
+      if (type === "audio") return { kind: "audio", mediaType: "audio/*", dataRef: String(p.content ?? "") };
+      return { kind: "json", value: p.content };
+    });
+  }
+  if (Array.isArray(raw.content)) {
+    return raw.content.map((p) => {
+      if (p.type === "text" || p.text !== void 0) {
+        return { kind: "text", text: String(p.text ?? "") };
+      }
+      if (p.type === "image") {
+        return { kind: "image", mediaType: p.mimeType ?? "image/*", dataRef: String(p.image ?? p.data ?? "") };
+      }
+      if (p.type === "audio") {
+        return { kind: "audio", mediaType: p.mimeType ?? "audio/*", dataRef: String(p.data ?? "") };
+      }
+      return { kind: "json", value: p };
+    });
+  }
+  if (typeof raw.content === "string") return [{ kind: "text", text: raw.content }];
+  if (raw.content != null) return [{ kind: "json", value: raw.content }];
+  return [];
+}
+function normalizeMessage(raw) {
+  const role = raw.role ?? "user";
+  if (Array.isArray(raw.content)) {
+    const content = raw.content;
+    const hasToolPart = content.some(
+      (p) => p.type === "tool-call" || p.type === "tool-result"
+    );
+    if (hasToolPart) {
+      const toolCalls = [];
+      const parts = [];
+      const toolResults = [];
+      for (const part of content) {
+        if (part.type === "tool-call") {
+          toolCalls.push({
+            id: part.toolCallId,
+            name: part.toolName ?? "",
+            arguments: parseJson(part.input) ?? part.input ?? {}
+          });
+        } else if (part.type === "tool-result") {
+          const out = part.output;
+          const value = out && typeof out === "object" && "value" in out ? out.value : out;
+          toolResults.push({ id: part.toolCallId, value });
+        } else if (part.type === "text" || part.text !== void 0) {
+          parts.push({ kind: "text", text: String(part.text ?? "") });
+        }
+      }
+      if (toolResults.length > 1) {
+        const msg3 = { role, parts: [] };
+        msg3._toolResults = toolResults;
+        return msg3;
+      }
+      const msg2 = { role, parts };
+      if (toolCalls.length > 0) msg2.toolCalls = toolCalls;
+      if (toolResults.length === 1) {
+        msg2.toolCallId = toolResults[0].id;
+        msg2.parts = [{ kind: "json", value: toolResults[0].value }];
+      }
+      if (raw.finish_reason) msg2.finishReason = raw.finish_reason;
+      return msg2;
+    }
+  }
+  const msg = { role, parts: normalizeMessageParts(raw) };
+  if (Array.isArray(raw.tool_calls) && raw.tool_calls.length > 0) {
+    msg.toolCalls = raw.tool_calls.map((tc) => ({
+      id: tc.id,
+      name: tc.function?.name ?? "",
+      arguments: parseJson(tc.function?.arguments) ?? tc.function?.arguments ?? {},
+      type: tc.type
+    }));
+  }
+  if (raw.tool_call_id) msg.toolCallId = raw.tool_call_id;
+  if (raw.finish_reason) msg.finishReason = raw.finish_reason;
+  return msg;
+}
+function readMessagesAttribute(attrs, key) {
+  const value = parseJson(attrs[key]);
+  if (!Array.isArray(value)) return void 0;
+  return value.map(normalizeMessage);
+}
+function messagesFromEvents(events) {
+  if (!events || events.length === 0) return [];
+  const out = [];
+  for (const ev of events) {
+    const attrs = ev.attributes ?? {};
+    if (ev.name === "gen_ai.choice") {
+      const message = parseJson(attrs.message) ?? attrs.message;
+      const finishReason = str(attrs.finish_reason);
+      if (message) {
+        const normalized = normalizeMessage(message);
+        if (finishReason) normalized.finishReason = finishReason;
+        out.push(normalized);
+      }
+      continue;
+    }
+    const m = ev.name.match(/^gen_ai\.(system|user|assistant|tool)\.message$/);
+    if (!m) continue;
+    const role = m[1];
+    const content = attrs.content;
+    const parsed = typeof content === "string" ? parseJson(content) ?? content : content;
+    out.push(normalizeMessage({
+      role,
+      content: parsed,
+      tool_calls: parseJson(attrs.tool_calls),
+      tool_call_id: str(attrs.id) ?? str(attrs.tool_call_id)
+    }));
+  }
+  return out;
+}
+function readToolDefinitions(attrs) {
+  const raw = parseJson(
+    attrs["gen_ai.tool.definitions"] ?? attrs["gen_ai.orchestrator.agent.definitions"]
+  );
+  if (!Array.isArray(raw)) return void 0;
+  return raw.filter((d) => typeof d.name === "string").map((d) => ({
+    name: d.name,
+    description: d.description,
+    type: d.type,
+    schema: d.schema ?? d.parameters
+  }));
+}
+function readUsage(attrs) {
+  const inputTokens = num(attrs["gen_ai.usage.input_tokens"]) ?? num(attrs["gen_ai.usage.prompt_tokens"]) ?? num(attrs["llm.usage.prompt_tokens"]) ?? num(attrs["ai.usage.inputTokens"]);
+  const outputTokens = num(attrs["gen_ai.usage.output_tokens"]) ?? num(attrs["gen_ai.usage.completion_tokens"]) ?? num(attrs["llm.usage.completion_tokens"]) ?? num(attrs["ai.usage.outputTokens"]);
+  return {
+    inputTokens,
+    outputTokens,
+    reasoningOutputTokens: num(attrs["gen_ai.usage.reasoning.output_tokens"]),
+    cacheReadInputTokens: num(attrs["gen_ai.usage.cache_read.input_tokens"]),
+    cacheCreationInputTokens: num(attrs["gen_ai.usage.cache_creation.input_tokens"])
+  };
+}
+function normalizeProviderName(raw) {
+  const p = raw.toLowerCase();
+  if (p === "az.ai.openai" || p === "azure_openai") return "openai";
+  if (p === "gcp.vertex_ai" || p === "vertex_ai" || p === "gcp.gemini" || p === "google-gla" || // Logfire / Pydantic AI naming for Google GenAI library
+  p === "google_genai" || p === "gemini") {
+    return "google";
+  }
+  return p;
+}
+var KNOWN_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "gen_ai.system",
+  "gen_ai.provider.name",
+  "gen_ai.operation.name",
+  "gen_ai.request.model",
+  "gen_ai.response.model",
+  "gen_ai.response.id",
+  "gen_ai.response.finish_reasons",
+  "gen_ai.request.temperature",
+  "gen_ai.request.top_p",
+  "gen_ai.request.top_k",
+  "gen_ai.request.max_tokens",
+  "gen_ai.request.stop_sequences",
+  "gen_ai.request.seed",
+  "gen_ai.request.frequency_penalty",
+  "gen_ai.request.presence_penalty",
+  "gen_ai.request.choice.count",
+  "gen_ai.usage.input_tokens",
+  "gen_ai.usage.output_tokens",
+  "gen_ai.usage.prompt_tokens",
+  "gen_ai.usage.completion_tokens",
+  "gen_ai.usage.reasoning.output_tokens",
+  "gen_ai.usage.cache_read.input_tokens",
+  "gen_ai.usage.cache_creation.input_tokens",
+  "gen_ai.input.messages",
+  "gen_ai.output.messages",
+  "gen_ai.input.messages.ref",
+  "gen_ai.output.messages.ref",
+  "gen_ai.system_instructions",
+  "gen_ai.tool.definitions",
+  "gen_ai.orchestrator.agent.definitions",
+  "gen_ai.agent.id",
+  "gen_ai.agent.name",
+  "gen_ai.agent.description",
+  "gen_ai.handoff.from_agent",
+  "gen_ai.handoff.to_agent",
+  "gen_ai.guardrail.name",
+  "gen_ai.guardrail.triggered",
+  "gen_ai.conversation.id",
+  "gen_ai.evaluation.name",
+  "gen_ai.evaluation.score.value",
+  "gen_ai.evaluation.score.label",
+  "gen_ai.evaluation.explanation",
+  "gen_ai.audio.input.format",
+  "gen_ai.audio.output.format",
+  "gen_ai.speech.voice",
+  "gen_ai.speech.input_text",
+  "gen_ai.transcription.text",
+  "gen_ai.embeddings.dimension.count",
+  "gen_ai.openai.request.service_tier",
+  "gen_ai.openai.response.service_tier",
+  "gen_ai.openai.response.system_fingerprint",
+  "gen_ai.openai.request.response_format",
+  "openai.request.service_tier",
+  "openai.response.service_tier",
+  "openai.response.system_fingerprint",
+  "openai.request.response_format"
+]);
+function toGenAiSpan(span) {
+  const attrs = span.attributes ?? {};
+  const rawProvider = str(attrs["gen_ai.provider.name"]) ?? str(attrs["gen_ai.system"]) ?? // Vercel AI SDK wrapper spans expose only `ai.model.provider`.
+  str(attrs["ai.model.provider"]) ?? "unknown";
+  const provider = normalizeProviderName(rawProvider);
+  const operation = str(attrs["gen_ai.operation.name"]) ?? "chat";
+  const requestModel = str(attrs["gen_ai.request.model"]) ?? str(attrs["llm.request.model"]) ?? // Pydantic AI's `agent run` parent span carries `model_name` but not
+  // `gen_ai.request.model`. Same pattern for any host-language convention
+  // that mirrors gen_ai.* loosely.
+  str(attrs["model_name"]) ?? str(attrs["ai.model.id"]) ?? "unknown";
+  const responseModel = str(attrs["gen_ai.response.model"]) ?? str(attrs["llm.response.model"]) ?? str(attrs["ai.response.model"]);
+  const inputMessages = readMessagesAttribute(attrs, "gen_ai.input.messages") ?? [];
+  const outputMessages = readMessagesAttribute(attrs, "gen_ai.output.messages") ?? [];
+  let systemInstructions = [];
+  const rawSystem = parseJson(attrs["gen_ai.system_instructions"]);
+  if (Array.isArray(rawSystem) && rawSystem.length > 0) {
+    const first = rawSystem[0];
+    if (first && typeof first === "object" && "role" in first) {
+      systemInstructions = rawSystem.map((m) => normalizeMessage(m));
+    } else {
+      const parts = rawSystem.map(
+        (p) => p.type === "text" || p.content !== void 0 ? { kind: "text", text: String(p.content ?? "") } : { kind: "json", value: p }
+      );
+      systemInstructions = [{ role: "system", parts }];
+    }
+  }
+  let messages = inputMessages.length || outputMessages.length || systemInstructions.length ? [...systemInstructions, ...inputMessages, ...outputMessages] : messagesFromEvents(span.events);
+  const inputRef = str(attrs["gen_ai.input.messages.ref"]);
+  const outputRef = str(attrs["gen_ai.output.messages.ref"]);
+  const hasInputContent = messages.some((m) => m.role === "system" || m.role === "user");
+  const hasOutputContent = messages.some((m) => m.role === "assistant");
+  if (inputRef && !hasInputContent) {
+    messages.push({ role: "user", parts: [{ kind: "ref", ref: inputRef, direction: "input" }] });
+  }
+  if (outputRef && !hasOutputContent) {
+    messages.push({ role: "assistant", parts: [{ kind: "ref", ref: outputRef, direction: "output" }] });
+  }
+  if (messages.length === 0) {
+    const aiPrompt = parseJson(attrs["ai.prompt.messages"]);
+    if (Array.isArray(aiPrompt)) {
+      messages.push(...aiPrompt.map(normalizeMessage));
+    } else {
+      const aiPromptBlob = parseJson(attrs["ai.prompt"]);
+      if (aiPromptBlob) {
+        if (Array.isArray(aiPromptBlob.messages)) {
+          messages.push(...aiPromptBlob.messages.map(normalizeMessage));
+        } else {
+          if (aiPromptBlob.system) {
+            messages.push({ role: "system", parts: [{ kind: "text", text: aiPromptBlob.system }] });
+          }
+          if (aiPromptBlob.prompt) {
+            messages.push({ role: "user", parts: [{ kind: "text", text: aiPromptBlob.prompt }] });
+          }
+        }
+      }
+    }
+    const aiResponseToolCalls = parseJson(
+      attrs["ai.response.toolCalls"]
+    );
+    const assistantToolCalls = Array.isArray(aiResponseToolCalls) ? aiResponseToolCalls.filter((c) => typeof c.toolName === "string").map((c) => ({
+      id: c.toolCallId,
+      name: c.toolName,
+      arguments: parseJson(c.input ?? c.args) ?? c.input ?? c.args ?? {}
+    })) : void 0;
+    const aiResponseText = str(attrs["ai.response.text"]);
+    if (aiResponseText || assistantToolCalls && assistantToolCalls.length > 0) {
+      const finishReason = strArray(attrs["gen_ai.response.finish_reasons"])?.[0] ?? str(attrs["ai.response.finishReason"]);
+      const msg = normalizeMessage({ role: "assistant", content: aiResponseText ?? "" });
+      if (finishReason) msg.finishReason = finishReason;
+      if (assistantToolCalls && assistantToolCalls.length > 0) msg.toolCalls = assistantToolCalls;
+      messages.push(msg);
+    }
+  }
+  if (messages.length === 0) {
+    const pydanticMessages = parseJson(attrs["pydantic_ai.all_messages"]);
+    if (Array.isArray(pydanticMessages)) {
+      messages.push(...pydanticMessages.map(normalizeMessage));
+    }
+  }
+  if (messages.length === 0) {
+    const legacy = [];
+    for (let i = 0; i < 32; i++) {
+      const role = str(attrs[`gen_ai.prompt.${i}.role`]) ?? str(attrs[`llm.prompts.${i}.role`]);
+      const content = attrs[`gen_ai.prompt.${i}.content`] ?? attrs[`llm.prompts.${i}.content`];
+      if (!role) break;
+      legacy.push(normalizeMessage({ role, content }));
+    }
+    for (let i = 0; i < 32; i++) {
+      const role = str(attrs[`gen_ai.completion.${i}.role`]) ?? str(attrs[`llm.completions.${i}.role`]);
+      const content = attrs[`gen_ai.completion.${i}.content`] ?? attrs[`llm.completions.${i}.content`];
+      const finishReason = str(attrs[`gen_ai.completion.${i}.finish_reason`]);
+      if (!role) break;
+      const msg = normalizeMessage({ role, content });
+      if (finishReason) msg.finishReason = finishReason;
+      legacy.push(msg);
+    }
+    if (legacy.length > 0) messages = legacy;
+  }
+  messages = messages.flatMap((m) => {
+    const bundled = m._toolResults;
+    if (!bundled) return [m];
+    return bundled.map((r) => ({
+      role: "tool",
+      parts: [{ kind: "json", value: r.value }],
+      toolCallId: r.id
+    }));
+  });
+  const toolCalls = [];
+  for (const m of messages) if (m.toolCalls) toolCalls.push(...m.toolCalls);
+  if (toolCalls.length > 0) {
+    const callsById = /* @__PURE__ */ new Map();
+    for (const tc of toolCalls) if (tc.id) callsById.set(tc.id, tc);
+    for (const m of messages) {
+      if (m.role !== "tool" || !m.toolCallId) continue;
+      const target = callsById.get(m.toolCallId);
+      if (!target || target.result !== void 0) continue;
+      const textPart = m.parts.find((p) => p.kind === "text");
+      const jsonPart = m.parts.find((p) => p.kind === "json");
+      if (textPart && textPart.kind === "text") {
+        target.result = parseJson(textPart.text) ?? textPart.text;
+      } else if (jsonPart && jsonPart.kind === "json") {
+        target.result = jsonPart.value;
+      }
+    }
+  }
+  const usage = readUsage(attrs);
+  const cost = priceCall({
+    provider,
+    model: responseModel ?? requestModel,
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    cacheReadInputTokens: usage.cacheReadInputTokens,
+    cacheCreationInputTokens: usage.cacheCreationInputTokens
+  });
+  const finishReasons = strArray(attrs["gen_ai.response.finish_reasons"]);
+  const agentName = str(attrs["gen_ai.agent.name"]);
+  const agentId = str(attrs["gen_ai.agent.id"]);
+  const agentDescription = str(attrs["gen_ai.agent.description"]);
+  const handoffFrom = str(attrs["gen_ai.handoff.from_agent"]);
+  const handoffTo = str(attrs["gen_ai.handoff.to_agent"]);
+  const guardrailName = str(attrs["gen_ai.guardrail.name"]);
+  const guardrailTriggered = bool(attrs["gen_ai.guardrail.triggered"]);
+  const evalName = str(attrs["gen_ai.evaluation.name"]);
+  const evalScoreValue = num(attrs["gen_ai.evaluation.score.value"]);
+  const evalScoreLabel = str(attrs["gen_ai.evaluation.score.label"]);
+  const evalExplanation = str(attrs["gen_ai.evaluation.explanation"]);
+  const audioIn = str(attrs["gen_ai.audio.input.format"]);
+  const audioOut = str(attrs["gen_ai.audio.output.format"]);
+  const speechVoice = str(attrs["gen_ai.speech.voice"]);
+  const speechInputText = str(attrs["gen_ai.speech.input_text"]);
+  const transcriptionText = str(attrs["gen_ai.transcription.text"]);
+  const embeddingDims = num(attrs["gen_ai.embeddings.dimension.count"]);
+  const raw = {};
+  for (const [k, v] of Object.entries(attrs)) {
+    if (KNOWN_TOP_LEVEL_KEYS.has(k)) continue;
+    if (k.startsWith("gen_ai.prompt.") || k.startsWith("gen_ai.completion.")) continue;
+    if (k.startsWith("llm.prompts.") || k.startsWith("llm.completions.")) continue;
+    raw[k] = v;
+  }
+  return {
+    traceId: span.traceId,
+    spanId: span.spanId,
+    parentSpanId: span.parentSpanId,
+    name: span.name,
+    startNs: span.startTime,
+    endNs: span.endTime,
+    status: span.status?.code === "OK" ? "ok" : span.status?.code === "ERROR" ? "error" : "unset",
+    errorMessage: span.status?.message,
+    provider,
+    operation,
+    requestModel,
+    responseModel,
+    params: {
+      temperature: num(attrs["gen_ai.request.temperature"]),
+      topP: num(attrs["gen_ai.request.top_p"]),
+      topK: num(attrs["gen_ai.request.top_k"]),
+      maxTokens: num(attrs["gen_ai.request.max_tokens"]),
+      stopSequences: strArray(attrs["gen_ai.request.stop_sequences"]),
+      seed: num(attrs["gen_ai.request.seed"]),
+      frequencyPenalty: num(attrs["gen_ai.request.frequency_penalty"]),
+      presencePenalty: num(attrs["gen_ai.request.presence_penalty"]),
+      choiceCount: num(attrs["gen_ai.request.choice.count"])
+    },
+    messages,
+    toolDefinitions: readToolDefinitions(attrs),
+    toolCalls,
+    usage,
+    cost,
+    finishReasons,
+    responseId: str(attrs["gen_ai.response.id"]),
+    agent: agentId || agentName || agentDescription ? { id: agentId, name: agentName, description: agentDescription } : void 0,
+    handoff: handoffFrom || handoffTo ? { fromAgent: handoffFrom, toAgent: handoffTo } : void 0,
+    guardrail: guardrailName || guardrailTriggered !== void 0 ? { name: guardrailName, triggered: guardrailTriggered } : void 0,
+    conversationId: str(attrs["gen_ai.conversation.id"]),
+    evaluation: evalName || evalScoreValue !== void 0 || evalScoreLabel || evalExplanation ? {
+      name: evalName,
+      scoreValue: evalScoreValue,
+      scoreLabel: evalScoreLabel,
+      explanation: evalExplanation
+    } : void 0,
+    modality: audioIn || audioOut || speechVoice || speechInputText || transcriptionText || embeddingDims ? {
+      audioInputFormat: audioIn,
+      audioOutputFormat: audioOut,
+      speechVoice,
+      speechInputText,
+      transcriptionText,
+      embeddingDimensions: embeddingDims
+    } : void 0,
+    extras: {
+      openaiServiceTier: str(attrs["gen_ai.openai.request.service_tier"]) || str(attrs["gen_ai.openai.response.service_tier"]) || str(attrs["openai.request.service_tier"]) || str(attrs["openai.response.service_tier"]) ? {
+        request: str(attrs["gen_ai.openai.request.service_tier"]) ?? str(attrs["openai.request.service_tier"]),
+        response: str(attrs["gen_ai.openai.response.service_tier"]) ?? str(attrs["openai.response.service_tier"])
+      } : void 0,
+      openaiSystemFingerprint: str(attrs["gen_ai.openai.response.system_fingerprint"]) ?? str(attrs["openai.response.system_fingerprint"]),
+      openaiResponseFormat: str(attrs["gen_ai.openai.request.response_format"]) ?? str(attrs["openai.request.response_format"]),
+      raw
+    }
+  };
+}
+
+// src/widget/genai/stitch.ts
+function buildToolResultIndex(spans) {
+  const index = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    const attrs = span.attributes ?? {};
+    const id = attrs["ai.toolCall.id"];
+    if (typeof id !== "string") continue;
+    const raw = attrs["ai.toolCall.result"];
+    if (raw == null) continue;
+    if (typeof raw === "string") {
+      try {
+        index.set(id, JSON.parse(raw));
+      } catch {
+        index.set(id, raw);
+      }
+    } else {
+      index.set(id, raw);
+    }
+  }
+  return index;
+}
+function hydrateToolResults(genAiSpan, index) {
+  if (index.size === 0) return;
+  for (const call of genAiSpan.toolCalls) {
+    if (call.result !== void 0) continue;
+    if (!call.id) continue;
+    const result = index.get(call.id);
+    if (result !== void 0) call.result = result;
+  }
+  for (const msg of genAiSpan.messages) {
+    if (!msg.toolCalls) continue;
+    for (const call of msg.toolCalls) {
+      if (call.result !== void 0) continue;
+      if (!call.id) continue;
+      const result = index.get(call.id);
+      if (result !== void 0) call.result = result;
+    }
+  }
+}
+
+exports.buildToolResultIndex = buildToolResultIndex;
+exports.hydrateToolResults = hydrateToolResults;
+exports.isGenAiSpan = isGenAiSpan;
+exports.lookupPrice = lookupPrice;
+exports.priceCall = priceCall;
+exports.toGenAiSpan = toGenAiSpan;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map