@ai-sdk/otel 1.0.0-beta.6 → 1.0.0-beta.61

package/src/record-span.ts

@@ -1,11 +1,10 @@
 import {
-  Attributes,
-  Span,
-  Tracer,
   SpanStatusCode,
   context,
+  type Attributes,
+  type Span,
+  type Tracer,
 } from '@opentelemetry/api';
-
 export async function recordSpan<T>({
   name,
   tracer,

package/src/select-attributes.ts

@@ -0,0 +1,57 @@
+import type { Attributes, AttributeValue } from '@opentelemetry/api';
+import type { TelemetryOptions } from 'ai';
+
+export type AttributeSpec =
+  | AttributeValue
+  | { input: () => AttributeValue | undefined }
+  | { output: () => AttributeValue | undefined }
+  | undefined;
+
+export type AttributeSpecMap = Record<string, AttributeSpec>;
+
+function shouldRecord(
+  telemetry: TelemetryOptions | undefined,
+): telemetry is TelemetryOptions {
+  return telemetry?.isEnabled !== false;
+}
+
+export function selectAttributes(
+  telemetry: TelemetryOptions | undefined,
+  attributes: AttributeSpecMap,
+): Attributes {
+  if (!shouldRecord(telemetry)) {
+    return {};
+  }
+
+  const result: Attributes = {};
+
+  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?.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?.recordOutputs === false) continue;
+      const resolved = value.output();
+      if (resolved != null) result[key] = resolved;
+      continue;
+    }
+
+    result[key] = value as AttributeValue;
+  }
+
+  return result;
+}

package/src/select-telemetry-attributes.ts

@@ -1,5 +1,5 @@
 import type { Attributes, AttributeValue } from '@opentelemetry/api';
-import type { TelemetrySettings } from 'ai';
+import type { TelemetryOptions } from 'ai';
 
 type ResolvableAttributeValue = () =>
   | AttributeValue
@@ -10,7 +10,7 @@ export async function selectTelemetryAttributes({
   telemetry,
   attributes,
 }: {
-  telemetry?: TelemetrySettings;
+  telemetry?: TelemetryOptions;
   attributes: {
     [attributeKey: string]:
       | AttributeValue
@@ -20,7 +20,7 @@ export async function selectTelemetryAttributes({
   };
 }): Promise<Attributes> {
   // when telemetry is disabled, return an empty object to avoid serialization overhead:
-  if (telemetry?.isEnabled !== true) {
+  if (telemetry?.isEnabled === false) {
     return {};
   }
 

package/src/stringify-for-telemetry.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   LanguageModelV4Message,
   LanguageModelV4Prompt,
 } from '@ai-sdk/provider';
@@ -21,13 +21,31 @@ export function stringifyForTelemetry(prompt: LanguageModelV4Prompt): string {
               part.type === 'file'
                 ? {
                     ...part,
-                    data:
-                      part.data instanceof Uint8Array
-                        ? convertDataContentToBase64String(part.data)
-                        : part.data,
+                    data: serializeFileData(part.data),
                   }
                 : part,
             ),
     })),
   );
 }
+
+function serializeFileData(
+  data:
+    | { type: 'data'; data: string | Uint8Array }
+    | { type: 'url'; url: URL }
+    | { type: 'reference'; reference: Record<string, string> }
+    | { type: 'text'; text: string },
+): unknown {
+  switch (data.type) {
+    case 'data':
+      return data.data instanceof Uint8Array
+        ? convertDataContentToBase64String(data.data)
+        : data.data;
+    case 'url':
+      return data.url.toString();
+    case 'reference':
+      return data.reference;
+    case 'text':
+      return data.text;
+  }
+}

package/src/supplemental-attributes.ts

@@ -0,0 +1,151 @@
+import type { Attributes, Tracer } from '@opentelemetry/api';
+import type { TelemetryOptions } from 'ai';
+import { selectAttributes, type AttributeSpecMap } from './select-attributes';
+
+type SupplementalAttributeOption =
+  | 'usage'
+  | 'providerMetadata'
+  | 'embedding'
+  | 'reranking'
+  | 'runtimeContext'
+  | 'headers'
+  | 'toolChoice'
+  | 'schema';
+
+export type SupplementalAttributeOptions = Record<
+  SupplementalAttributeOption,
+  boolean
+>;
+
+export type OpenTelemetryOptions = {
+  /**
+   * The tracer to use for the telemetry data.
+   */
+  tracer?: Tracer;
+
+  /**
+   * Emit AI SDK usage details that are not represented by GenAI SemConv.
+   */
+  usage?: boolean;
+
+  /**
+   * Emit provider metadata on response spans.
+   */
+  providerMetadata?: boolean;
+
+  /**
+   * Emit embedding input and output values.
+   */
+  embedding?: boolean;
+
+  /**
+   * Emit reranking input documents and output ranking.
+   */
+  reranking?: boolean;
+
+  /**
+   * Emit runtime context values.
+   */
+  runtimeContext?: boolean;
+
+  /**
+   * Emit request headers.
+   */
+  headers?: boolean;
+
+  /**
+   * Emit selected tool choice information.
+   */
+  toolChoice?: boolean;
+
+  /**
+   * Emit object generation schema information.
+   */
+  schema?: boolean;
+};
+
+const disabledSupplementalAttributes: SupplementalAttributeOptions = {
+  usage: false,
+  providerMetadata: false,
+  embedding: false,
+  reranking: false,
+  runtimeContext: false,
+  headers: false,
+  toolChoice: false,
+  schema: false,
+};
+
+export function normalizeSupplementalAttributes(
+  options: OpenTelemetryOptions,
+): SupplementalAttributeOptions {
+  return {
+    ...disabledSupplementalAttributes,
+    usage: options.usage ?? false,
+    providerMetadata: options.providerMetadata ?? false,
+    embedding: options.embedding ?? false,
+    reranking: options.reranking ?? false,
+    runtimeContext: options.runtimeContext ?? false,
+    headers: options.headers ?? false,
+    toolChoice: options.toolChoice ?? false,
+    schema: options.schema ?? false,
+  };
+}
+
+export function getRuntimeContextAttributes(
+  context: Record<string, unknown> | undefined,
+): AttributeSpecMap {
+  return Object.fromEntries(
+    Object.entries(context ?? {})
+      .filter(([, value]) => value != null)
+      .map(([key, value]) => [`ai.settings.context.${key}`, value]),
+  ) as AttributeSpecMap;
+}
+
+export function getHeaderAttributes(
+  headers: Record<string, string | undefined> | undefined,
+): AttributeSpecMap {
+  return Object.fromEntries(
+    Object.entries(headers ?? {})
+      .filter(([, value]) => value != null)
+      .map(([key, value]) => [`ai.request.headers.${key}`, value]),
+  ) as AttributeSpecMap;
+}
+
+export function getDetailedUsageAttributes(usage: {
+  inputTokenDetails?: {
+    noCacheTokens?: number | undefined;
+  };
+  outputTokenDetails?: {
+    textTokens?: number | undefined;
+    reasoningTokens?: number | undefined;
+  };
+}): AttributeSpecMap {
+  return {
+    'ai.usage.inputTokenDetails.noCacheTokens':
+      usage.inputTokenDetails?.noCacheTokens,
+    'ai.usage.outputTokenDetails.textTokens':
+      usage.outputTokenDetails?.textTokens,
+    'ai.usage.outputTokenDetails.reasoningTokens':
+      usage.outputTokenDetails?.reasoningTokens,
+  };
+}
+
+export function selectSupplementalAttributes(
+  telemetry: TelemetryOptions | undefined,
+  enabledAttributes: SupplementalAttributeOptions,
+  attributes: Partial<Record<SupplementalAttributeOption, AttributeSpecMap>>,
+): Attributes {
+  const result: Attributes = {};
+
+  for (const [key, value] of Object.entries(attributes) as Array<
+    [SupplementalAttributeOption, AttributeSpecMap | undefined]
+  >) {
+    if (!enabledAttributes[key] || value == null) {
+      continue;
+    }
+
+    Object.assign(result, selectAttributes(telemetry, value));
+  }
+
+  return result;
+}

package/dist/index.d.mts

@@ -1,52 +0,0 @@
-import { LanguageModelV4Prompt } from '@ai-sdk/provider';
-import { Tracer } from '@opentelemetry/api';
-import { TelemetryIntegration, OnStartEvent, ToolSet, OutputInterface, ObjectOnStartEvent, EmbedOnStartEvent, RerankOnStartEvent, ObjectOnStepStartEvent, ObjectOnStepFinishEvent, GenerationContext, OnStepStartEvent, OnToolCallStartEvent, OnToolCallFinishEvent, OnStepFinishEvent, OnFinishEvent, ObjectOnFinishEvent, EmbedOnFinishEvent, RerankOnFinishEvent, EmbedStartEvent, EmbedFinishEvent, RerankStartEvent, RerankFinishEvent, OnChunkEvent } from 'ai';
-
-interface OtelStepStartEvent<TOOLS extends ToolSet = ToolSet, CONTEXT extends GenerationContext<TOOLS> = GenerationContext<TOOLS>, OUTPUT extends OutputInterface = OutputInterface> extends OnStepStartEvent<TOOLS, CONTEXT, OUTPUT> {
-    readonly promptMessages?: LanguageModelV4Prompt;
-    readonly stepTools?: ReadonlyArray<Record<string, unknown>>;
-    readonly stepToolChoice?: unknown;
-}
-declare class OpenTelemetryIntegration implements TelemetryIntegration {
-    private readonly callStates;
-    /**
-     * The tracer to use for the telemetry data.
-     */
-    private readonly tracer;
-    constructor(options?: {
-        tracer?: Tracer;
-    });
-    private getCallState;
-    private cleanupCallState;
-    executeTool<T>({ callId, toolCallId, execute, }: {
-        callId: string;
-        toolCallId: string;
-        execute: () => PromiseLike<T>;
-    }): PromiseLike<T>;
-    onStart(event: OnStartEvent<ToolSet, OutputInterface> | ObjectOnStartEvent | EmbedOnStartEvent | RerankOnStartEvent): void;
-    private onGenerateStart;
-    private onObjectOperationStart;
-    /** @deprecated */
-    onObjectStepStart(event: ObjectOnStepStartEvent): void;
-    /** @deprecated */
-    onObjectStepFinish(event: ObjectOnStepFinishEvent): void;
-    private onEmbedOperationStart;
-    onStepStart(event: OtelStepStartEvent<ToolSet, OutputInterface>): void;
-    onToolCallStart(event: OnToolCallStartEvent<ToolSet>): void;
-    onToolCallFinish(event: OnToolCallFinishEvent<ToolSet>): void;
-    onStepFinish(event: OnStepFinishEvent<ToolSet>): void;
-    onFinish(event: OnFinishEvent<ToolSet> | ObjectOnFinishEvent<unknown> | EmbedOnFinishEvent | RerankOnFinishEvent): void;
-    private onGenerateFinish;
-    private onObjectOperationFinish;
-    private onEmbedOperationFinish;
-    onEmbedStart(event: EmbedStartEvent): void;
-    onEmbedFinish(event: EmbedFinishEvent): void;
-    private onRerankOperationStart;
-    private onRerankOperationFinish;
-    onRerankStart(event: RerankStartEvent): void;
-    onRerankFinish(event: RerankFinishEvent): void;
-    onChunk(event: OnChunkEvent<ToolSet>): void;
-    onError(error: unknown): void;
-}
-
-export { OpenTelemetryIntegration };