@ai-sdk/otel 0.0.0-6b196531-20260710185421

package/dist/index.js

@@ -0,0 +1,2500 @@
+// 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
+};
+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);
+  }
+};
+
+// 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({
+  operationId,
+  telemetry
+}) {
+  return {
+    // standardized operation and resource name:
+    "operation.name": `${operationId}${(telemetry == null ? void 0 : telemetry.functionId) != null ? ` ${telemetry.functionId}` : ""}`,
+    "resource.name": telemetry == null ? void 0 : telemetry.functionId,
+    // detailed, AI SDK specific data:
+    "ai.operationId": operationId,
+    "ai.telemetry.functionId": telemetry == null ? void 0 : telemetry.functionId
+  };
+}
+
+// src/get-base-telemetry-attributes.ts
+function getBaseTelemetryAttributes({
+  model,
+  settings,
+  headers,
+  context: context4
+}) {
+  return {
+    "ai.model.provider": model.provider,
+    "ai.model.id": model.modelId,
+    // settings:
+    ...Object.entries(settings).reduce((attributes, [key, value]) => {
+      attributes[`ai.settings.${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) {
+        attributes[`ai.request.headers.${key}`] = value;
+      }
+      return attributes;
+    }, {})
+  };
+}
+
+// src/stringify-for-telemetry.ts
+import { convertDataContentToBase64String as convertDataContentToBase64String2 } from "ai";
+function stringifyForTelemetry(prompt) {
+  return JSON.stringify(
+    prompt.map((message) => ({
+      ...message,
+      content: typeof message.content === "string" ? message.content : message.content.map(
+        (part) => part.type === "file" ? {
+          ...part,
+          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/legacy-open-telemetry.ts
+function recordSpanError(span, error) {
+  if (error instanceof Error) {
+    span.recordException({
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    });
+    span.setStatus({
+      code: SpanStatusCode2.ERROR,
+      message: error.message
+    });
+  } else {
+    span.setStatus({ code: SpanStatusCode2.ERROR });
+  }
+}
+function shouldRecord2(telemetry) {
+  return (telemetry == null ? void 0 : telemetry.isEnabled) !== false;
+}
+function selectAttributes2(telemetry, attributes) {
+  if (!shouldRecord2(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;
+}
+var LegacyOpenTelemetry = class {
+  constructor(options = {}) {
+    this.callStates = /* @__PURE__ */ new Map();
+    var _a;
+    this.tracer = (_a = options.tracer) != null ? _a : trace2.getTracer("ai");
+  }
+  getCallState(callId) {
+    return this.callStates.get(callId);
+  }
+  cleanupCallState(callId) {
+    this.callStates.delete(callId);
+  }
+  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 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.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) {
+    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 baseTelemetryAttributes = getBaseTelemetryAttributes({
+      model: { provider: event.provider, modelId: event.modelId },
+      headers: event.headers,
+      settings,
+      context: event.runtimeContext
+    });
+    const attributes = selectAttributes2(telemetry, {
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry
+      }),
+      ...baseTelemetryAttributes,
+      "ai.model.provider": event.provider,
+      "ai.model.id": event.modelId,
+      "ai.prompt": {
+        input: () => JSON.stringify({
+          system: event.instructions,
+          messages: event.messages
+        })
+      }
+    });
+    const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
+    const rootContext = trace2.setSpan(context3.active(), rootSpan);
+    this.callStates.set(event.callId, {
+      operationId: event.operationId,
+      telemetry,
+      rootSpan,
+      rootContext,
+      stepSpan: void 0,
+      stepContext: void 0,
+      embedSpans: /* @__PURE__ */ new Map(),
+      rerankSpan: void 0,
+      toolSpans: /* @__PURE__ */ new Map(),
+      baseTelemetryAttributes,
+      settings
+    });
+  }
+  onObjectOperationStart(event) {
+    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 baseTelemetryAttributes = getBaseTelemetryAttributes({
+      model: { provider: event.provider, modelId: event.modelId },
+      headers: event.headers,
+      settings,
+      context: void 0
+    });
+    const attributes = selectAttributes2(telemetry, {
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry
+      }),
+      ...baseTelemetryAttributes,
+      "ai.prompt": {
+        input: () => JSON.stringify({
+          system: event.system,
+          prompt: event.prompt,
+          messages: event.messages
+        })
+      },
+      "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 rootSpan = this.tracer.startSpan(event.operationId, { attributes });
+    const rootContext = trace2.setSpan(context3.active(), rootSpan);
+    this.callStates.set(event.callId, {
+      operationId: event.operationId,
+      telemetry,
+      rootSpan,
+      rootContext,
+      stepSpan: void 0,
+      stepContext: void 0,
+      embedSpans: /* @__PURE__ */ new Map(),
+      rerankSpan: void 0,
+      toolSpans: /* @__PURE__ */ new Map(),
+      baseTelemetryAttributes,
+      settings
+    });
+  }
+  /** @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 stepOperationId = state.operationId === "ai.streamObject" ? "ai.streamObject.doStream" : "ai.generateObject.doGenerate";
+    const attributes = selectAttributes2(telemetry, {
+      ...assembleOperationName({
+        operationId: stepOperationId,
+        telemetry
+      }),
+      ...state.baseTelemetryAttributes,
+      "ai.prompt.messages": {
+        input: () => event.promptMessages ? stringifyForTelemetry(event.promptMessages) : void 0
+      },
+      "gen_ai.system": event.provider,
+      "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.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
+    });
+    state.stepSpan = this.tracer.startSpan(
+      stepOperationId,
+      { attributes },
+      state.rootContext
+    );
+    state.stepContext = trace2.setSpan(state.rootContext, state.stepSpan);
+  }
+  /** @deprecated */
+  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(
+      selectAttributes2(telemetry, {
+        "ai.response.finishReason": event.finishReason,
+        "ai.response.object": {
+          output: () => {
+            try {
+              return JSON.stringify(JSON.parse(event.objectText));
+            } catch (e) {
+              return event.objectText;
+            }
+          }
+        },
+        "ai.response.id": event.response.id,
+        "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.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,
+        "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
+      })
+    );
+    if (event.msToFirstChunk != null) {
+      state.stepSpan.addEvent("ai.stream.firstChunk", {
+        "ai.stream.msToFirstChunk": event.msToFirstChunk
+      });
+      state.stepSpan.setAttributes({
+        "ai.stream.msToFirstChunk": event.msToFirstChunk
+      });
+    }
+    state.stepSpan.end();
+    state.stepSpan = void 0;
+    state.stepContext = void 0;
+  }
+  onEmbedOperationStart(event) {
+    const telemetry = {
+      recordInputs: event.recordInputs,
+      recordOutputs: event.recordOutputs,
+      functionId: event.functionId
+    };
+    const settings = {
+      maxRetries: event.maxRetries
+    };
+    const baseTelemetryAttributes = getBaseTelemetryAttributes({
+      model: { provider: event.provider, modelId: event.modelId },
+      headers: event.headers,
+      settings,
+      context: void 0
+    });
+    const value = event.value;
+    const isMany = event.operationId === "ai.embedMany";
+    const attributes = selectAttributes2(telemetry, {
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry
+      }),
+      ...baseTelemetryAttributes,
+      ...isMany ? {
+        "ai.values": {
+          input: () => value.map((v) => JSON.stringify(v))
+        }
+      } : {
+        "ai.value": {
+          input: () => JSON.stringify(value)
+        }
+      }
+    });
+    const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
+    const rootContext = trace2.setSpan(context3.active(), rootSpan);
+    this.callStates.set(event.callId, {
+      operationId: event.operationId,
+      telemetry,
+      rootSpan,
+      rootContext,
+      stepSpan: void 0,
+      stepContext: void 0,
+      embedSpans: /* @__PURE__ */ new Map(),
+      rerankSpan: void 0,
+      toolSpans: /* @__PURE__ */ new Map(),
+      baseTelemetryAttributes,
+      settings
+    });
+  }
+  onStepStart(event) {
+    var _a;
+    const state = this.getCallState(event.callId);
+    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 = selectAttributes2(telemetry, {
+      ...assembleOperationName({
+        operationId: stepOperationId,
+        telemetry
+      }),
+      ...state.baseTelemetryAttributes,
+      "ai.model.provider": event.provider,
+      "ai.model.id": event.modelId,
+      "ai.prompt.messages": {
+        input: () => event.promptMessages ? stringifyForTelemetry(event.promptMessages) : void 0
+      },
+      "ai.prompt.tools": {
+        input: () => {
+          var _a2;
+          return (_a2 = event.stepTools) == null ? void 0 : _a2.map((tool) => JSON.stringify(tool));
+        }
+      },
+      "ai.prompt.toolChoice": {
+        input: () => event.stepToolChoice != null ? JSON.stringify(event.stepToolChoice) : void 0
+      },
+      "gen_ai.system": event.provider,
+      "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
+    });
+    state.stepSpan = this.tracer.startSpan(
+      stepOperationId,
+      { attributes },
+      state.rootContext
+    );
+    state.stepContext = trace2.setSpan(state.rootContext, state.stepSpan);
+  }
+  onToolExecutionStart(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.stepContext)) return;
+    const { telemetry } = state;
+    const { toolCall } = event;
+    const attributes = selectAttributes2(telemetry, {
+      ...assembleOperationName({
+        operationId: "ai.toolCall",
+        telemetry
+      }),
+      "ai.toolCall.name": toolCall.toolName,
+      "ai.toolCall.id": toolCall.toolCallId,
+      "ai.toolCall.args": {
+        output: () => JSON.stringify(toolCall.input)
+      }
+    });
+    const toolSpan = this.tracer.startSpan(
+      "ai.toolCall",
+      { attributes },
+      state.stepContext
+    );
+    const toolContext = trace2.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;
+    if (toolOutput.type === "tool-result") {
+      try {
+        span.setAttributes(
+          selectAttributes2(telemetry, {
+            "ai.toolCall.result": {
+              output: () => JSON.stringify(toolOutput.output)
+            }
+          })
+        );
+      } catch (e) {
+      }
+    } else {
+      recordSpanError(span, toolOutput.error);
+    }
+    span.end();
+    state.toolSpans.delete(event.toolCall.toolCallId);
+  }
+  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(
+      selectAttributes2(telemetry, {
+        "ai.response.finishReason": event.finishReason,
+        "ai.response.text": {
+          output: () => {
+            var _a2;
+            return (_a2 = event.text) != null ? _a2 : void 0;
+          }
+        },
+        "ai.response.reasoning": {
+          output: () => event.reasoning.length > 0 ? event.reasoning.filter((part) => "text" in part).map((part) => part.text).join("\n") : void 0
+        },
+        "ai.response.toolCalls": {
+          output: () => event.toolCalls.length > 0 ? JSON.stringify(
+            event.toolCalls.map((toolCall) => ({
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              input: toolCall.input
+            }))
+          ) : void 0
+        },
+        "ai.response.files": {
+          output: () => event.files.length > 0 ? JSON.stringify(
+            event.files.map((file) => ({
+              type: "file",
+              mediaType: file.mediaType,
+              data: file.base64
+            }))
+          ) : void 0
+        },
+        "ai.response.id": event.response.id,
+        "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": (_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,
+        "gen_ai.usage.input_tokens": event.usage.inputTokens,
+        "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;
+  }
+  /** @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, _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(
+      selectAttributes2(telemetry, {
+        "ai.response.finishReason": event.finishReason,
+        "ai.response.text": {
+          output: () => {
+            var _a2;
+            return (_a2 = event.text) != null ? _a2 : void 0;
+          }
+        },
+        "ai.response.reasoning": {
+          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(
+            event.toolCalls.map((toolCall) => ({
+              toolCallId: toolCall.toolCallId,
+              toolName: toolCall.toolName,
+              input: toolCall.input
+            }))
+          ) : void 0
+        },
+        "ai.response.files": {
+          output: () => event.files.length > 0 ? JSON.stringify(
+            event.files.map((file) => ({
+              type: "file",
+              mediaType: file.mediaType,
+              data: file.base64
+            }))
+          ) : void 0
+        },
+        "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);
+  }
+  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(
+      selectAttributes2(telemetry, {
+        "ai.response.finishReason": event.finishReason,
+        "ai.response.object": {
+          output: () => event.object != null ? JSON.stringify(event.object) : void 0
+        },
+        "ai.response.providerMetadata": event.providerMetadata ? JSON.stringify(event.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
+      })
+    );
+    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(
+      selectAttributes2(telemetry, {
+        ...isMany ? {
+          "ai.embeddings": {
+            output: () => event.embedding.map((e) => JSON.stringify(e))
+          }
+        } : {
+          "ai.embedding": {
+            output: () => JSON.stringify(event.embedding)
+          }
+        },
+        "ai.usage.tokens": event.usage.tokens
+      })
+    );
+    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 attributes = selectAttributes2(telemetry, {
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry
+      }),
+      ...state.baseTelemetryAttributes,
+      "ai.values": {
+        input: () => event.values.map((v) => JSON.stringify(v))
+      }
+    });
+    const embedSpan = this.tracer.startSpan(
+      event.operationId,
+      { attributes },
+      state.rootContext
+    );
+    const embedContext = trace2.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(
+      selectAttributes2(telemetry, {
+        "ai.embeddings": {
+          output: () => event.embeddings.map((embedding) => JSON.stringify(embedding))
+        },
+        "ai.usage.tokens": event.usage.tokens
+      })
+    );
+    span.end();
+    state.embedSpans.delete(event.embedCallId);
+  }
+  onRerankOperationStart(event) {
+    const telemetry = {
+      recordInputs: event.recordInputs,
+      recordOutputs: event.recordOutputs,
+      functionId: event.functionId
+    };
+    const settings = {
+      maxRetries: event.maxRetries
+    };
+    const baseTelemetryAttributes = getBaseTelemetryAttributes({
+      model: { provider: event.provider, modelId: event.modelId },
+      headers: event.headers,
+      settings,
+      context: void 0
+    });
+    const attributes = selectAttributes2(telemetry, {
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry
+      }),
+      ...baseTelemetryAttributes,
+      "ai.documents": {
+        input: () => event.documents.map((d) => JSON.stringify(d))
+      }
+    });
+    const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
+    const rootContext = trace2.setSpan(context3.active(), rootSpan);
+    this.callStates.set(event.callId, {
+      operationId: event.operationId,
+      telemetry,
+      rootSpan,
+      rootContext,
+      stepSpan: void 0,
+      stepContext: void 0,
+      embedSpans: /* @__PURE__ */ new Map(),
+      rerankSpan: void 0,
+      toolSpans: /* @__PURE__ */ new Map(),
+      baseTelemetryAttributes,
+      settings
+    });
+  }
+  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 attributes = selectAttributes2(telemetry, {
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry
+      }),
+      ...state.baseTelemetryAttributes,
+      "ai.documents": {
+        input: () => event.documents.map((d) => JSON.stringify(d))
+      }
+    });
+    const rerankSpan = this.tracer.startSpan(
+      event.operationId,
+      { attributes },
+      state.rootContext
+    );
+    const rerankContext = trace2.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(
+      selectAttributes2(telemetry, {
+        "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.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;
+    if (state.stepSpan) {
+      recordSpanError(state.stepSpan, actualError);
+      state.stepSpan.end();
+    }
+    for (const { span: embedSpan } of state.embedSpans.values()) {
+      recordSpanError(embedSpan, actualError);
+      embedSpan.end();
+    }
+    state.embedSpans.clear();
+    if (state.rerankSpan) {
+      recordSpanError(state.rerankSpan.span, actualError);
+      state.rerankSpan.span.end();
+      state.rerankSpan = void 0;
+    }
+    recordSpanError(state.rootSpan, actualError);
+    state.rootSpan.end();
+    this.cleanupCallState(event.callId);
+  }
+};
+export {
+  LegacyOpenTelemetry,
+  OpenTelemetry
+};
+//# sourceMappingURL=index.js.map