@ai-sdk/otel 0.0.1-beta.0

package/dist/index.js

@@ -0,0 +1,868 @@
+"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 });
+};
+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 });
+  }
+  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/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,
+  telemetry,
+  headers
+}) {
+  var _a;
+  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 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;
+      },
+      {}
+    ),
+    // 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
+var import_ai = require("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: part.data instanceof Uint8Array ? (0, import_ai.convertDataContentToBase64String)(part.data) : part.data
+        } : part
+      )
+    }))
+  );
+}
+
+// src/open-telemetry-integration.ts
+function recordSpanError(span, error) {
+  if (error instanceof Error) {
+    span.recordException({
+      name: error.name,
+      message: error.message,
+      stack: error.stack
+    });
+    span.setStatus({
+      code: import_api.SpanStatusCode.ERROR,
+      message: error.message
+    });
+  } else {
+    span.setStatus({ code: import_api.SpanStatusCode.ERROR });
+  }
+}
+function shouldRecord(telemetry) {
+  return (telemetry == null ? void 0 : telemetry.isEnabled) === true;
+}
+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) result[key] = resolved;
+      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;
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+var OpenTelemetryIntegration = class {
+  constructor(options = {}) {
+    this.callStates = /* @__PURE__ */ new Map();
+    var _a;
+    this.tracer = (_a = options.tracer) != null ? _a : import_api.trace.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 import_api.context.with(toolSpanEntry.context, 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);
+      return;
+    }
+    if (event.operationId === "ai.generateObject" || event.operationId === "ai.streamObject") {
+      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
+    };
+    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 },
+      telemetry,
+      headers: event.headers,
+      settings
+    });
+    const attributes = selectAttributes(telemetry, {
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry
+      }),
+      ...baseTelemetryAttributes,
+      "ai.model.provider": event.provider,
+      "ai.model.id": event.modelId,
+      "ai.prompt": {
+        input: () => JSON.stringify({
+          system: event.system,
+          prompt: event.prompt,
+          messages: event.messages
+        })
+      }
+    });
+    const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
+    const rootContext = import_api.trace.setSpan(import_api.context.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 = {
+      isEnabled: event.isEnabled,
+      recordInputs: event.recordInputs,
+      recordOutputs: event.recordOutputs,
+      functionId: event.functionId,
+      metadata: event.metadata
+    };
+    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 },
+      telemetry,
+      headers: event.headers,
+      settings
+    });
+    const attributes = selectAttributes(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 = import_api.trace.setSpan(import_api.context.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 = selectAttributes(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 = import_api.trace.setSpan(state.rootContext, state.stepSpan);
+  }
+  /** @deprecated */
+  onObjectStepFinish(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.stepSpan)) return;
+    const { telemetry } = state;
+    state.stepSpan.setAttributes(
+      selectAttributes(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": event.usage.reasoningTokens,
+        "ai.usage.cachedInputTokens": event.usage.cachedInputTokens,
+        "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 = {
+      isEnabled: event.isEnabled,
+      recordInputs: event.recordInputs,
+      recordOutputs: event.recordOutputs,
+      functionId: event.functionId,
+      metadata: event.metadata
+    };
+    const settings = {
+      maxRetries: event.maxRetries
+    };
+    const baseTelemetryAttributes = getBaseTelemetryAttributes({
+      model: { provider: event.provider, modelId: event.modelId },
+      telemetry,
+      headers: event.headers,
+      settings
+    });
+    const value = event.value;
+    const isMany = event.operationId === "ai.embedMany";
+    const attributes = selectAttributes(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 = import_api.trace.setSpan(import_api.context.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 = selectAttributes(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 = import_api.trace.setSpan(state.rootContext, state.stepSpan);
+  }
+  onToolCallStart(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, {
+      ...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 = import_api.trace.setSpan(state.stepContext, toolSpan);
+    state.toolSpans.set(toolCall.toolCallId, {
+      span: toolSpan,
+      context: toolContext
+    });
+  }
+  onToolCallFinish(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) {
+      try {
+        span.setAttributes(
+          selectAttributes(telemetry, {
+            "ai.toolCall.result": {
+              output: () => JSON.stringify(event.output)
+            }
+          })
+        );
+      } catch (_ignored) {
+      }
+    } else {
+      recordSpanError(span, event.error);
+    }
+    span.end();
+    state.toolSpans.delete(event.toolCall.toolCallId);
+  }
+  onStepFinish(event) {
+    var _a, _b, _c, _d, _e;
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.stepSpan)) return;
+    const { telemetry } = state;
+    state.stepSpan.setAttributes(
+      selectAttributes(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.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,
+        "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
+      })
+    );
+    state.stepSpan.end();
+    state.stepSpan = void 0;
+    state.stepContext = void 0;
+  }
+  onFinish(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);
+      return;
+    }
+    if (state.operationId === "ai.rerank") {
+      this.onRerankOperationFinish(event);
+      return;
+    }
+    if (state.operationId === "ai.generateObject" || state.operationId === "ai.streamObject") {
+      this.onObjectOperationFinish(event);
+      return;
+    }
+    this.onGenerateFinish(event);
+  }
+  onGenerateFinish(event) {
+    var _a, _b, _c, _d, _e;
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan)) return;
+    const { telemetry } = state;
+    state.rootSpan.setAttributes(
+      selectAttributes(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.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
+      })
+    );
+    state.rootSpan.end();
+    this.cleanupCallState(event.callId);
+  }
+  onObjectOperationFinish(event) {
+    const state = this.getCallState(event.callId);
+    if (!(state == null ? void 0 : state.rootSpan)) return;
+    const { telemetry } = state;
+    state.rootSpan.setAttributes(
+      selectAttributes(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": event.usage.reasoningTokens,
+        "ai.usage.cachedInputTokens": event.usage.cachedInputTokens
+      })
+    );
+    state.rootSpan.end();
+    this.cleanupCallState(event.callId);
+  }
+  onEmbedOperationFinish(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, {
+        ...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 = selectAttributes(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 = import_api.trace.setSpan(state.rootContext, embedSpan);
+    state.embedSpans.set(event.embedCallId, {
+      span: embedSpan,
+      context: embedContext
+    });
+  }
+  onEmbedFinish(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, {
+        "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 = {
+      isEnabled: event.isEnabled,
+      recordInputs: event.recordInputs,
+      recordOutputs: event.recordOutputs,
+      functionId: event.functionId,
+      metadata: event.metadata
+    };
+    const settings = {
+      maxRetries: event.maxRetries
+    };
+    const baseTelemetryAttributes = getBaseTelemetryAttributes({
+      model: { provider: event.provider, modelId: event.modelId },
+      telemetry,
+      headers: event.headers,
+      settings
+    });
+    const attributes = selectAttributes(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 = import_api.trace.setSpan(import_api.context.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
+    });
+  }
+  onRerankOperationFinish(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 = selectAttributes(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 = import_api.trace.setSpan(state.rootContext, rerankSpan);
+    state.rerankSpan = { span: rerankSpan, context: rerankContext };
+  }
+  onRerankFinish(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, {
+        "ai.ranking.type": event.documentsType,
+        "ai.ranking": {
+          output: () => event.ranking.map((r) => JSON.stringify(r))
+        }
+      })
+    );
+    span.end();
+    state.rerankSpan = void 0;
+  }
+  onChunk(event) {
+    var _a;
+    const chunk = event.chunk;
+    if (typeof chunk.callId !== "string") {
+      return;
+    }
+    if (chunk.type !== "ai.stream.firstChunk" && chunk.type !== "ai.stream.finish") {
+      return;
+    }
+    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);
+    }
+  }
+  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);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenTelemetryIntegration
+});
+//# sourceMappingURL=index.js.map