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

package/src/{open-telemetry-integration.ts → legacy-open-telemetry.ts}

@@ -1,38 +1,39 @@
-import { LanguageModelV4Prompt } from '@ai-sdk/provider';
+import type { LanguageModelV4Prompt } from '@ai-sdk/provider';
+import type { Context as AISDKContext } from '@ai-sdk/provider-utils';
 import {
-  Attributes,
-  AttributeValue,
   context,
-  Context,
-  Span,
   SpanStatusCode,
   trace,
-  Tracer,
+  type Attributes,
+  type AttributeValue,
+  type Context as OpenTelemetryContext,
+  type Span,
+  type Tracer,
 } from '@opentelemetry/api';
 import type {
-  EmbedFinishEvent,
-  EmbedOnFinishEvent,
-  EmbedOnStartEvent,
+  EmbeddingModelCallEndEvent,
+  EmbedEndEvent,
   EmbedStartEvent,
-  GenerationContext,
-  ObjectOnFinishEvent,
-  ObjectOnStartEvent,
-  ObjectOnStepFinishEvent,
-  ObjectOnStepStartEvent,
-  OnChunkEvent,
-  OnFinishEvent,
-  OnStartEvent,
-  OnStepFinishEvent,
-  OnStepStartEvent,
-  OnToolCallFinishEvent,
-  OnToolCallStartEvent,
+  EmbeddingModelCallStartEvent,
+  GenerateObjectEndEvent,
+  GenerateObjectStartEvent,
+  GenerateObjectStepEndEvent,
+  GenerateObjectStepStartEvent,
+  StreamTextChunkEvent,
+  GenerateTextEndEvent,
+  GenerateTextStartEvent,
+  GenerateTextStepEndEvent,
+  GenerateTextStepStartEvent,
+  ToolExecutionEndEvent,
+  ToolExecutionStartEvent,
   OutputInterface as Output,
-  RerankFinishEvent,
-  RerankOnFinishEvent,
-  RerankOnStartEvent,
+  RerankingModelCallEndEvent,
+  RerankEndEvent,
   RerankStartEvent,
-  TelemetryIntegration,
-  TelemetrySettings,
+  RerankingModelCallStartEvent,
+  InferTelemetryEvent,
+  Telemetry,
+  TelemetryOptions,
   ToolSet,
 } from 'ai';
 import { assembleOperationName } from './assemble-operation-name';
@@ -56,13 +57,13 @@ function recordSpanError(span: Span, error: unknown): void {
 }
 
 function shouldRecord(
-  telemetry: TelemetrySettings | undefined,
-): telemetry is TelemetrySettings {
-  return telemetry?.isEnabled === true;
+  telemetry: TelemetryOptions | undefined,
+): telemetry is TelemetryOptions {
+  return telemetry?.isEnabled !== false;
 }
 
 function selectAttributes(
-  telemetry: TelemetrySettings | undefined,
+  telemetry: TelemetryOptions | undefined,
   attributes: Record<
     string,
     | AttributeValue
@@ -110,9 +111,9 @@ function selectAttributes(
 
 interface OtelStepStartEvent<
   TOOLS extends ToolSet = ToolSet,
-  CONTEXT extends GenerationContext<TOOLS> = GenerationContext<TOOLS>,
+  RUNTIME_CONTEXT extends AISDKContext = AISDKContext,
   OUTPUT extends Output = Output,
-> extends OnStepStartEvent<TOOLS, CONTEXT, OUTPUT> {
+> extends GenerateTextStepStartEvent<TOOLS, RUNTIME_CONTEXT, OUTPUT> {
   readonly promptMessages?: LanguageModelV4Prompt;
   readonly stepTools?: ReadonlyArray<Record<string, unknown>>;
   readonly stepToolChoice?: unknown;
@@ -120,19 +121,19 @@ interface OtelStepStartEvent<
 
 interface CallState {
   operationId: string;
-  telemetry: TelemetrySettings | undefined;
+  telemetry: TelemetryOptions | undefined;
   rootSpan: Span | undefined;
-  rootContext: Context | undefined;
+  rootContext: OpenTelemetryContext | undefined;
   stepSpan: Span | undefined;
-  stepContext: Context | undefined;
-  embedSpans: Map<string, { span: Span; context: Context }>;
-  rerankSpan: { span: Span; context: Context } | undefined;
-  toolSpans: Map<string, { span: Span; context: Context }>;
+  stepContext: OpenTelemetryContext | undefined;
+  embedSpans: Map<string, { span: Span; context: OpenTelemetryContext }>;
+  rerankSpan: { span: Span; context: OpenTelemetryContext } | undefined;
+  toolSpans: Map<string, { span: Span; context: OpenTelemetryContext }>;
   baseTelemetryAttributes: Attributes;
   settings: Record<string, unknown>;
 }
 
-export class OpenTelemetryIntegration implements TelemetryIntegration {
+export class LegacyOpenTelemetry implements Telemetry {
   private readonly callStates = new Map<string, CallState>();
 
   /**
@@ -176,23 +177,23 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
 
   onStart(
     event:
-      | OnStartEvent<ToolSet, Output>
-      | ObjectOnStartEvent
-      | EmbedOnStartEvent
-      | RerankOnStartEvent,
+      | InferTelemetryEvent<GenerateTextStartEvent>
+      | InferTelemetryEvent<GenerateObjectStartEvent>
+      | InferTelemetryEvent<EmbedStartEvent>
+      | InferTelemetryEvent<RerankStartEvent>,
   ): void {
-    if (event.isEnabled !== true) return;
-
     if (
       event.operationId === 'ai.embed' ||
       event.operationId === 'ai.embedMany'
     ) {
-      this.onEmbedOperationStart(event as EmbedOnStartEvent);
+      this.onEmbedOperationStart(event as InferTelemetryEvent<EmbedStartEvent>);
       return;
     }
 
     if (event.operationId === 'ai.rerank') {
-      this.onRerankOperationStart(event as RerankOnStartEvent);
+      this.onRerankOperationStart(
+        event as InferTelemetryEvent<RerankStartEvent>,
+      );
       return;
     }
 
@@ -200,20 +201,22 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
       event.operationId === 'ai.generateObject' ||
       event.operationId === 'ai.streamObject'
     ) {
-      this.onObjectOperationStart(event as ObjectOnStartEvent);
+      this.onObjectOperationStart(
+        event as InferTelemetryEvent<GenerateObjectStartEvent>,
+      );
       return;
     }
 
-    this.onGenerateStart(event as OnStartEvent<ToolSet, Output>);
+    this.onGenerateStart(event as InferTelemetryEvent<GenerateTextStartEvent>);
   }
 
-  private onGenerateStart(event: OnStartEvent<ToolSet, Output>): void {
-    const telemetry: TelemetrySettings = {
-      isEnabled: event.isEnabled,
+  private onGenerateStart(
+    event: InferTelemetryEvent<GenerateTextStartEvent>,
+  ): void {
+    const telemetry: TelemetryOptions = {
       recordInputs: event.recordInputs,
       recordOutputs: event.recordOutputs,
       functionId: event.functionId,
-      metadata: event.metadata,
     };
 
     const settings: Record<string, unknown> = {
@@ -230,9 +233,9 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
 
     const baseTelemetryAttributes = getBaseTelemetryAttributes({
       model: { provider: event.provider, modelId: event.modelId },
-      telemetry,
       headers: event.headers,
       settings,
+      context: event.runtimeContext as Record<string, unknown> | undefined,
     });
 
     const attributes = selectAttributes(telemetry, {
@@ -247,7 +250,6 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
         input: () =>
           JSON.stringify({
             system: event.system,
-            prompt: event.prompt,
             messages: event.messages,
           }),
       },
@@ -271,13 +273,13 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     });
   }
 
-  private onObjectOperationStart(event: ObjectOnStartEvent): void {
-    const telemetry: TelemetrySettings = {
-      isEnabled: event.isEnabled,
+  private onObjectOperationStart(
+    event: InferTelemetryEvent<GenerateObjectStartEvent>,
+  ): void {
+    const telemetry: TelemetryOptions = {
       recordInputs: event.recordInputs,
       recordOutputs: event.recordOutputs,
       functionId: event.functionId,
-      metadata: event.metadata,
     };
 
     const settings: Record<string, unknown> = {
@@ -293,9 +295,9 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
 
     const baseTelemetryAttributes = getBaseTelemetryAttributes({
       model: { provider: event.provider, modelId: event.modelId },
-      telemetry,
       headers: event.headers,
       settings,
+      context: undefined,
     });
 
     const attributes = selectAttributes(telemetry, {
@@ -339,7 +341,7 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
   }
 
   /** @deprecated */
-  onObjectStepStart(event: ObjectOnStepStartEvent): void {
+  onObjectStepStart(event: GenerateObjectStepStartEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan || !state.rootContext) return;
 
@@ -390,7 +392,7 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
   }
 
   /** @deprecated */
-  onObjectStepFinish(event: ObjectOnStepFinishEvent): void {
+  onObjectStepFinish(event: GenerateObjectStepEndEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.stepSpan) return;
 
@@ -443,13 +445,13 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     state.stepContext = undefined;
   }
 
-  private onEmbedOperationStart(event: EmbedOnStartEvent): void {
-    const telemetry: TelemetrySettings = {
-      isEnabled: event.isEnabled,
+  private onEmbedOperationStart(
+    event: InferTelemetryEvent<EmbedStartEvent>,
+  ): void {
+    const telemetry: TelemetryOptions = {
       recordInputs: event.recordInputs,
       recordOutputs: event.recordOutputs,
       functionId: event.functionId,
-      metadata: event.metadata,
     };
 
     const settings: Record<string, unknown> = {
@@ -458,9 +460,9 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
 
     const baseTelemetryAttributes = getBaseTelemetryAttributes({
       model: { provider: event.provider, modelId: event.modelId },
-      telemetry,
       headers: event.headers,
       settings,
+      context: undefined,
     });
 
     const value = event.value;
@@ -503,7 +505,7 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     });
   }
 
-  onStepStart(event: OtelStepStartEvent<ToolSet, Output>): void {
+  onStepStart(event: OtelStepStartEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan || !state.rootContext) return;
 
@@ -568,7 +570,7 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     state.stepContext = trace.setSpan(state.rootContext, state.stepSpan);
   }
 
-  onToolCallStart(event: OnToolCallStartEvent<ToolSet>): void {
+  onToolExecutionStart(event: ToolExecutionStartEvent<ToolSet>): void {
     const state = this.getCallState(event.callId);
     if (!state?.stepContext) return;
 
@@ -600,7 +602,7 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     });
   }
 
-  onToolCallFinish(event: OnToolCallFinishEvent<ToolSet>): void {
+  onToolExecutionEnd(event: ToolExecutionEndEvent<ToolSet>): void {
     const state = this.getCallState(event.callId);
     if (!state) return;
 
@@ -610,27 +612,28 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     const { span } = toolSpanEntry;
     const { telemetry } = state;
 
-    if (event.success) {
+    const { toolOutput } = event;
+    if (toolOutput.type === 'tool-result') {
       try {
         span.setAttributes(
           selectAttributes(telemetry, {
             'ai.toolCall.result': {
-              output: () => JSON.stringify(event.output),
+              output: () => JSON.stringify(toolOutput.output),
             },
           }),
         );
-      } catch (_ignored) {
+      } catch {
         // JSON.stringify might fail for non-serializable results
       }
     } else {
-      recordSpanError(span, event.error);
+      recordSpanError(span, toolOutput.error);
     }
 
     span.end();
     state.toolSpans.delete(event.toolCall.toolCallId);
   }
 
-  onStepFinish(event: OnStepFinishEvent<ToolSet>): void {
+  onStepFinish(event: GenerateTextStepEndEvent<ToolSet>): void {
     const state = this.getCallState(event.callId);
     if (!state?.stepSpan) return;
 
@@ -713,10 +716,10 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
 
   onFinish(
     event:
-      | OnFinishEvent<ToolSet>
-      | ObjectOnFinishEvent<unknown>
-      | EmbedOnFinishEvent
-      | RerankOnFinishEvent,
+      | GenerateTextEndEvent<ToolSet>
+      | GenerateObjectEndEvent<unknown>
+      | EmbedEndEvent
+      | RerankEndEvent,
   ): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan) return;
@@ -725,12 +728,12 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
       state.operationId === 'ai.embed' ||
       state.operationId === 'ai.embedMany'
     ) {
-      this.onEmbedOperationFinish(event as EmbedOnFinishEvent);
+      this.onEmbedOperationFinish(event as EmbedEndEvent);
       return;
     }
 
     if (state.operationId === 'ai.rerank') {
-      this.onRerankOperationFinish(event as RerankOnFinishEvent);
+      this.onRerankOperationFinish(event as RerankEndEvent);
       return;
     }
 
@@ -738,14 +741,14 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
       state.operationId === 'ai.generateObject' ||
       state.operationId === 'ai.streamObject'
     ) {
-      this.onObjectOperationFinish(event as ObjectOnFinishEvent<unknown>);
+      this.onObjectOperationFinish(event as GenerateObjectEndEvent<unknown>);
       return;
     }
 
-    this.onGenerateFinish(event as OnFinishEvent<ToolSet>);
+    this.onGenerateFinish(event as GenerateTextEndEvent<ToolSet>);
   }
 
-  private onGenerateFinish(event: OnFinishEvent<ToolSet>): void {
+  private onGenerateFinish(event: GenerateTextEndEvent<ToolSet>): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan) return;
 
@@ -816,7 +819,9 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     this.cleanupCallState(event.callId);
   }
 
-  private onObjectOperationFinish(event: ObjectOnFinishEvent<unknown>): void {
+  private onObjectOperationFinish(
+    event: GenerateObjectEndEvent<unknown>,
+  ): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan) return;
 
@@ -845,7 +850,7 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     this.cleanupCallState(event.callId);
   }
 
-  private onEmbedOperationFinish(event: EmbedOnFinishEvent): void {
+  private onEmbedOperationFinish(event: EmbedEndEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan) return;
 
@@ -874,7 +879,7 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     this.cleanupCallState(event.callId);
   }
 
-  onEmbedStart(event: EmbedStartEvent): void {
+  onEmbedStart(event: EmbeddingModelCallStartEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan || !state.rootContext) return;
 
@@ -904,7 +909,7 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     });
   }
 
-  onEmbedFinish(event: EmbedFinishEvent): void {
+  onEmbedFinish(event: EmbeddingModelCallEndEvent): void {
     const state = this.getCallState(event.callId);
     if (!state) return;
 
@@ -928,13 +933,13 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     state.embedSpans.delete(event.embedCallId);
   }
 
-  private onRerankOperationStart(event: RerankOnStartEvent): void {
-    const telemetry: TelemetrySettings = {
-      isEnabled: event.isEnabled,
+  private onRerankOperationStart(
+    event: InferTelemetryEvent<RerankStartEvent>,
+  ): void {
+    const telemetry: TelemetryOptions = {
       recordInputs: event.recordInputs,
       recordOutputs: event.recordOutputs,
       functionId: event.functionId,
-      metadata: event.metadata,
     };
 
     const settings: Record<string, unknown> = {
@@ -943,9 +948,9 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
 
     const baseTelemetryAttributes = getBaseTelemetryAttributes({
       model: { provider: event.provider, modelId: event.modelId },
-      telemetry,
       headers: event.headers,
       settings,
+      context: undefined,
     });
 
     const attributes = selectAttributes(telemetry, {
@@ -977,7 +982,7 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     });
   }
 
-  private onRerankOperationFinish(event: RerankOnFinishEvent): void {
+  private onRerankOperationFinish(event: RerankEndEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan) return;
 
@@ -985,7 +990,7 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     this.cleanupCallState(event.callId);
   }
 
-  onRerankStart(event: RerankStartEvent): void {
+  onRerankStart(event: RerankingModelCallStartEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan || !state.rootContext) return;
 
@@ -1012,7 +1017,7 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     state.rerankSpan = { span: rerankSpan, context: rerankContext };
   }
 
-  onRerankFinish(event: RerankFinishEvent): void {
+  onRerankFinish(event: RerankingModelCallEndEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.rerankSpan) return;
 
@@ -1032,7 +1037,7 @@ export class OpenTelemetryIntegration implements TelemetryIntegration {
     state.rerankSpan = undefined;
   }
 
-  onChunk(event: OnChunkEvent<ToolSet>): void {
+  onChunk(event: StreamTextChunkEvent<ToolSet>): void {
     const chunk = event.chunk as {
       type: string;
       callId?: unknown;

package/src/mock-tracer.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   AttributeValue,
   Attributes,
   Context,

package/src/noop-tracer.ts

@@ -1,4 +1,4 @@
-import { Span, SpanContext, Tracer } from '@opentelemetry/api';
+import type { Span, SpanContext, Tracer } from '@opentelemetry/api';
 
 /**
  * Tracer implementation that does nothing (null object).