@ai-sdk/otel 1.0.0-beta.13 → 1.0.0-beta.131

package/dist/index.js

@@ -1,31 +1,1620 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+// src/open-telemetry.ts
+import {
+  context as context2,
+  SpanKind,
+  trace
+} from "@opentelemetry/api";
+
+// src/gen-ai-format-messages.ts
+import { convertDataContentToBase64String } from "ai";
+function mapProviderName(provider) {
+  const lower = provider.toLowerCase();
+  const wellKnownPrefixes = [
+    ["google.vertex", "gcp.vertex_ai"],
+    ["google.generative-ai", "gcp.gemini"],
+    ["google-vertex", "gcp.vertex_ai"],
+    ["amazon-bedrock", "aws.bedrock"],
+    ["azure-openai", "azure.ai.openai"],
+    ["anthropic", "anthropic"],
+    ["openai", "openai"],
+    ["azure", "azure.ai.inference"],
+    ["google", "gcp.gemini"],
+    ["mistral", "mistral_ai"],
+    ["cohere", "cohere"],
+    ["bedrock", "aws.bedrock"],
+    ["groq", "groq"],
+    ["deepseek", "deepseek"],
+    ["perplexity", "perplexity"],
+    ["xai", "x_ai"]
+  ];
+  for (const [prefix, mapped] of wellKnownPrefixes) {
+    if (lower === prefix || lower.startsWith(prefix + ".") || lower.startsWith(prefix + "-")) {
+      return mapped;
+    }
+  }
+  return provider;
+}
+function mapOperationName(operationId) {
+  var _a;
+  const mapping = {
+    "ai.generateText": "invoke_agent",
+    "ai.streamText": "invoke_agent",
+    "ai.generateObject": "invoke_agent",
+    "ai.streamObject": "invoke_agent",
+    "ai.embed": "embeddings",
+    "ai.embedMany": "embeddings",
+    "ai.rerank": "rerank"
+  };
+  return (_a = mapping[operationId]) != null ? _a : operationId;
+}
+function formatSystemInstructions(system) {
+  if (typeof system === "string") {
+    return [{ type: "text", content: system }];
+  }
+  if (Array.isArray(system)) {
+    return system.map((msg) => ({ type: "text", content: msg.content }));
+  }
+  return [{ type: "text", content: system.content }];
+}
+function convertMessagePartToSemConv(part) {
+  var _a, _b, _c, _d, _e;
+  switch (part.type) {
+    case "text":
+      return { type: "text", content: part.text };
+    case "reasoning":
+      return { type: "reasoning", content: part.text };
+    case "tool-call":
+      return {
+        type: "tool_call",
+        id: (_a = part.toolCallId) != null ? _a : null,
+        name: part.toolName,
+        arguments: part.input
+      };
+    case "tool-result": {
+      const output = part.output;
+      let response;
+      if (output) {
+        if (output.type === "text" || output.type === "error-text") {
+          response = output.value;
+        } else if (output.type === "json" || output.type === "error-json") {
+          response = output.value;
+        } else if (output.type === "execution-denied") {
+          response = { denied: true, reason: output.reason };
+        } else {
+          response = output;
+        }
+      }
+      return {
+        type: "tool_call_response",
+        id: (_b = part.toolCallId) != null ? _b : null,
+        response
+      };
+    }
+    case "file": {
+      const rawData = part.data;
+      const data = (() => {
+        if (typeof rawData === "object" && rawData !== null && !(rawData instanceof URL) && !(rawData instanceof Uint8Array) && !(rawData instanceof ArrayBuffer) && "type" in rawData) {
+          switch (rawData.type) {
+            case "data":
+              return rawData.data;
+            case "url":
+              return rawData.url;
+            case "text":
+              return rawData.text;
+            default:
+              return "";
+          }
+        }
+        return rawData;
+      })();
+      let content;
+      if (data instanceof Uint8Array) {
+        content = convertDataContentToBase64String(data);
+      } else if (typeof data === "string") {
+        if (data.startsWith("http://") || data.startsWith("https://")) {
+          return {
+            type: "uri",
+            modality: getModality(part.mediaType),
+            mime_type: (_c = part.mediaType) != null ? _c : null,
+            uri: data
+          };
+        }
+        content = data;
+      } else if (data instanceof URL) {
+        return {
+          type: "uri",
+          modality: getModality(part.mediaType),
+          mime_type: (_d = part.mediaType) != null ? _d : null,
+          uri: data.toString()
+        };
+      } else {
+        content = String(data);
+      }
+      return {
+        type: "blob",
+        modality: getModality(part.mediaType),
+        mime_type: (_e = part.mediaType) != null ? _e : null,
+        content
+      };
+    }
+    case "tool-approval-response":
+      return {
+        type: "tool_approval_response",
+        approval_id: part.approvalId,
+        approved: part.approved,
+        reason: part.reason
+      };
+    case "custom":
+      return { type: "custom", kind: part.kind };
+    case "reasoning-file":
+      return { type: String(part.type) };
+    default: {
+      const _exhaustive = part;
+      return { type: String(_exhaustive.type) };
+    }
+  }
+}
+function getModality(mediaType) {
+  if (!mediaType) return "image";
+  if (mediaType.startsWith("image/")) return "image";
+  if (mediaType.startsWith("video/")) return "video";
+  if (mediaType.startsWith("audio/")) return "audio";
+  return "image";
+}
+function formatInputMessages(prompt) {
+  return prompt.filter((msg) => msg.role !== "system").map((message) => {
+    if (message.role === "system") {
+      return {
+        role: "system",
+        parts: [{ type: "text", content: message.content }]
+      };
+    }
+    const parts = message.content.map(convertMessagePartToSemConv);
+    return { role: message.role, parts };
+  });
+}
+function formatModelMessages({
+  prompt,
+  messages
+}) {
+  const result = [];
+  if (typeof prompt === "string") {
+    result.push({
+      role: "user",
+      parts: [{ type: "text", content: prompt }]
+    });
+  } else if (Array.isArray(prompt)) {
+    for (const msg of prompt) {
+      const converted = convertModelMessageToSemConv(msg);
+      if (converted) result.push(converted);
+    }
+  }
+  if (messages) {
+    for (const msg of messages) {
+      const converted = convertModelMessageToSemConv(msg);
+      if (converted) result.push(converted);
+    }
+  }
+  return result;
+}
+function convertModelMessageToSemConv(msg) {
+  if (msg.role === "system") return void 0;
+  if (msg.role === "user") {
+    if (typeof msg.content === "string") {
+      return {
+        role: "user",
+        parts: [{ type: "text", content: msg.content }]
+      };
+    }
+    const parts = msg.content.map((part) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      switch (part.type) {
+        case "text":
+          return { type: "text", content: part.text };
+        case "image": {
+          const data = part.image;
+          if (data instanceof URL) {
+            return {
+              type: "uri",
+              modality: "image",
+              mime_type: (_a = part.mediaType) != null ? _a : null,
+              uri: data.toString()
+            };
+          }
+          if (typeof data === "string") {
+            if (data.startsWith("http://") || data.startsWith("https://")) {
+              return {
+                type: "uri",
+                modality: "image",
+                mime_type: (_b = part.mediaType) != null ? _b : null,
+                uri: data
+              };
+            }
+            return {
+              type: "blob",
+              modality: "image",
+              mime_type: (_c = part.mediaType) != null ? _c : null,
+              content: data
+            };
+          }
+          return {
+            type: "blob",
+            modality: "image",
+            mime_type: (_d = part.mediaType) != null ? _d : null,
+            content: convertDataContentToBase64String(data)
+          };
+        }
+        case "file": {
+          const rawData = part.data;
+          const data = (() => {
+            if (typeof rawData === "object" && rawData !== null && !(rawData instanceof URL) && !(rawData instanceof Uint8Array) && !(rawData instanceof ArrayBuffer) && "type" in rawData) {
+              switch (rawData.type) {
+                case "data":
+                  return rawData.data;
+                case "url":
+                  return rawData.url;
+                case "text":
+                  return rawData.text;
+                default:
+                  return "";
+              }
+            }
+            return rawData;
+          })();
+          if (data instanceof URL) {
+            return {
+              type: "uri",
+              modality: getModality(part.mediaType),
+              mime_type: (_e = part.mediaType) != null ? _e : null,
+              uri: data.toString()
+            };
+          }
+          if (typeof data === "string") {
+            if (data.startsWith("http://") || data.startsWith("https://")) {
+              return {
+                type: "uri",
+                modality: getModality(part.mediaType),
+                mime_type: (_f = part.mediaType) != null ? _f : null,
+                uri: data
+              };
+            }
+            return {
+              type: "blob",
+              modality: getModality(part.mediaType),
+              mime_type: (_g = part.mediaType) != null ? _g : null,
+              content: data
+            };
+          }
+          return {
+            type: "blob",
+            modality: getModality(part.mediaType),
+            mime_type: (_h = part.mediaType) != null ? _h : null,
+            content: convertDataContentToBase64String(data)
+          };
+        }
+        default:
+          return { type: String(part.type) };
+      }
+    });
+    return { role: "user", parts };
+  }
+  if (msg.role === "assistant") {
+    if (typeof msg.content === "string") {
+      return {
+        role: "assistant",
+        parts: [{ type: "text", content: msg.content }]
+      };
+    }
+    const parts = msg.content.map((part) => {
+      var _a, _b;
+      switch (part.type) {
+        case "text":
+          return { type: "text", content: part.text };
+        case "reasoning":
+          return { type: "reasoning", content: part.text };
+        case "tool-call":
+          return {
+            type: "tool_call",
+            id: (_a = part.toolCallId) != null ? _a : null,
+            name: part.toolName,
+            arguments: part.input
+          };
+        case "tool-result": {
+          const output = part.output;
+          let response;
+          if (output) {
+            if (output.type === "text" || output.type === "error-text") {
+              response = output.value;
+            } else if (output.type === "json" || output.type === "error-json") {
+              response = output.value;
+            } else if (output.type === "execution-denied") {
+              response = { denied: true, reason: output.reason };
+            } else {
+              response = output;
+            }
+          }
+          return {
+            type: "tool_call_response",
+            id: (_b = part.toolCallId) != null ? _b : null,
+            response
+          };
+        }
+        default:
+          return { type: String(part.type) };
+      }
+    });
+    return { role: "assistant", parts };
+  }
+  if (msg.role === "tool") {
+    const parts = msg.content.map((part) => {
+      var _a;
+      if (part.type === "tool-result") {
+        const output = part.output;
+        let response;
+        if (output) {
+          if (output.type === "text" || output.type === "error-text") {
+            response = output.value;
+          } else if (output.type === "json" || output.type === "error-json") {
+            response = output.value;
+          } else if (output.type === "execution-denied") {
+            response = { denied: true, reason: output.reason };
+          } else {
+            response = output;
+          }
+        }
+        return {
+          type: "tool_call_response",
+          id: (_a = part.toolCallId) != null ? _a : null,
+          response
+        };
+      }
+      return { type: String(part.type) };
+    });
+    return { role: "tool", parts };
+  }
+  return void 0;
+}
+function formatOutputMessages({
+  text,
+  reasoning,
+  toolCalls,
+  files,
+  finishReason
+}) {
+  const parts = [];
+  if (reasoning) {
+    for (const r of reasoning) {
+      if ("text" in r && r.text) {
+        parts.push({ type: "reasoning", content: r.text });
+      }
+    }
+  }
+  if (text != null && text.length > 0) {
+    parts.push({ type: "text", content: text });
+  }
+  if (toolCalls) {
+    for (const tc of toolCalls) {
+      parts.push({
+        type: "tool_call",
+        id: tc.toolCallId,
+        name: tc.toolName,
+        arguments: tc.input
+      });
+    }
+  }
+  if (files) {
+    for (const file of files) {
+      parts.push({
+        type: "blob",
+        modality: getModality(file.mediaType),
+        mime_type: file.mediaType,
+        content: file.base64
+      });
+    }
+  }
+  return [
+    {
+      role: "assistant",
+      parts,
+      finish_reason: mapFinishReason(finishReason)
+    }
+  ];
+}
+function formatObjectOutputMessages({
+  objectText,
+  finishReason
+}) {
+  return [
+    {
+      role: "assistant",
+      parts: [{ type: "text", content: objectText }],
+      finish_reason: mapFinishReason(finishReason)
+    }
+  ];
+}
+function mapFinishReason(reason) {
+  var _a;
+  const mapping = {
+    stop: "stop",
+    length: "length",
+    "content-filter": "content_filter",
+    "tool-calls": "tool_call",
+    error: "error",
+    other: "stop",
+    unknown: "stop"
+  };
+  return (_a = mapping[reason]) != null ? _a : reason;
+}
+
+// src/record-span.ts
+import {
+  SpanStatusCode,
+  context
+} from "@opentelemetry/api";
+function recordErrorOnSpan(span, error) {
+  if (error instanceof Error) {
+    span.recordException({
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    });
+    span.setStatus({
+      code: SpanStatusCode.ERROR,
+      message: error.message
+    });
+  } else {
+    span.setStatus({ code: SpanStatusCode.ERROR });
+  }
+}
+
+// src/sanitize-attribute-value.ts
+function isPrimitiveAttributeValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function sanitizeAttributeValue(value) {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  const primitiveTypes = new Set(
+    value.filter(isPrimitiveAttributeValue).map((item) => typeof item)
+  );
+  if (primitiveTypes.size !== 1) {
+    return void 0;
+  }
+  const [primitiveType] = primitiveTypes;
+  if (primitiveType === "string") {
+    return value.filter((item) => typeof item === "string");
+  }
+  if (primitiveType === "number") {
+    return value.filter((item) => typeof item === "number");
+  }
+  return value.filter((item) => typeof item === "boolean");
+}
+function sanitizeAttributes(attributes) {
+  const result = {};
+  for (const [key, value] of Object.entries(attributes != null ? attributes : {})) {
+    if (value == null) continue;
+    const sanitized = sanitizeAttributeValue(value);
+    if (sanitized != null) result[key] = sanitized;
+  }
+  return result;
+}
+
+// src/select-attributes.ts
+function shouldRecord(telemetry) {
+  return (telemetry == null ? void 0 : telemetry.isEnabled) !== false;
+}
+function selectAttributes(telemetry, attributes) {
+  if (!shouldRecord(telemetry)) {
+    return {};
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (value == null) continue;
+    if (typeof value === "object" && "input" in value && typeof value.input === "function") {
+      if ((telemetry == null ? void 0 : telemetry.recordInputs) === false) continue;
+      const resolved = value.input();
+      if (resolved != null) {
+        const sanitized2 = sanitizeAttributeValue(resolved);
+        if (sanitized2 != null) result[key] = sanitized2;
+      }
+      continue;
+    }
+    if (typeof value === "object" && "output" in value && typeof value.output === "function") {
+      if ((telemetry == null ? void 0 : telemetry.recordOutputs) === false) continue;
+      const resolved = value.output();
+      if (resolved != null) {
+        const sanitized2 = sanitizeAttributeValue(resolved);
+        if (sanitized2 != null) result[key] = sanitized2;
+      }
+      continue;
+    }
+    const sanitized = sanitizeAttributeValue(value);
+    if (sanitized != null) result[key] = sanitized;
+  }
+  return result;
+}
+
+// src/supplemental-attributes.ts
+var disabledSupplementalAttributes = {
+  usage: false,
+  providerMetadata: false,
+  embedding: false,
+  reranking: false,
+  runtimeContext: false,
+  headers: false,
+  toolChoice: false,
+  schema: false
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+function normalizeSupplementalAttributes(options) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  return {
+    ...disabledSupplementalAttributes,
+    usage: (_a = options.usage) != null ? _a : false,
+    providerMetadata: (_b = options.providerMetadata) != null ? _b : false,
+    embedding: (_c = options.embedding) != null ? _c : false,
+    reranking: (_d = options.reranking) != null ? _d : false,
+    runtimeContext: (_e = options.runtimeContext) != null ? _e : false,
+    headers: (_f = options.headers) != null ? _f : false,
+    toolChoice: (_g = options.toolChoice) != null ? _g : false,
+    schema: (_h = options.schema) != null ? _h : false
+  };
+}
+function getRuntimeContextAttributes(context4) {
+  const attributes = {};
+  for (const [key, value] of Object.entries(context4 != null ? context4 : {})) {
+    addRuntimeContextAttribute(attributes, `ai.settings.context.${key}`, value);
+  }
+  return attributes;
+}
+function addRuntimeContextAttribute(attributes, key, value) {
+  if (value == null) {
+    return;
+  }
+  if (Array.isArray(value) || typeof value !== "object") {
+    attributes[key] = value;
+    return;
+  }
+  for (const [nestedKey, nestedValue] of Object.entries(value)) {
+    addRuntimeContextAttribute(attributes, `${key}.${nestedKey}`, nestedValue);
+  }
+}
+function getHeaderAttributes(headers) {
+  return Object.fromEntries(
+    Object.entries(headers != null ? headers : {}).filter(([, value]) => value != null).map(([key, value]) => [`ai.request.headers.${key}`, value])
+  );
+}
+function getDetailedUsageAttributes(usage) {
+  var _a, _b, _c;
+  return {
+    "ai.usage.inputTokenDetails.noCacheTokens": (_a = usage.inputTokenDetails) == null ? void 0 : _a.noCacheTokens,
+    "ai.usage.outputTokenDetails.textTokens": (_b = usage.outputTokenDetails) == null ? void 0 : _b.textTokens,
+    "ai.usage.outputTokenDetails.reasoningTokens": (_c = usage.outputTokenDetails) == null ? void 0 : _c.reasoningTokens
+  };
+}
+function selectSupplementalAttributes(telemetry, enabledAttributes, attributes) {
+  const result = {};
+  for (const [key, value] of Object.entries(attributes)) {
+    if (!enabledAttributes[key] || value == null) {
+      continue;
+    }
+    Object.assign(result, selectAttributes(telemetry, value));
+  }
+  return result;
+}
+
+// src/open-telemetry.ts
+function msToSeconds(durationMs) {
+  return durationMs == null ? void 0 : durationMs / 1e3;
+}
+function getGenAIClientPerformanceAttributes(performance) {
+  var _a;
+  return {
+    "gen_ai.client.operation.duration": msToSeconds(performance.responseTimeMs),
+    "gen_ai.client.operation.time_to_first_chunk": msToSeconds(
+      performance.timeToFirstOutputMs
+    ),
+    "gen_ai.client.operation.time_per_output_chunk": msToSeconds(
+      (_a = performance.timeBetweenOutputChunksMs) == null ? void 0 : _a.avg
+    )
+  };
+}
+var OpenTelemetry = class {
+  constructor(options = {}) {
+    this.callStates = /* @__PURE__ */ new Map();
+    var _a;
+    this.tracer = (_a = options.tracer) != null ? _a : trace.getTracer("gen_ai");
+    this.supplementalAttributes = normalizeSupplementalAttributes(options);
+    this.enrichSpan = options.enrichSpan;
+  }
+  getCallState(callId) {
+    return this.callStates.get(callId);
+  }
+  cleanupCallState(callId) {
+    this.callStates.delete(callId);
+  }
+  getSpanAttributes({
+    attributes,
+    spanType,
+    operationId,
+    callId,
+    runtimeContext
+  }) {
+    var _a;
+    let customAttributes;
+    try {
+      customAttributes = (_a = this.enrichSpan) == null ? void 0 : _a.call(this, {
+        spanType,
+        operationId,
+        callId,
+        runtimeContext
+      });
+    } catch (e) {
+      customAttributes = void 0;
+    }
+    return {
+      ...sanitizeAttributes(customAttributes),
+      ...attributes
+    };
+  }
+  executeTool({
+    callId,
+    toolCallId,
+    execute
+  }) {
+    var _a;
+    const toolSpanEntry = (_a = this.getCallState(callId)) == null ? void 0 : _a.toolSpans.get(toolCallId);
+    if (toolSpanEntry == null) {
+      return execute();
+    }
+    return context2.with(toolSpanEntry.context, execute);
+  }
+  /**
+   * Runs the provider `doGenerate`/`doStream` call with the active model-call
+   * context.
+   */
+  executeLanguageModelCall({
+    callId,
+    execute
+  }) {
+    var _a;
+    const state = this.getCallState(callId);
+    const modelCallContext = (_a = state == null ? void 0 : state.inferenceContext) != null ? _a : state == null ? void 0 : state.stepContext;
+    if (modelCallContext == null) {
+      return execute();
+    }
+    return context2.with(modelCallContext, execute);
+  }
+  onStart(event) {
+    if (event.operationId === "ai.embed" || event.operationId === "ai.embedMany") {
+      this.onEmbedOperationStart(event);
+      return;
+    }
+    if (event.operationId === "ai.rerank") {
+      this.onRerankOperationStart(
+        event
+      );
+      return;
+    }
+    if (event.operationId === "ai.generateObject" || event.operationId === "ai.streamObject") {
+      this.onObjectOperationStart(
+        event
+      );
+      return;
+    }
+    this.onGenerateStart(event);
+  }
+  onGenerateStart(event) {
+    var _a;
+    const telemetry = {
+      recordInputs: event.recordInputs,
+      recordOutputs: event.recordOutputs,
+      functionId: event.functionId
+    };
+    const settings = {
+      maxOutputTokens: event.maxOutputTokens,
+      temperature: event.temperature,
+      topP: event.topP,
+      topK: event.topK,
+      presencePenalty: event.presencePenalty,
+      frequencyPenalty: event.frequencyPenalty,
+      stopSequences: event.stopSequences,
+      seed: event.seed,
+      maxRetries: event.maxRetries
+    };
+    const providerName = mapProviderName(event.provider);
+    const operationName = mapOperationName(event.operationId);
+    const runtimeContext = event.runtimeContext;
+    const baseSupplementalAttributes = selectSupplementalAttributes(
+      telemetry,
+      this.supplementalAttributes,
+      {
+        runtimeContext: getRuntimeContextAttributes(runtimeContext),
+        headers: getHeaderAttributes(event.headers)
+      }
+    );
+    const attributes = selectAttributes(telemetry, {
+      "gen_ai.operation.name": operationName,
+      "gen_ai.provider.name": providerName,
+      "gen_ai.request.model": event.modelId,
+      "gen_ai.agent.name": telemetry.functionId,
+      "gen_ai.request.frequency_penalty": event.frequencyPenalty,
+      "gen_ai.request.max_tokens": event.maxOutputTokens,
+      "gen_ai.request.presence_penalty": event.presencePenalty,
+      "gen_ai.request.temperature": (_a = event.temperature) != null ? _a : void 0,
+      "gen_ai.request.top_k": event.topK,
+      "gen_ai.request.top_p": event.topP,
+      "gen_ai.request.stop_sequences": event.stopSequences,
+      "gen_ai.request.seed": event.seed,
+      "gen_ai.system_instructions": event.instructions ? {
+        input: () => JSON.stringify(formatSystemInstructions(event.instructions))
+      } : void 0,
+      "gen_ai.input.messages": {
+        input: () => JSON.stringify(
+          formatModelMessages({
+            prompt: void 0,
+            messages: event.messages
+          })
+        )
+      },
+      ...baseSupplementalAttributes
+    });
+    const spanName = `${operationName} ${event.modelId}`;
+    const rootSpan = this.tracer.startSpan(spanName, {
+      attributes: this.getSpanAttributes({
+        attributes,
+        spanType: "operation",
+        operationId: event.operationId,
+        callId: event.callId,
+        runtimeContext
+      }),
+      kind: SpanKind.INTERNAL
+    });
+    const rootContext = trace.setSpan(context2.active(), rootSpan);
+    this.callStates.set(event.callId, {
+      operationId: event.operationId,
+      telemetry,
+      rootSpan,
+      rootContext,
+      stepSpan: void 0,
+      stepContext: void 0,
+      inferenceSpan: void 0,
+      inferenceContext: void 0,
+      embedSpans: /* @__PURE__ */ new Map(),
+      rerankSpan: void 0,
+      toolSpans: /* @__PURE__ */ new Map(),
+      settings,
+      provider: event.provider,
+      modelId: event.modelId,
+      runtimeContext,
+      baseSupplementalAttributes
+    });
+  }
+  onObjectOperationStart(event) {
+    var _a;
+    const telemetry = {
+      recordInputs: event.recordInputs,
+      recordOutputs: event.recordOutputs,
+      functionId: event.functionId
+    };
+    const settings = {
+      maxOutputTokens: event.maxOutputTokens,
+      temperature: event.temperature,
+      topP: event.topP,
+      topK: event.topK,
+      presencePenalty: event.presencePenalty,
+      frequencyPenalty: event.frequencyPenalty,
+      seed: event.seed,
+      maxRetries: event.maxRetries
+    };
+    const providerName = mapProviderName(event.provider);
+    const operationName = mapOperationName(event.operationId);
+    const baseSupplementalAttributes = selectSupplementalAttributes(
+      telemetry,
+      this.supplementalAttributes,
+      {
+        headers: getHeaderAttributes(event.headers)
+      }
+    );
+    const attributes = selectAttributes(telemetry, {
+      "gen_ai.operation.name": operationName,
+      "gen_ai.provider.name": providerName,
+      "gen_ai.request.model": event.modelId,
+      "gen_ai.agent.name": telemetry.functionId,
+      "gen_ai.output.type": "json",
+      "gen_ai.request.frequency_penalty": event.frequencyPenalty,
+      "gen_ai.request.max_tokens": event.maxOutputTokens,
+      "gen_ai.request.presence_penalty": event.presencePenalty,
+      "gen_ai.request.temperature": (_a = event.temperature) != null ? _a : void 0,
+      "gen_ai.request.top_k": event.topK,
+      "gen_ai.request.top_p": event.topP,
+      "gen_ai.request.seed": event.seed,
+      "gen_ai.system_instructions": event.system ? {
+        input: () => JSON.stringify(formatSystemInstructions(event.system))
+      } : void 0,
+      "gen_ai.input.messages": {
+        input: () => JSON.stringify(
+          formatModelMessages({
+            prompt: event.prompt,
+            messages: event.messages
+          })
+        )
+      },
+      ...baseSupplementalAttributes,
+      ...selectSupplementalAttributes(telemetry, this.supplementalAttributes, {
+        schema: {
+          "ai.schema": event.schema ? { input: () => JSON.stringify(event.schema) } : void 0,
+          "ai.schema.name": event.schemaName,
+          "ai.schema.description": event.schemaDescription,
+          "ai.settings.output": event.output
+        }
+      })
+    });
+    const spanName = `${operationName} ${event.modelId}`;
+    const rootSpan = this.tracer.startSpan(spanName, {
+      attributes: this.getSpanAttributes({
+        attributes,
+        spanType: "operation",
+        operationId: event.operationId,
+        callId: event.callId,
+        runtimeContext: void 0
+      }),
+      kind: SpanKind.INTERNAL
+    });
+    const rootContext = trace.setSpan(context2.active(), rootSpan);
+    this.callStates.set(event.callId, {
+      operationId: event.operationId,
+      telemetry,
+      rootSpan,
+      rootContext,
+      stepSpan: void 0,
+      stepContext: void 0,
+      inferenceSpan: void 0,
+      inferenceContext: void 0,
+      embedSpans: /* @__PURE__ */ new Map(),
+      rerankSpan: void 0,
+      toolSpans: /* @__PURE__ */ new Map(),
+      settings,
+      provider: event.provider,
+      modelId: event.modelId,
+      runtimeContext: void 0,
+      baseSupplementalAttributes
+    });
+  }
+  /** @deprecated */
+  onObjectStepStart(event) {
+    var _a;
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan) || !state.rootContext) return;
+    const { telemetry } = state;
+    const providerName = mapProviderName(event.provider);
+    const attributes = selectAttributes(telemetry, {
+      "gen_ai.operation.name": "chat",
+      "gen_ai.provider.name": providerName,
+      "gen_ai.request.model": event.modelId,
+      "gen_ai.output.type": "json",
+      "gen_ai.request.frequency_penalty": state.settings.frequencyPenalty,
+      "gen_ai.request.max_tokens": state.settings.maxOutputTokens,
+      "gen_ai.request.presence_penalty": state.settings.presencePenalty,
+      "gen_ai.request.temperature": (_a = state.settings.temperature) != null ? _a : void 0,
+      "gen_ai.request.top_k": state.settings.topK,
+      "gen_ai.request.top_p": state.settings.topP,
+      "gen_ai.input.messages": {
+        input: () => event.promptMessages ? JSON.stringify(formatInputMessages(event.promptMessages)) : void 0
+      },
+      ...state.baseSupplementalAttributes
+    });
+    const spanName = `chat ${event.modelId}`;
+    state.inferenceSpan = this.tracer.startSpan(
+      spanName,
+      {
+        attributes: this.getSpanAttributes({
+          attributes,
+          spanType: "languageModel",
+          operationId: state.operationId,
+          callId: event.callId,
+          runtimeContext: state.runtimeContext
+        }),
+        kind: SpanKind.CLIENT
+      },
+      state.rootContext
+    );
+    state.inferenceContext = trace.setSpan(
+      state.rootContext,
+      state.inferenceSpan
+    );
+  }
+  /** @deprecated */
+  onObjectStepEnd(event) {
+    var _a;
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.inferenceSpan)) return;
+    const { telemetry } = state;
+    state.inferenceSpan.setAttributes(
+      selectAttributes(telemetry, {
+        "gen_ai.response.finish_reasons": [event.finishReason],
+        "gen_ai.response.id": event.response.id,
+        "gen_ai.response.model": event.response.modelId,
+        "gen_ai.usage.input_tokens": event.usage.inputTokens,
+        "gen_ai.usage.output_tokens": event.usage.outputTokens,
+        "gen_ai.usage.cache_read.input_tokens": (_a = event.usage.inputTokenDetails) == null ? void 0 : _a.cacheReadTokens,
+        "gen_ai.output.messages": {
+          output: () => {
+            try {
+              return JSON.stringify(
+                formatObjectOutputMessages({
+                  objectText: event.objectText,
+                  finishReason: event.finishReason
+                })
+              );
+            } catch (e) {
+              return event.objectText;
+            }
+          }
+        },
+        ...selectSupplementalAttributes(
+          telemetry,
+          this.supplementalAttributes,
+          {
+            providerMetadata: {
+              "ai.response.providerMetadata": event.providerMetadata ? JSON.stringify(event.providerMetadata) : void 0
+            },
+            usage: getDetailedUsageAttributes(event.usage)
+          }
+        )
+      })
+    );
+    state.inferenceSpan.end();
+    state.inferenceSpan = void 0;
+    state.inferenceContext = void 0;
+  }
+  onEmbedOperationStart(event) {
+    const telemetry = {
+      recordInputs: event.recordInputs,
+      recordOutputs: event.recordOutputs,
+      functionId: event.functionId
+    };
+    const providerName = mapProviderName(event.provider);
+    const baseSupplementalAttributes = selectSupplementalAttributes(
+      telemetry,
+      this.supplementalAttributes,
+      {
+        headers: getHeaderAttributes(event.headers)
+      }
+    );
+    const value = event.value;
+    const isMany = event.operationId === "ai.embedMany";
+    const attributes = selectAttributes(telemetry, {
+      "gen_ai.operation.name": "embeddings",
+      "gen_ai.provider.name": providerName,
+      "gen_ai.request.model": event.modelId,
+      ...baseSupplementalAttributes,
+      ...selectSupplementalAttributes(telemetry, this.supplementalAttributes, {
+        embedding: isMany ? {
+          "ai.values": {
+            input: () => value.map((v) => JSON.stringify(v))
+          }
+        } : {
+          "ai.value": {
+            input: () => JSON.stringify(value)
+          }
+        }
+      })
+    });
+    const spanName = `embeddings ${event.modelId}`;
+    const rootSpan = this.tracer.startSpan(spanName, {
+      attributes: this.getSpanAttributes({
+        attributes,
+        spanType: "operation",
+        operationId: event.operationId,
+        callId: event.callId,
+        runtimeContext: void 0
+      }),
+      kind: SpanKind.CLIENT
+    });
+    const rootContext = trace.setSpan(context2.active(), rootSpan);
+    this.callStates.set(event.callId, {
+      operationId: event.operationId,
+      telemetry,
+      rootSpan,
+      rootContext,
+      stepSpan: void 0,
+      stepContext: void 0,
+      inferenceSpan: void 0,
+      inferenceContext: void 0,
+      embedSpans: /* @__PURE__ */ new Map(),
+      rerankSpan: void 0,
+      toolSpans: /* @__PURE__ */ new Map(),
+      settings: { maxRetries: event.maxRetries },
+      provider: event.provider,
+      modelId: event.modelId,
+      runtimeContext: void 0,
+      baseSupplementalAttributes
+    });
+  }
+  onStepStart(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan) || !state.rootContext) return;
+    const { telemetry } = state;
+    state.runtimeContext = event.runtimeContext;
+    const stepAttributes = selectAttributes(telemetry, {
+      "gen_ai.operation.name": "agent_step",
+      ...state.baseSupplementalAttributes,
+      ...selectSupplementalAttributes(telemetry, this.supplementalAttributes, {
+        toolChoice: {
+          "ai.prompt.toolChoice": {
+            input: () => event.stepToolChoice != null ? JSON.stringify(event.stepToolChoice) : void 0
+          }
+        }
+      })
+    });
+    state.stepSpan = this.tracer.startSpan(
+      `step ${event.steps.length + 1}`,
+      {
+        attributes: this.getSpanAttributes({
+          attributes: stepAttributes,
+          spanType: "step",
+          operationId: state.operationId,
+          callId: event.callId,
+          runtimeContext: state.runtimeContext
+        }),
+        kind: SpanKind.INTERNAL
+      },
+      state.rootContext
+    );
+    state.stepContext = trace.setSpan(state.rootContext, state.stepSpan);
+  }
+  onLanguageModelCallStart(event) {
+    var _a;
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.stepContext)) return;
+    const { telemetry } = state;
+    const providerName = mapProviderName(event.provider);
+    const inferenceAttributes = selectAttributes(telemetry, {
+      "gen_ai.operation.name": "chat",
+      "gen_ai.provider.name": providerName,
+      "gen_ai.request.model": event.modelId,
+      "gen_ai.request.frequency_penalty": state.settings.frequencyPenalty,
+      "gen_ai.request.max_tokens": state.settings.maxOutputTokens,
+      "gen_ai.request.presence_penalty": state.settings.presencePenalty,
+      "gen_ai.request.stop_sequences": state.settings.stopSequences,
+      "gen_ai.request.temperature": (_a = state.settings.temperature) != null ? _a : void 0,
+      "gen_ai.request.top_k": state.settings.topK,
+      "gen_ai.request.top_p": state.settings.topP,
+      "gen_ai.input.messages": {
+        input: () => {
+          const formattedMessages = formatModelMessages({
+            prompt: void 0,
+            messages: event.messages
+          });
+          return formattedMessages.length > 0 ? JSON.stringify(formattedMessages) : void 0;
+        }
+      },
+      "gen_ai.tool.definitions": {
+        input: () => event.tools ? JSON.stringify(event.tools) : void 0
+      }
+    });
+    state.inferenceSpan = this.tracer.startSpan(
+      `chat ${event.modelId}`,
+      {
+        attributes: this.getSpanAttributes({
+          attributes: inferenceAttributes,
+          spanType: "languageModel",
+          operationId: state.operationId,
+          callId: event.callId,
+          runtimeContext: state.runtimeContext
+        }),
+        kind: SpanKind.CLIENT
+      },
+      state.stepContext
+    );
+    state.inferenceContext = trace.setSpan(
+      state.stepContext,
+      state.inferenceSpan
+    );
+  }
+  onLanguageModelCallEnd(event) {
+    var _a, _b;
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.inferenceSpan)) return;
+    const { telemetry } = state;
+    state.inferenceSpan.setAttributes(
+      selectAttributes(telemetry, {
+        ...getGenAIClientPerformanceAttributes(event.performance),
+        "gen_ai.response.finish_reasons": [event.finishReason],
+        "gen_ai.response.id": event.responseId,
+        "gen_ai.usage.input_tokens": event.usage.inputTokens,
+        "gen_ai.usage.output_tokens": event.usage.outputTokens,
+        "gen_ai.usage.cache_read.input_tokens": (_a = event.usage.inputTokenDetails) == null ? void 0 : _a.cacheReadTokens,
+        "gen_ai.usage.cache_creation.input_tokens": (_b = event.usage.inputTokenDetails) == null ? void 0 : _b.cacheWriteTokens,
+        "gen_ai.output.messages": {
+          output: () => JSON.stringify(
+            formatOutputMessages({
+              text: event.content.filter((p) => p.type === "text").map((p) => p.text).join("") || void 0,
+              reasoning: event.content.filter((p) => p.type === "reasoning"),
+              toolCalls: event.content.filter((p) => p.type === "tool-call"),
+              files: event.content.filter((p) => p.type === "file").map((p) => p.file),
+              finishReason: event.finishReason
+            })
+          )
+        },
+        ...selectSupplementalAttributes(
+          telemetry,
+          this.supplementalAttributes,
+          {
+            usage: getDetailedUsageAttributes(event.usage)
+          }
+        )
+      })
+    );
+    state.inferenceSpan.end();
+    state.inferenceSpan = void 0;
+    state.inferenceContext = void 0;
+  }
+  onToolExecutionStart(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.stepContext)) return;
+    const { telemetry } = state;
+    const { toolCall } = event;
+    const attributes = selectAttributes(telemetry, {
+      "gen_ai.operation.name": "execute_tool",
+      "gen_ai.tool.name": toolCall.toolName,
+      "gen_ai.tool.call.id": toolCall.toolCallId,
+      "gen_ai.tool.type": "function",
+      "gen_ai.tool.call.arguments": {
+        input: () => JSON.stringify(toolCall.input)
+      }
+    });
+    const spanName = `execute_tool ${toolCall.toolName}`;
+    const toolSpan = this.tracer.startSpan(
+      spanName,
+      {
+        attributes: this.getSpanAttributes({
+          attributes,
+          spanType: "tool",
+          operationId: state.operationId,
+          callId: event.callId,
+          runtimeContext: state.runtimeContext
+        }),
+        kind: SpanKind.INTERNAL
+      },
+      state.stepContext
+    );
+    const toolContext = trace.setSpan(state.stepContext, toolSpan);
+    state.toolSpans.set(toolCall.toolCallId, {
+      span: toolSpan,
+      context: toolContext
+    });
+  }
+  onToolExecutionEnd(event) {
+    const state = this.getCallState(event.callId);
+    if (!state) return;
+    const toolSpanEntry = state.toolSpans.get(event.toolCall.toolCallId);
+    if (!toolSpanEntry) return;
+    const { span } = toolSpanEntry;
+    const { telemetry } = state;
+    const { toolOutput } = event;
+    span.setAttributes(
+      selectAttributes(telemetry, {
+        "gen_ai.execute_tool.duration": msToSeconds(event.toolExecutionMs)
+      })
+    );
+    if (toolOutput.type === "tool-result") {
+      try {
+        span.setAttributes(
+          selectAttributes(telemetry, {
+            "gen_ai.tool.call.result": {
+              output: () => JSON.stringify(toolOutput.output)
+            }
+          })
+        );
+      } catch (e) {
+      }
+    } else {
+      recordErrorOnSpan(span, toolOutput.error);
+    }
+    span.end();
+    state.toolSpans.delete(event.toolCall.toolCallId);
+  }
+  onStepEnd(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.stepSpan)) return;
+    const { telemetry } = state;
+    state.stepSpan.setAttributes(
+      selectSupplementalAttributes(telemetry, this.supplementalAttributes, {
+        providerMetadata: {
+          "ai.response.providerMetadata": event.providerMetadata ? JSON.stringify(event.providerMetadata) : void 0
+        },
+        usage: getDetailedUsageAttributes(event.usage)
+      })
+    );
+    state.stepSpan.end();
+    state.stepSpan = void 0;
+    state.stepContext = void 0;
+  }
+  /** @deprecated Use `onStepEnd` instead. */
+  onStepFinish(event) {
+    this.onStepEnd(event);
+  }
+  onEnd(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan)) return;
+    if (state.operationId === "ai.embed" || state.operationId === "ai.embedMany") {
+      this.onEmbedOperationEnd(event);
+      return;
+    }
+    if (state.operationId === "ai.rerank") {
+      this.onRerankOperationEnd(event);
+      return;
+    }
+    if (state.operationId === "ai.generateObject" || state.operationId === "ai.streamObject") {
+      this.onObjectOperationEnd(event);
+      return;
+    }
+    this.onGenerateEnd(event);
+  }
+  onGenerateEnd(event) {
+    var _a, _b;
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan)) return;
+    const { telemetry } = state;
+    state.rootSpan.setAttributes(
+      selectAttributes(telemetry, {
+        "gen_ai.response.finish_reasons": [event.finishReason],
+        "gen_ai.usage.input_tokens": event.usage.inputTokens,
+        "gen_ai.usage.output_tokens": event.usage.outputTokens,
+        "gen_ai.usage.cache_read.input_tokens": (_a = event.usage.inputTokenDetails) == null ? void 0 : _a.cacheReadTokens,
+        "gen_ai.usage.cache_creation.input_tokens": (_b = event.usage.inputTokenDetails) == null ? void 0 : _b.cacheWriteTokens,
+        "gen_ai.output.messages": {
+          output: () => {
+            var _a2;
+            return JSON.stringify(
+              formatOutputMessages({
+                text: (_a2 = event.text) != null ? _a2 : void 0,
+                reasoning: event.finalStep.reasoning,
+                toolCalls: event.toolCalls,
+                files: event.files,
+                finishReason: event.finishReason
+              })
+            );
+          }
+        },
+        ...selectSupplementalAttributes(
+          telemetry,
+          this.supplementalAttributes,
+          {
+            providerMetadata: {
+              "ai.response.providerMetadata": event.finalStep.providerMetadata ? JSON.stringify(event.finalStep.providerMetadata) : void 0
+            },
+            usage: getDetailedUsageAttributes(event.usage)
+          }
+        )
+      })
+    );
+    state.rootSpan.end();
+    this.cleanupCallState(event.callId);
+  }
+  onObjectOperationEnd(event) {
+    var _a;
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan)) return;
+    const { telemetry } = state;
+    state.rootSpan.setAttributes(
+      selectAttributes(telemetry, {
+        "gen_ai.response.finish_reasons": [event.finishReason],
+        "gen_ai.usage.input_tokens": event.usage.inputTokens,
+        "gen_ai.usage.output_tokens": event.usage.outputTokens,
+        "gen_ai.usage.cache_read.input_tokens": (_a = event.usage.inputTokenDetails) == null ? void 0 : _a.cacheReadTokens,
+        "gen_ai.output.messages": {
+          output: () => event.object != null ? JSON.stringify(
+            formatObjectOutputMessages({
+              objectText: JSON.stringify(event.object),
+              finishReason: event.finishReason
+            })
+          ) : void 0
+        },
+        ...selectSupplementalAttributes(
+          telemetry,
+          this.supplementalAttributes,
+          {
+            providerMetadata: {
+              "ai.response.providerMetadata": event.providerMetadata ? JSON.stringify(event.providerMetadata) : void 0
+            },
+            usage: getDetailedUsageAttributes(event.usage)
+          }
+        )
+      })
+    );
+    state.rootSpan.end();
+    this.cleanupCallState(event.callId);
+  }
+  onEmbedOperationEnd(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan)) return;
+    const { telemetry } = state;
+    const isMany = state.operationId === "ai.embedMany";
+    state.rootSpan.setAttributes(
+      selectAttributes(telemetry, {
+        "gen_ai.usage.input_tokens": event.usage.tokens,
+        ...selectSupplementalAttributes(
+          telemetry,
+          this.supplementalAttributes,
+          {
+            embedding: isMany ? {
+              "ai.embeddings": {
+                output: () => event.embedding.map(
+                  (e) => JSON.stringify(e)
+                )
+              }
+            } : {
+              "ai.embedding": {
+                output: () => JSON.stringify(event.embedding)
+              }
+            }
+          }
+        )
+      })
+    );
+    state.rootSpan.end();
+    this.cleanupCallState(event.callId);
+  }
+  onEmbedStart(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan) || !state.rootContext) return;
+    const { telemetry } = state;
+    const providerName = mapProviderName(state.provider);
+    const attributes = selectAttributes(telemetry, {
+      "gen_ai.operation.name": "embeddings",
+      "gen_ai.provider.name": providerName,
+      "gen_ai.request.model": state.modelId,
+      ...state.baseSupplementalAttributes,
+      ...selectSupplementalAttributes(telemetry, this.supplementalAttributes, {
+        embedding: {
+          "ai.values": {
+            input: () => event.values.map((v) => JSON.stringify(v))
+          }
+        }
+      })
+    });
+    const spanName = `embeddings ${state.modelId}`;
+    const embedSpan = this.tracer.startSpan(
+      spanName,
+      {
+        attributes: this.getSpanAttributes({
+          attributes,
+          spanType: "embedding",
+          operationId: state.operationId,
+          callId: event.callId,
+          runtimeContext: state.runtimeContext
+        }),
+        kind: SpanKind.CLIENT
+      },
+      state.rootContext
+    );
+    const embedContext = trace.setSpan(state.rootContext, embedSpan);
+    state.embedSpans.set(event.embedCallId, {
+      span: embedSpan,
+      context: embedContext
+    });
+  }
+  onEmbedEnd(event) {
+    const state = this.getCallState(event.callId);
+    if (!state) return;
+    const embedSpanEntry = state.embedSpans.get(event.embedCallId);
+    if (!embedSpanEntry) return;
+    const { span } = embedSpanEntry;
+    const { telemetry } = state;
+    span.setAttributes(
+      selectAttributes(telemetry, {
+        "gen_ai.usage.input_tokens": event.usage.tokens,
+        ...selectSupplementalAttributes(
+          telemetry,
+          this.supplementalAttributes,
+          {
+            embedding: {
+              "ai.embeddings": {
+                output: () => event.embeddings.map((embedding) => JSON.stringify(embedding))
+              }
+            }
+          }
+        )
+      })
+    );
+    span.end();
+    state.embedSpans.delete(event.embedCallId);
+  }
+  onRerankOperationStart(event) {
+    const telemetry = {
+      recordInputs: event.recordInputs,
+      recordOutputs: event.recordOutputs,
+      functionId: event.functionId
+    };
+    const providerName = mapProviderName(event.provider);
+    const baseSupplementalAttributes = selectSupplementalAttributes(
+      telemetry,
+      this.supplementalAttributes,
+      {
+        headers: getHeaderAttributes(event.headers)
+      }
+    );
+    const attributes = selectAttributes(telemetry, {
+      "gen_ai.operation.name": "rerank",
+      "gen_ai.provider.name": providerName,
+      "gen_ai.request.model": event.modelId,
+      ...baseSupplementalAttributes,
+      ...selectSupplementalAttributes(telemetry, this.supplementalAttributes, {
+        reranking: {
+          "ai.documents": {
+            input: () => event.documents.map((d) => JSON.stringify(d))
+          }
+        }
+      })
+    });
+    const spanName = `rerank ${event.modelId}`;
+    const rootSpan = this.tracer.startSpan(spanName, {
+      attributes: this.getSpanAttributes({
+        attributes,
+        spanType: "operation",
+        operationId: event.operationId,
+        callId: event.callId,
+        runtimeContext: void 0
+      }),
+      kind: SpanKind.CLIENT
+    });
+    const rootContext = trace.setSpan(context2.active(), rootSpan);
+    this.callStates.set(event.callId, {
+      operationId: event.operationId,
+      telemetry,
+      rootSpan,
+      rootContext,
+      stepSpan: void 0,
+      stepContext: void 0,
+      inferenceSpan: void 0,
+      inferenceContext: void 0,
+      embedSpans: /* @__PURE__ */ new Map(),
+      rerankSpan: void 0,
+      toolSpans: /* @__PURE__ */ new Map(),
+      settings: { maxRetries: event.maxRetries },
+      provider: event.provider,
+      modelId: event.modelId,
+      runtimeContext: void 0,
+      baseSupplementalAttributes
+    });
+  }
+  onRerankOperationEnd(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan)) return;
+    state.rootSpan.end();
+    this.cleanupCallState(event.callId);
+  }
+  onRerankStart(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan) || !state.rootContext) return;
+    const { telemetry } = state;
+    const providerName = mapProviderName(state.provider);
+    const attributes = selectAttributes(telemetry, {
+      "gen_ai.operation.name": "rerank",
+      "gen_ai.provider.name": providerName,
+      "gen_ai.request.model": state.modelId,
+      ...state.baseSupplementalAttributes,
+      ...selectSupplementalAttributes(telemetry, this.supplementalAttributes, {
+        reranking: {
+          "ai.documents": {
+            input: () => event.documents.map((d) => JSON.stringify(d))
+          }
+        }
+      })
+    });
+    const spanName = `rerank ${state.modelId}`;
+    const rerankSpan = this.tracer.startSpan(
+      spanName,
+      {
+        attributes: this.getSpanAttributes({
+          attributes,
+          spanType: "reranking",
+          operationId: state.operationId,
+          callId: event.callId,
+          runtimeContext: state.runtimeContext
+        }),
+        kind: SpanKind.CLIENT
+      },
+      state.rootContext
+    );
+    const rerankContext = trace.setSpan(state.rootContext, rerankSpan);
+    state.rerankSpan = { span: rerankSpan, context: rerankContext };
+  }
+  onRerankEnd(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rerankSpan)) return;
+    const { span } = state.rerankSpan;
+    const { telemetry } = state;
+    span.setAttributes(
+      selectSupplementalAttributes(telemetry, this.supplementalAttributes, {
+        reranking: {
+          "ai.ranking.type": event.documentsType,
+          "ai.ranking": {
+            output: () => event.ranking.map((r) => JSON.stringify(r))
+          }
+        }
+      })
+    );
+    span.end();
+    state.rerankSpan = void 0;
+  }
+  onAbort(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan)) return;
+    for (const { span: toolSpan } of state.toolSpans.values()) {
+      toolSpan.end();
+    }
+    state.toolSpans.clear();
+    if (state.inferenceSpan) {
+      state.inferenceSpan.end();
+      state.inferenceSpan = void 0;
+      state.inferenceContext = void 0;
+    }
+    if (state.stepSpan) {
+      state.stepSpan.end();
+      state.stepSpan = void 0;
+      state.stepContext = void 0;
+    }
+    for (const { span: embedSpan } of state.embedSpans.values()) {
+      embedSpan.end();
+    }
+    state.embedSpans.clear();
+    if (state.rerankSpan) {
+      state.rerankSpan.span.end();
+      state.rerankSpan = void 0;
+    }
+    state.rootSpan.end();
+    this.cleanupCallState(event.callId);
+  }
+  onError(error) {
+    var _a;
+    const event = error;
+    if (!(event == null ? void 0 : event.callId)) return;
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan)) return;
+    const actualError = (_a = event.error) != null ? _a : error;
+    for (const { span: toolSpan } of state.toolSpans.values()) {
+      recordErrorOnSpan(toolSpan, actualError);
+      toolSpan.end();
+    }
+    state.toolSpans.clear();
+    if (state.inferenceSpan) {
+      recordErrorOnSpan(state.inferenceSpan, actualError);
+      state.inferenceSpan.end();
+      state.inferenceSpan = void 0;
+      state.inferenceContext = void 0;
+    }
+    if (state.stepSpan) {
+      recordErrorOnSpan(state.stepSpan, actualError);
+      state.stepSpan.end();
+      state.stepSpan = void 0;
+      state.stepContext = void 0;
+    }
+    for (const { span: embedSpan } of state.embedSpans.values()) {
+      recordErrorOnSpan(embedSpan, actualError);
+      embedSpan.end();
+    }
+    state.embedSpans.clear();
+    if (state.rerankSpan) {
+      recordErrorOnSpan(state.rerankSpan.span, actualError);
+      state.rerankSpan.span.end();
+      state.rerankSpan = void 0;
+    }
+    recordErrorOnSpan(state.rootSpan, actualError);
+    state.rootSpan.end();
+    this.cleanupCallState(event.callId);
   }
-  return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  OpenTelemetryIntegration: () => OpenTelemetryIntegration
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/open-telemetry-integration.ts
-var import_api = require("@opentelemetry/api");
+// src/legacy-open-telemetry.ts
+import {
+  context as context3,
+  SpanStatusCode as SpanStatusCode2,
+  trace as trace2
+} from "@opentelemetry/api";
 
 // src/assemble-operation-name.ts
 function assembleOperationName({
@@ -46,10 +1635,9 @@ function assembleOperationName({
 function getBaseTelemetryAttributes({
   model,
   settings,
-  telemetry,
-  headers
+  headers,
+  context: context4
 }) {
-  var _a;
   return {
     "ai.model.provider": model.provider,
     "ai.model.id": model.modelId,
@@ -58,16 +1646,8 @@ function getBaseTelemetryAttributes({
       attributes[`ai.settings.${key}`] = value;
       return attributes;
     }, {}),
-    // add metadata as attributes:
-    ...Object.entries((_a = telemetry == null ? void 0 : telemetry.metadata) != null ? _a : {}).reduce(
-      (attributes, [key, value]) => {
-        if (value != void 0) {
-          attributes[`ai.telemetry.metadata.${key}`] = value;
-        }
-        return attributes;
-      },
-      {}
-    ),
+    // add context as attributes:
+    ...getRuntimeContextAttributes(context4),
     // request headers
     ...Object.entries(headers != null ? headers : {}).reduce((attributes, [key, value]) => {
       if (value !== void 0) {
@@ -79,7 +1659,7 @@ function getBaseTelemetryAttributes({
 }
 
 // src/stringify-for-telemetry.ts
-var import_ai = require("ai");
+import { convertDataContentToBase64String as convertDataContentToBase64String2 } from "ai";
 function stringifyForTelemetry(prompt) {
   return JSON.stringify(
     prompt.map((message) => ({
@@ -87,14 +1667,26 @@ function stringifyForTelemetry(prompt) {
       content: typeof message.content === "string" ? message.content : message.content.map(
         (part) => part.type === "file" ? {
           ...part,
-          data: part.data instanceof Uint8Array ? (0, import_ai.convertDataContentToBase64String)(part.data) : part.data
+          data: serializeFileData(part.data)
         } : part
       )
     }))
   );
 }
+function serializeFileData(data) {
+  switch (data.type) {
+    case "data":
+      return data.data instanceof Uint8Array ? convertDataContentToBase64String2(data.data) : data.data;
+    case "url":
+      return data.url.toString();
+    case "reference":
+      return data.reference;
+    case "text":
+      return data.text;
+  }
+}
 
-// src/open-telemetry-integration.ts
+// src/legacy-open-telemetry.ts
 function recordSpanError(span, error) {
   if (error instanceof Error) {
     span.recordException({
@@ -103,18 +1695,18 @@ function recordSpanError(span, error) {
       stack: error.stack
     });
     span.setStatus({
-      code: import_api.SpanStatusCode.ERROR,
+      code: SpanStatusCode2.ERROR,
       message: error.message
     });
   } else {
-    span.setStatus({ code: import_api.SpanStatusCode.ERROR });
+    span.setStatus({ code: SpanStatusCode2.ERROR });
   }
 }
-function shouldRecord(telemetry) {
-  return (telemetry == null ? void 0 : telemetry.isEnabled) === true;
+function shouldRecord2(telemetry) {
+  return (telemetry == null ? void 0 : telemetry.isEnabled) !== false;
 }
-function selectAttributes(telemetry, attributes) {
-  if (!shouldRecord(telemetry)) {
+function selectAttributes2(telemetry, attributes) {
+  if (!shouldRecord2(telemetry)) {
     return {};
   }
   const result = {};
@@ -123,24 +1715,31 @@ function selectAttributes(telemetry, attributes) {
     if (typeof value === "object" && "input" in value && typeof value.input === "function") {
       if ((telemetry == null ? void 0 : telemetry.recordInputs) === false) continue;
       const resolved = value.input();
-      if (resolved != null) result[key] = resolved;
+      if (resolved != null) {
+        const sanitized2 = sanitizeAttributeValue(resolved);
+        if (sanitized2 != null) result[key] = sanitized2;
+      }
       continue;
     }
     if (typeof value === "object" && "output" in value && typeof value.output === "function") {
       if ((telemetry == null ? void 0 : telemetry.recordOutputs) === false) continue;
       const resolved = value.output();
-      if (resolved != null) result[key] = resolved;
+      if (resolved != null) {
+        const sanitized2 = sanitizeAttributeValue(resolved);
+        if (sanitized2 != null) result[key] = sanitized2;
+      }
       continue;
     }
-    result[key] = value;
+    const sanitized = sanitizeAttributeValue(value);
+    if (sanitized != null) result[key] = sanitized;
   }
   return result;
 }
-var OpenTelemetryIntegration = class {
+var LegacyOpenTelemetry = class {
   constructor(options = {}) {
     this.callStates = /* @__PURE__ */ new Map();
     var _a;
-    this.tracer = (_a = options.tracer) != null ? _a : import_api.trace.getTracer("ai");
+    this.tracer = (_a = options.tracer) != null ? _a : trace2.getTracer("ai");
   }
   getCallState(callId) {
     return this.callStates.get(callId);
@@ -158,31 +1757,47 @@ var OpenTelemetryIntegration = class {
     if (toolSpanEntry == null) {
       return execute();
     }
-    return import_api.context.with(toolSpanEntry.context, execute);
+    return context3.with(toolSpanEntry.context, execute);
+  }
+  /**
+   * Runs the provider `doGenerate`/`doStream` call with the active legacy
+   * model-call context.
+   */
+  executeLanguageModelCall({
+    callId,
+    execute
+  }) {
+    var _a;
+    const stepContext = (_a = this.getCallState(callId)) == null ? void 0 : _a.stepContext;
+    if (stepContext == null) {
+      return execute();
+    }
+    return context3.with(stepContext, execute);
   }
   onStart(event) {
-    if (event.isEnabled !== true) return;
     if (event.operationId === "ai.embed" || event.operationId === "ai.embedMany") {
       this.onEmbedOperationStart(event);
       return;
     }
     if (event.operationId === "ai.rerank") {
-      this.onRerankOperationStart(event);
+      this.onRerankOperationStart(
+        event
+      );
       return;
     }
     if (event.operationId === "ai.generateObject" || event.operationId === "ai.streamObject") {
-      this.onObjectOperationStart(event);
+      this.onObjectOperationStart(
+        event
+      );
       return;
     }
     this.onGenerateStart(event);
   }
   onGenerateStart(event) {
     const telemetry = {
-      isEnabled: event.isEnabled,
       recordInputs: event.recordInputs,
       recordOutputs: event.recordOutputs,
-      functionId: event.functionId,
-      metadata: event.metadata
+      functionId: event.functionId
     };
     const settings = {
       maxOutputTokens: event.maxOutputTokens,
@@ -197,11 +1812,11 @@ var OpenTelemetryIntegration = class {
     };
     const baseTelemetryAttributes = getBaseTelemetryAttributes({
       model: { provider: event.provider, modelId: event.modelId },
-      telemetry,
       headers: event.headers,
-      settings
+      settings,
+      context: event.runtimeContext
     });
-    const attributes = selectAttributes(telemetry, {
+    const attributes = selectAttributes2(telemetry, {
       ...assembleOperationName({
         operationId: event.operationId,
         telemetry
@@ -211,14 +1826,13 @@ var OpenTelemetryIntegration = class {
       "ai.model.id": event.modelId,
       "ai.prompt": {
         input: () => JSON.stringify({
-          system: event.system,
-          prompt: event.prompt,
+          system: event.instructions,
           messages: event.messages
         })
       }
     });
     const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
-    const rootContext = import_api.trace.setSpan(import_api.context.active(), rootSpan);
+    const rootContext = trace2.setSpan(context3.active(), rootSpan);
     this.callStates.set(event.callId, {
       operationId: event.operationId,
       telemetry,
@@ -235,11 +1849,9 @@ var OpenTelemetryIntegration = class {
   }
   onObjectOperationStart(event) {
     const telemetry = {
-      isEnabled: event.isEnabled,
       recordInputs: event.recordInputs,
       recordOutputs: event.recordOutputs,
-      functionId: event.functionId,
-      metadata: event.metadata
+      functionId: event.functionId
     };
     const settings = {
       maxOutputTokens: event.maxOutputTokens,
@@ -253,11 +1865,11 @@ var OpenTelemetryIntegration = class {
     };
     const baseTelemetryAttributes = getBaseTelemetryAttributes({
       model: { provider: event.provider, modelId: event.modelId },
-      telemetry,
       headers: event.headers,
-      settings
+      settings,
+      context: void 0
     });
-    const attributes = selectAttributes(telemetry, {
+    const attributes = selectAttributes2(telemetry, {
       ...assembleOperationName({
         operationId: event.operationId,
         telemetry
@@ -276,7 +1888,7 @@ var OpenTelemetryIntegration = class {
       "ai.settings.output": event.output
     });
     const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
-    const rootContext = import_api.trace.setSpan(import_api.context.active(), rootSpan);
+    const rootContext = trace2.setSpan(context3.active(), rootSpan);
     this.callStates.set(event.callId, {
       operationId: event.operationId,
       telemetry,
@@ -298,7 +1910,7 @@ var OpenTelemetryIntegration = class {
     if (!(state == null ? void 0 : state.rootSpan) || !state.rootContext) return;
     const { telemetry } = state;
     const stepOperationId = state.operationId === "ai.streamObject" ? "ai.streamObject.doStream" : "ai.generateObject.doGenerate";
-    const attributes = selectAttributes(telemetry, {
+    const attributes = selectAttributes2(telemetry, {
       ...assembleOperationName({
         operationId: stepOperationId,
         telemetry
@@ -321,15 +1933,16 @@ var OpenTelemetryIntegration = class {
       { attributes },
       state.rootContext
     );
-    state.stepContext = import_api.trace.setSpan(state.rootContext, state.stepSpan);
+    state.stepContext = trace2.setSpan(state.rootContext, state.stepSpan);
   }
   /** @deprecated */
-  onObjectStepFinish(event) {
+  onObjectStepEnd(event) {
+    var _a, _b;
     const state = this.getCallState(event.callId);
     if (!(state == null ? void 0 : state.stepSpan)) return;
     const { telemetry } = state;
     state.stepSpan.setAttributes(
-      selectAttributes(telemetry, {
+      selectAttributes2(telemetry, {
         "ai.response.finishReason": event.finishReason,
         "ai.response.object": {
           output: () => {
@@ -347,8 +1960,8 @@ var OpenTelemetryIntegration = class {
         "ai.usage.inputTokens": event.usage.inputTokens,
         "ai.usage.outputTokens": event.usage.outputTokens,
         "ai.usage.totalTokens": event.usage.totalTokens,
-        "ai.usage.reasoningTokens": event.usage.reasoningTokens,
-        "ai.usage.cachedInputTokens": event.usage.cachedInputTokens,
+        "ai.usage.reasoningTokens": (_a = event.usage.outputTokenDetails) == null ? void 0 : _a.reasoningTokens,
+        "ai.usage.cachedInputTokens": (_b = event.usage.inputTokenDetails) == null ? void 0 : _b.cacheReadTokens,
         "gen_ai.response.finish_reasons": [event.finishReason],
         "gen_ai.response.id": event.response.id,
         "gen_ai.response.model": event.response.modelId,
@@ -370,24 +1983,22 @@ var OpenTelemetryIntegration = class {
   }
   onEmbedOperationStart(event) {
     const telemetry = {
-      isEnabled: event.isEnabled,
       recordInputs: event.recordInputs,
       recordOutputs: event.recordOutputs,
-      functionId: event.functionId,
-      metadata: event.metadata
+      functionId: event.functionId
     };
     const settings = {
       maxRetries: event.maxRetries
     };
     const baseTelemetryAttributes = getBaseTelemetryAttributes({
       model: { provider: event.provider, modelId: event.modelId },
-      telemetry,
       headers: event.headers,
-      settings
+      settings,
+      context: void 0
     });
     const value = event.value;
     const isMany = event.operationId === "ai.embedMany";
-    const attributes = selectAttributes(telemetry, {
+    const attributes = selectAttributes2(telemetry, {
       ...assembleOperationName({
         operationId: event.operationId,
         telemetry
@@ -404,7 +2015,7 @@ var OpenTelemetryIntegration = class {
       }
     });
     const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
-    const rootContext = import_api.trace.setSpan(import_api.context.active(), rootSpan);
+    const rootContext = trace2.setSpan(context3.active(), rootSpan);
     this.callStates.set(event.callId, {
       operationId: event.operationId,
       telemetry,
@@ -425,7 +2036,7 @@ var OpenTelemetryIntegration = class {
     if (!(state == null ? void 0 : state.rootSpan) || !state.rootContext) return;
     const { telemetry } = state;
     const stepOperationId = state.operationId === "ai.streamText" ? "ai.streamText.doStream" : "ai.generateText.doGenerate";
-    const attributes = selectAttributes(telemetry, {
+    const attributes = selectAttributes2(telemetry, {
       ...assembleOperationName({
         operationId: stepOperationId,
         telemetry
@@ -460,14 +2071,14 @@ var OpenTelemetryIntegration = class {
       { attributes },
       state.rootContext
     );
-    state.stepContext = import_api.trace.setSpan(state.rootContext, state.stepSpan);
+    state.stepContext = trace2.setSpan(state.rootContext, state.stepSpan);
   }
-  onToolCallStart(event) {
+  onToolExecutionStart(event) {
     const state = this.getCallState(event.callId);
     if (!(state == null ? void 0 : state.stepContext)) return;
     const { telemetry } = state;
     const { toolCall } = event;
-    const attributes = selectAttributes(telemetry, {
+    const attributes = selectAttributes2(telemetry, {
       ...assembleOperationName({
         operationId: "ai.toolCall",
         telemetry
@@ -483,43 +2094,45 @@ var OpenTelemetryIntegration = class {
       { attributes },
       state.stepContext
     );
-    const toolContext = import_api.trace.setSpan(state.stepContext, toolSpan);
+    const toolContext = trace2.setSpan(state.stepContext, toolSpan);
     state.toolSpans.set(toolCall.toolCallId, {
       span: toolSpan,
       context: toolContext
     });
   }
-  onToolCallFinish(event) {
+  onToolExecutionEnd(event) {
     const state = this.getCallState(event.callId);
     if (!state) return;
     const toolSpanEntry = state.toolSpans.get(event.toolCall.toolCallId);
     if (!toolSpanEntry) return;
     const { span } = toolSpanEntry;
     const { telemetry } = state;
-    if (event.success) {
+    const { toolOutput } = event;
+    if (toolOutput.type === "tool-result") {
       try {
         span.setAttributes(
-          selectAttributes(telemetry, {
+          selectAttributes2(telemetry, {
             "ai.toolCall.result": {
-              output: () => JSON.stringify(event.output)
+              output: () => JSON.stringify(toolOutput.output)
             }
           })
         );
-      } catch (_ignored) {
+      } catch (e) {
       }
     } else {
-      recordSpanError(span, event.error);
+      recordSpanError(span, toolOutput.error);
     }
     span.end();
     state.toolSpans.delete(event.toolCall.toolCallId);
   }
-  onStepFinish(event) {
-    var _a, _b, _c, _d, _e;
+  onStepEnd(event) {
+    var _a, _b, _c, _d, _e, _f, _g;
     const state = this.getCallState(event.callId);
     if (!(state == null ? void 0 : state.stepSpan)) return;
     const { telemetry } = state;
+    const isStreamText = state.operationId === "ai.streamText";
     state.stepSpan.setAttributes(
-      selectAttributes(telemetry, {
+      selectAttributes2(telemetry, {
         "ai.response.finishReason": event.finishReason,
         "ai.response.text": {
           output: () => {
@@ -552,16 +2165,19 @@ var OpenTelemetryIntegration = class {
         "ai.response.model": event.response.modelId,
         "ai.response.timestamp": event.response.timestamp.toISOString(),
         "ai.response.providerMetadata": event.providerMetadata ? JSON.stringify(event.providerMetadata) : void 0,
+        "ai.response.msToFirstChunk": isStreamText ? event.performance.timeToFirstOutputMs : void 0,
+        "ai.response.msToFinish": isStreamText ? event.performance.responseTimeMs : void 0,
+        "ai.response.avgOutputTokensPerSecond": isStreamText ? event.performance.effectiveOutputTokensPerSecond : void 0,
         "ai.usage.inputTokens": event.usage.inputTokens,
         "ai.usage.outputTokens": event.usage.outputTokens,
         "ai.usage.totalTokens": event.usage.totalTokens,
-        "ai.usage.reasoningTokens": event.usage.reasoningTokens,
-        "ai.usage.cachedInputTokens": event.usage.cachedInputTokens,
-        "ai.usage.inputTokenDetails.noCacheTokens": (_a = event.usage.inputTokenDetails) == null ? void 0 : _a.noCacheTokens,
-        "ai.usage.inputTokenDetails.cacheReadTokens": (_b = event.usage.inputTokenDetails) == null ? void 0 : _b.cacheReadTokens,
-        "ai.usage.inputTokenDetails.cacheWriteTokens": (_c = event.usage.inputTokenDetails) == null ? void 0 : _c.cacheWriteTokens,
-        "ai.usage.outputTokenDetails.textTokens": (_d = event.usage.outputTokenDetails) == null ? void 0 : _d.textTokens,
-        "ai.usage.outputTokenDetails.reasoningTokens": (_e = event.usage.outputTokenDetails) == null ? void 0 : _e.reasoningTokens,
+        "ai.usage.reasoningTokens": (_a = event.usage.outputTokenDetails) == null ? void 0 : _a.reasoningTokens,
+        "ai.usage.cachedInputTokens": (_b = event.usage.inputTokenDetails) == null ? void 0 : _b.cacheReadTokens,
+        "ai.usage.inputTokenDetails.noCacheTokens": (_c = event.usage.inputTokenDetails) == null ? void 0 : _c.noCacheTokens,
+        "ai.usage.inputTokenDetails.cacheReadTokens": (_d = event.usage.inputTokenDetails) == null ? void 0 : _d.cacheReadTokens,
+        "ai.usage.inputTokenDetails.cacheWriteTokens": (_e = event.usage.inputTokenDetails) == null ? void 0 : _e.cacheWriteTokens,
+        "ai.usage.outputTokenDetails.textTokens": (_f = event.usage.outputTokenDetails) == null ? void 0 : _f.textTokens,
+        "ai.usage.outputTokenDetails.reasoningTokens": (_g = event.usage.outputTokenDetails) == null ? void 0 : _g.reasoningTokens,
         "gen_ai.response.finish_reasons": [event.finishReason],
         "gen_ai.response.id": event.response.id,
         "gen_ai.response.model": event.response.modelId,
@@ -569,34 +2185,49 @@ var OpenTelemetryIntegration = class {
         "gen_ai.usage.output_tokens": event.usage.outputTokens
       })
     );
+    if (isStreamText && event.performance.timeToFirstOutputMs != null) {
+      state.stepSpan.addEvent("ai.stream.firstChunk", {
+        "ai.response.msToFirstChunk": event.performance.timeToFirstOutputMs
+      });
+    }
+    if (isStreamText) {
+      state.stepSpan.addEvent("ai.stream.finish", {
+        "ai.response.msToFinish": event.performance.responseTimeMs,
+        "ai.response.avgOutputTokensPerSecond": event.performance.effectiveOutputTokensPerSecond
+      });
+    }
     state.stepSpan.end();
     state.stepSpan = void 0;
     state.stepContext = void 0;
   }
-  onFinish(event) {
+  /** @deprecated Use `onStepEnd` instead. */
+  onStepFinish(event) {
+    this.onStepEnd(event);
+  }
+  onEnd(event) {
     const state = this.getCallState(event.callId);
     if (!(state == null ? void 0 : state.rootSpan)) return;
     if (state.operationId === "ai.embed" || state.operationId === "ai.embedMany") {
-      this.onEmbedOperationFinish(event);
+      this.onEmbedOperationEnd(event);
       return;
     }
     if (state.operationId === "ai.rerank") {
-      this.onRerankOperationFinish(event);
+      this.onRerankOperationEnd(event);
       return;
     }
     if (state.operationId === "ai.generateObject" || state.operationId === "ai.streamObject") {
-      this.onObjectOperationFinish(event);
+      this.onObjectOperationEnd(event);
       return;
     }
-    this.onGenerateFinish(event);
+    this.onGenerateEnd(event);
   }
-  onGenerateFinish(event) {
-    var _a, _b, _c, _d, _e;
+  onGenerateEnd(event) {
+    var _a, _b, _c, _d, _e, _f, _g;
     const state = this.getCallState(event.callId);
     if (!(state == null ? void 0 : state.rootSpan)) return;
     const { telemetry } = state;
     state.rootSpan.setAttributes(
-      selectAttributes(telemetry, {
+      selectAttributes2(telemetry, {
         "ai.response.finishReason": event.finishReason,
         "ai.response.text": {
           output: () => {
@@ -605,7 +2236,7 @@ var OpenTelemetryIntegration = class {
           }
         },
         "ai.response.reasoning": {
-          output: () => event.reasoning.length > 0 ? event.reasoning.filter((part) => "text" in part).map((part) => part.text).join("\n") : void 0
+          output: () => event.finalStep.reasoning.length > 0 ? event.finalStep.reasoning.filter((part) => "text" in part).map((part) => part.text).join("\n") : void 0
         },
         "ai.response.toolCalls": {
           output: () => event.toolCalls.length > 0 ? JSON.stringify(
@@ -625,28 +2256,29 @@ var OpenTelemetryIntegration = class {
             }))
           ) : void 0
         },
-        "ai.response.providerMetadata": event.providerMetadata ? JSON.stringify(event.providerMetadata) : void 0,
-        "ai.usage.inputTokens": event.totalUsage.inputTokens,
-        "ai.usage.outputTokens": event.totalUsage.outputTokens,
-        "ai.usage.totalTokens": event.totalUsage.totalTokens,
-        "ai.usage.reasoningTokens": event.totalUsage.reasoningTokens,
-        "ai.usage.cachedInputTokens": event.totalUsage.cachedInputTokens,
-        "ai.usage.inputTokenDetails.noCacheTokens": (_a = event.totalUsage.inputTokenDetails) == null ? void 0 : _a.noCacheTokens,
-        "ai.usage.inputTokenDetails.cacheReadTokens": (_b = event.totalUsage.inputTokenDetails) == null ? void 0 : _b.cacheReadTokens,
-        "ai.usage.inputTokenDetails.cacheWriteTokens": (_c = event.totalUsage.inputTokenDetails) == null ? void 0 : _c.cacheWriteTokens,
-        "ai.usage.outputTokenDetails.textTokens": (_d = event.totalUsage.outputTokenDetails) == null ? void 0 : _d.textTokens,
-        "ai.usage.outputTokenDetails.reasoningTokens": (_e = event.totalUsage.outputTokenDetails) == null ? void 0 : _e.reasoningTokens
+        "ai.response.providerMetadata": event.finalStep.providerMetadata ? JSON.stringify(event.finalStep.providerMetadata) : void 0,
+        "ai.usage.inputTokens": event.usage.inputTokens,
+        "ai.usage.outputTokens": event.usage.outputTokens,
+        "ai.usage.totalTokens": event.usage.totalTokens,
+        "ai.usage.reasoningTokens": (_a = event.usage.outputTokenDetails) == null ? void 0 : _a.reasoningTokens,
+        "ai.usage.cachedInputTokens": (_b = event.usage.inputTokenDetails) == null ? void 0 : _b.cacheReadTokens,
+        "ai.usage.inputTokenDetails.noCacheTokens": (_c = event.usage.inputTokenDetails) == null ? void 0 : _c.noCacheTokens,
+        "ai.usage.inputTokenDetails.cacheReadTokens": (_d = event.usage.inputTokenDetails) == null ? void 0 : _d.cacheReadTokens,
+        "ai.usage.inputTokenDetails.cacheWriteTokens": (_e = event.usage.inputTokenDetails) == null ? void 0 : _e.cacheWriteTokens,
+        "ai.usage.outputTokenDetails.textTokens": (_f = event.usage.outputTokenDetails) == null ? void 0 : _f.textTokens,
+        "ai.usage.outputTokenDetails.reasoningTokens": (_g = event.usage.outputTokenDetails) == null ? void 0 : _g.reasoningTokens
       })
     );
     state.rootSpan.end();
     this.cleanupCallState(event.callId);
   }
-  onObjectOperationFinish(event) {
+  onObjectOperationEnd(event) {
+    var _a, _b;
     const state = this.getCallState(event.callId);
     if (!(state == null ? void 0 : state.rootSpan)) return;
     const { telemetry } = state;
     state.rootSpan.setAttributes(
-      selectAttributes(telemetry, {
+      selectAttributes2(telemetry, {
         "ai.response.finishReason": event.finishReason,
         "ai.response.object": {
           output: () => event.object != null ? JSON.stringify(event.object) : void 0
@@ -655,20 +2287,20 @@ var OpenTelemetryIntegration = class {
         "ai.usage.inputTokens": event.usage.inputTokens,
         "ai.usage.outputTokens": event.usage.outputTokens,
         "ai.usage.totalTokens": event.usage.totalTokens,
-        "ai.usage.reasoningTokens": event.usage.reasoningTokens,
-        "ai.usage.cachedInputTokens": event.usage.cachedInputTokens
+        "ai.usage.reasoningTokens": (_a = event.usage.outputTokenDetails) == null ? void 0 : _a.reasoningTokens,
+        "ai.usage.cachedInputTokens": (_b = event.usage.inputTokenDetails) == null ? void 0 : _b.cacheReadTokens
       })
     );
     state.rootSpan.end();
     this.cleanupCallState(event.callId);
   }
-  onEmbedOperationFinish(event) {
+  onEmbedOperationEnd(event) {
     const state = this.getCallState(event.callId);
     if (!(state == null ? void 0 : state.rootSpan)) return;
     const { telemetry } = state;
     const isMany = state.operationId === "ai.embedMany";
     state.rootSpan.setAttributes(
-      selectAttributes(telemetry, {
+      selectAttributes2(telemetry, {
         ...isMany ? {
           "ai.embeddings": {
             output: () => event.embedding.map((e) => JSON.stringify(e))
@@ -688,7 +2320,7 @@ var OpenTelemetryIntegration = class {
     const state = this.getCallState(event.callId);
     if (!(state == null ? void 0 : state.rootSpan) || !state.rootContext) return;
     const { telemetry } = state;
-    const attributes = selectAttributes(telemetry, {
+    const attributes = selectAttributes2(telemetry, {
       ...assembleOperationName({
         operationId: event.operationId,
         telemetry
@@ -703,13 +2335,13 @@ var OpenTelemetryIntegration = class {
       { attributes },
       state.rootContext
     );
-    const embedContext = import_api.trace.setSpan(state.rootContext, embedSpan);
+    const embedContext = trace2.setSpan(state.rootContext, embedSpan);
     state.embedSpans.set(event.embedCallId, {
       span: embedSpan,
       context: embedContext
     });
   }
-  onEmbedFinish(event) {
+  onEmbedEnd(event) {
     const state = this.getCallState(event.callId);
     if (!state) return;
     const embedSpanEntry = state.embedSpans.get(event.embedCallId);
@@ -717,7 +2349,7 @@ var OpenTelemetryIntegration = class {
     const { span } = embedSpanEntry;
     const { telemetry } = state;
     span.setAttributes(
-      selectAttributes(telemetry, {
+      selectAttributes2(telemetry, {
         "ai.embeddings": {
           output: () => event.embeddings.map((embedding) => JSON.stringify(embedding))
         },
@@ -729,22 +2361,20 @@ var OpenTelemetryIntegration = class {
   }
   onRerankOperationStart(event) {
     const telemetry = {
-      isEnabled: event.isEnabled,
       recordInputs: event.recordInputs,
       recordOutputs: event.recordOutputs,
-      functionId: event.functionId,
-      metadata: event.metadata
+      functionId: event.functionId
     };
     const settings = {
       maxRetries: event.maxRetries
     };
     const baseTelemetryAttributes = getBaseTelemetryAttributes({
       model: { provider: event.provider, modelId: event.modelId },
-      telemetry,
       headers: event.headers,
-      settings
+      settings,
+      context: void 0
     });
-    const attributes = selectAttributes(telemetry, {
+    const attributes = selectAttributes2(telemetry, {
       ...assembleOperationName({
         operationId: event.operationId,
         telemetry
@@ -755,7 +2385,7 @@ var OpenTelemetryIntegration = class {
       }
     });
     const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
-    const rootContext = import_api.trace.setSpan(import_api.context.active(), rootSpan);
+    const rootContext = trace2.setSpan(context3.active(), rootSpan);
     this.callStates.set(event.callId, {
       operationId: event.operationId,
       telemetry,
@@ -770,7 +2400,7 @@ var OpenTelemetryIntegration = class {
       settings
     });
   }
-  onRerankOperationFinish(event) {
+  onRerankOperationEnd(event) {
     const state = this.getCallState(event.callId);
     if (!(state == null ? void 0 : state.rootSpan)) return;
     state.rootSpan.end();
@@ -780,7 +2410,7 @@ var OpenTelemetryIntegration = class {
     const state = this.getCallState(event.callId);
     if (!(state == null ? void 0 : state.rootSpan) || !state.rootContext) return;
     const { telemetry } = state;
-    const attributes = selectAttributes(telemetry, {
+    const attributes = selectAttributes2(telemetry, {
       ...assembleOperationName({
         operationId: event.operationId,
         telemetry
@@ -795,16 +2425,16 @@ var OpenTelemetryIntegration = class {
       { attributes },
       state.rootContext
     );
-    const rerankContext = import_api.trace.setSpan(state.rootContext, rerankSpan);
+    const rerankContext = trace2.setSpan(state.rootContext, rerankSpan);
     state.rerankSpan = { span: rerankSpan, context: rerankContext };
   }
-  onRerankFinish(event) {
+  onRerankEnd(event) {
     const state = this.getCallState(event.callId);
     if (!(state == null ? void 0 : state.rerankSpan)) return;
     const { span } = state.rerankSpan;
     const { telemetry } = state;
     span.setAttributes(
-      selectAttributes(telemetry, {
+      selectAttributes2(telemetry, {
         "ai.ranking.type": event.documentsType,
         "ai.ranking": {
           output: () => event.ranking.map((r) => JSON.stringify(r))
@@ -814,26 +2444,28 @@ var OpenTelemetryIntegration = class {
     span.end();
     state.rerankSpan = void 0;
   }
-  onChunk(event) {
-    var _a;
-    const chunk = event.chunk;
-    if (typeof chunk.callId !== "string") {
-      return;
+  onAbort(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan)) return;
+    for (const { span: toolSpan } of state.toolSpans.values()) {
+      toolSpan.end();
     }
-    if (chunk.type !== "ai.stream.firstChunk" && chunk.type !== "ai.stream.finish") {
-      return;
+    state.toolSpans.clear();
+    if (state.stepSpan) {
+      state.stepSpan.end();
+      state.stepSpan = void 0;
+      state.stepContext = void 0;
     }
-    const state = this.getCallState(chunk.callId);
-    if (!(state == null ? void 0 : state.stepSpan)) return;
-    const attributes = Object.fromEntries(
-      Object.entries(
-        (_a = chunk.attributes) != null ? _a : {}
-      ).filter(([, value]) => value != null)
-    );
-    state.stepSpan.addEvent(chunk.type, attributes);
-    if (Object.keys(attributes).length > 0) {
-      state.stepSpan.setAttributes(attributes);
+    for (const { span: embedSpan } of state.embedSpans.values()) {
+      embedSpan.end();
     }
+    state.embedSpans.clear();
+    if (state.rerankSpan) {
+      state.rerankSpan.span.end();
+      state.rerankSpan = void 0;
+    }
+    state.rootSpan.end();
+    this.cleanupCallState(event.callId);
   }
   onError(error) {
     var _a;
@@ -861,8 +2493,8 @@ var OpenTelemetryIntegration = class {
     this.cleanupCallState(event.callId);
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  OpenTelemetryIntegration
-});
+export {
+  LegacyOpenTelemetry,
+  OpenTelemetry
+};
 //# sourceMappingURL=index.js.map