@ai-sdk/otel 1.0.0-beta.57 → 1.0.0-beta.59

package/src/open-telemetry.ts

@@ -1,43 +1,50 @@
-import { LanguageModelV4Prompt } from '@ai-sdk/provider';
-import type { Context as AISDKContext } from '@ai-sdk/provider-utils';
 import {
   Attributes,
   AttributeValue,
   context,
   Context as OpenTelemetryContext,
   Span,
+  SpanKind,
   SpanStatusCode,
   trace,
   Tracer,
 } from '@opentelemetry/api';
 import type {
-  EmbedFinishEvent,
-  EmbedOnFinishEvent,
-  EmbedOnStartEvent,
+  EmbeddingModelCallEndEvent,
+  EmbedEndEvent,
   EmbedStartEvent,
-  ObjectOnFinishEvent,
-  ObjectOnStartEvent,
-  ObjectOnStepFinishEvent,
-  ObjectOnStepStartEvent,
-  OnChunkEvent,
-  OnFinishEvent,
-  OnStartEvent,
-  OnStepFinishEvent,
-  OnStepStartEvent,
+  LanguageModelCallEndEvent,
+  LanguageModelCallStartEvent,
+  EmbeddingModelCallStartEvent,
+  GenerateObjectEndEvent,
+  GenerateObjectStartEvent,
+  GenerateObjectStepEndEvent,
+  GenerateObjectStepStartEvent,
+  StreamTextChunkEvent,
+  GenerateTextEndEvent,
+  GenerateTextStartEvent,
+  GenerateTextStepEndEvent,
+  GenerateTextStepStartEvent,
   ToolExecutionEndEvent,
   ToolExecutionStartEvent,
-  OutputInterface as Output,
-  RerankFinishEvent,
-  RerankOnFinishEvent,
-  RerankOnStartEvent,
+  RerankingModelCallEndEvent,
+  RerankEndEvent,
   RerankStartEvent,
+  RerankingModelCallStartEvent,
+  InferTelemetryEvent,
   Telemetry,
   TelemetryOptions,
   ToolSet,
 } from 'ai';
-import { assembleOperationName } from './assemble-operation-name';
-import { getBaseTelemetryAttributes } from './get-base-telemetry-attributes';
-import { stringifyForTelemetry } from './stringify-for-telemetry';
+import {
+  formatInputMessages,
+  formatModelMessages,
+  formatObjectOutputMessages,
+  formatOutputMessages,
+  formatSystemInstructions,
+  mapOperationName,
+  mapProviderName,
+} from './gen-ai-format-messages';
 
 function recordSpanError(span: Span, error: unknown): void {
   if (error instanceof Error) {
@@ -108,16 +115,6 @@ function selectAttributes(
   return result;
 }
 
-interface OtelStepStartEvent<
-  TOOLS extends ToolSet = ToolSet,
-  RUNTIME_CONTEXT extends AISDKContext = AISDKContext,
-  OUTPUT extends Output = Output,
-> extends OnStepStartEvent<TOOLS, RUNTIME_CONTEXT, OUTPUT> {
-  readonly promptMessages?: LanguageModelV4Prompt;
-  readonly stepTools?: ReadonlyArray<Record<string, unknown>>;
-  readonly stepToolChoice?: unknown;
-}
-
 interface CallState {
   operationId: string;
   telemetry: TelemetryOptions | undefined;
@@ -125,19 +122,19 @@ interface CallState {
   rootContext: OpenTelemetryContext | undefined;
   stepSpan: Span | undefined;
   stepContext: OpenTelemetryContext | undefined;
+  inferenceSpan: Span | undefined;
+  inferenceContext: 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>;
+  provider: string;
+  modelId: string;
 }
 
 export class OpenTelemetry implements Telemetry {
   private readonly callStates = new Map<string, CallState>();
 
-  /**
-   * The tracer to use for the telemetry data.
-   */
   private readonly tracer: Tracer;
 
   constructor(
@@ -145,7 +142,7 @@ export class OpenTelemetry implements Telemetry {
       tracer?: Tracer;
     } = {},
   ) {
-    this.tracer = options.tracer ?? trace.getTracer('ai');
+    this.tracer = options.tracer ?? trace.getTracer('gen_ai');
   }
 
   private getCallState(callId: string): CallState | undefined {
@@ -176,23 +173,23 @@ export class OpenTelemetry implements Telemetry {
 
   onStart(
     event:
-      | OnStartEvent
-      | ObjectOnStartEvent
-      | EmbedOnStartEvent
-      | RerankOnStartEvent,
+      | InferTelemetryEvent<GenerateTextStartEvent>
+      | InferTelemetryEvent<GenerateObjectStartEvent>
+      | InferTelemetryEvent<EmbedStartEvent>
+      | InferTelemetryEvent<RerankStartEvent>,
   ): void {
-    if (event.isEnabled === false) 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,16 +197,19 @@ export class OpenTelemetry implements Telemetry {
       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);
+    this.onGenerateStart(event as InferTelemetryEvent<GenerateTextStartEvent>);
   }
 
-  private onGenerateStart(event: OnStartEvent): void {
+  private onGenerateStart(
+    event: InferTelemetryEvent<GenerateTextStartEvent>,
+  ): void {
     const telemetry: TelemetryOptions = {
-      isEnabled: event.isEnabled,
       recordInputs: event.recordInputs,
       recordOutputs: event.recordOutputs,
       functionId: event.functionId,
@@ -227,32 +227,46 @@ export class OpenTelemetry implements Telemetry {
       maxRetries: event.maxRetries,
     };
 
-    const baseTelemetryAttributes = getBaseTelemetryAttributes({
-      model: { provider: event.provider, modelId: event.modelId },
-      headers: event.headers,
-      settings,
-      context: event.runtimeContext as Record<string, unknown> | undefined,
-    });
+    const providerName = mapProviderName(event.provider);
+    const operationName = mapOperationName(event.operationId);
 
     const attributes = selectAttributes(telemetry, {
-      ...assembleOperationName({
-        operationId: event.operationId,
-        telemetry,
-      }),
-      ...baseTelemetryAttributes,
-      'ai.model.provider': event.provider,
-      'ai.model.id': event.modelId,
-      'ai.prompt': {
+      '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': (event.temperature ?? undefined) as
+        | number
+        | undefined,
+      '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.system
+        ? {
+            input: () =>
+              JSON.stringify(formatSystemInstructions(event.system!)),
+          }
+        : undefined,
+      'gen_ai.input.messages': {
         input: () =>
-          JSON.stringify({
-            system: event.system,
-            prompt: event.prompt,
-            messages: event.messages,
-          }),
+          JSON.stringify(
+            formatModelMessages({
+              prompt: undefined,
+              messages: event.messages,
+            }),
+          ),
       },
     });
 
-    const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
+    const spanName = `${operationName} ${event.modelId}`;
+    const rootSpan = this.tracer.startSpan(spanName, {
+      attributes,
+      kind: SpanKind.INTERNAL,
+    });
     const rootContext = trace.setSpan(context.active(), rootSpan);
 
     this.callStates.set(event.callId, {
@@ -262,17 +276,21 @@ export class OpenTelemetry implements Telemetry {
       rootContext,
       stepSpan: undefined,
       stepContext: undefined,
+      inferenceSpan: undefined,
+      inferenceContext: undefined,
       embedSpans: new Map(),
       rerankSpan: undefined,
       toolSpans: new Map(),
-      baseTelemetryAttributes,
       settings,
+      provider: event.provider,
+      modelId: event.modelId,
     });
   }
 
-  private onObjectOperationStart(event: ObjectOnStartEvent): void {
+  private onObjectOperationStart(
+    event: InferTelemetryEvent<GenerateObjectStartEvent>,
+  ): void {
     const telemetry: TelemetryOptions = {
-      isEnabled: event.isEnabled,
       recordInputs: event.recordInputs,
       recordOutputs: event.recordOutputs,
       functionId: event.functionId,
@@ -289,36 +307,46 @@ export class OpenTelemetry implements Telemetry {
       maxRetries: event.maxRetries,
     };
 
-    const baseTelemetryAttributes = getBaseTelemetryAttributes({
-      model: { provider: event.provider, modelId: event.modelId },
-      headers: event.headers,
-      settings,
-      context: undefined,
-    });
+    const providerName = mapProviderName(event.provider);
+    const operationName = mapOperationName(event.operationId);
 
     const attributes = selectAttributes(telemetry, {
-      ...assembleOperationName({
-        operationId: event.operationId,
-        telemetry,
-      }),
-      ...baseTelemetryAttributes,
-      'ai.prompt': {
+      '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': (event.temperature ?? undefined) as
+        | number
+        | undefined,
+      '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!)),
+          }
+        : undefined,
+      'gen_ai.input.messages': {
         input: () =>
-          JSON.stringify({
-            system: event.system,
-            prompt: event.prompt,
-            messages: event.messages,
-          }),
+          JSON.stringify(
+            formatModelMessages({
+              prompt: event.prompt,
+              messages: event.messages,
+            }),
+          ),
       },
-      'ai.schema': event.schema
-        ? { input: () => JSON.stringify(event.schema) }
-        : undefined,
-      'ai.schema.name': event.schemaName,
-      'ai.schema.description': event.schemaDescription,
-      'ai.settings.output': event.output,
     });
 
-    const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
+    const spanName = `${operationName} ${event.modelId}`;
+    const rootSpan = this.tracer.startSpan(spanName, {
+      attributes,
+      kind: SpanKind.INTERNAL,
+    });
     const rootContext = trace.setSpan(context.active(), rootSpan);
 
     this.callStates.set(event.callId, {
@@ -328,41 +356,30 @@ export class OpenTelemetry implements Telemetry {
       rootContext,
       stepSpan: undefined,
       stepContext: undefined,
+      inferenceSpan: undefined,
+      inferenceContext: undefined,
       embedSpans: new Map(),
       rerankSpan: undefined,
       toolSpans: new Map(),
-      baseTelemetryAttributes,
       settings,
+      provider: event.provider,
+      modelId: event.modelId,
     });
   }
 
   /** @deprecated */
-  onObjectStepStart(event: ObjectOnStepStartEvent): void {
+  onObjectStepStart(event: GenerateObjectStepStartEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan || !state.rootContext) return;
 
     const { telemetry } = state;
-
-    const stepOperationId =
-      state.operationId === 'ai.streamObject'
-        ? 'ai.streamObject.doStream'
-        : 'ai.generateObject.doGenerate';
+    const providerName = mapProviderName(event.provider);
 
     const attributes = selectAttributes(telemetry, {
-      ...assembleOperationName({
-        operationId: stepOperationId,
-        telemetry,
-      }),
-      ...state.baseTelemetryAttributes,
-      'ai.prompt.messages': {
-        input: () =>
-          event.promptMessages
-            ? stringifyForTelemetry(event.promptMessages)
-            : undefined,
-      },
-
-      'gen_ai.system': event.provider,
+      '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 as
         | number
         | undefined,
@@ -377,73 +394,67 @@ export class OpenTelemetry implements Telemetry {
         | undefined,
       'gen_ai.request.top_k': state.settings.topK as number | undefined,
       'gen_ai.request.top_p': state.settings.topP as number | undefined,
+      'gen_ai.input.messages': {
+        input: () =>
+          event.promptMessages
+            ? JSON.stringify(formatInputMessages(event.promptMessages))
+            : undefined,
+      },
     });
 
-    state.stepSpan = this.tracer.startSpan(
-      stepOperationId,
-      { attributes },
+    const spanName = `chat ${event.modelId}`;
+    state.inferenceSpan = this.tracer.startSpan(
+      spanName,
+      { attributes, kind: SpanKind.CLIENT },
       state.rootContext,
     );
-    state.stepContext = trace.setSpan(state.rootContext, state.stepSpan);
+    state.inferenceContext = trace.setSpan(
+      state.rootContext,
+      state.inferenceSpan,
+    );
   }
 
   /** @deprecated */
-  onObjectStepFinish(event: ObjectOnStepFinishEvent): void {
+  onObjectStepFinish(event: GenerateObjectStepEndEvent): void {
     const state = this.getCallState(event.callId);
-    if (!state?.stepSpan) return;
+    if (!state?.inferenceSpan) return;
 
     const { telemetry } = state;
 
-    state.stepSpan.setAttributes(
+    state.inferenceSpan.setAttributes(
       selectAttributes(telemetry, {
-        'ai.response.finishReason': event.finishReason,
-        'ai.response.object': {
+        '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': event.usage.cachedInputTokens,
+        'gen_ai.output.messages': {
           output: () => {
             try {
-              return JSON.stringify(JSON.parse(event.objectText));
+              return JSON.stringify(
+                formatObjectOutputMessages({
+                  objectText: event.objectText,
+                  finishReason: event.finishReason,
+                }),
+              );
             } catch {
               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)
-          : undefined,
-
-        '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 = undefined;
-    state.stepContext = undefined;
+    state.inferenceSpan.end();
+    state.inferenceSpan = undefined;
+    state.inferenceContext = undefined;
   }
 
-  private onEmbedOperationStart(event: EmbedOnStartEvent): void {
+  private onEmbedOperationStart(
+    event: InferTelemetryEvent<EmbedStartEvent>,
+  ): void {
     const telemetry: TelemetryOptions = {
-      isEnabled: event.isEnabled,
       recordInputs: event.recordInputs,
       recordOutputs: event.recordOutputs,
       functionId: event.functionId,
@@ -453,36 +464,19 @@ export class OpenTelemetry implements Telemetry {
       maxRetries: event.maxRetries,
     };
 
-    const baseTelemetryAttributes = getBaseTelemetryAttributes({
-      model: { provider: event.provider, modelId: event.modelId },
-      headers: event.headers,
-      settings,
-      context: undefined,
-    });
-
-    const value = event.value;
-    const isMany = event.operationId === 'ai.embedMany';
+    const providerName = mapProviderName(event.provider);
 
     const attributes = selectAttributes(telemetry, {
-      ...assembleOperationName({
-        operationId: event.operationId,
-        telemetry,
-      }),
-      ...baseTelemetryAttributes,
-      ...(isMany
-        ? {
-            'ai.values': {
-              input: () => (value as string[]).map(v => JSON.stringify(v)),
-            },
-          }
-        : {
-            'ai.value': {
-              input: () => JSON.stringify(value),
-            },
-          }),
+      'gen_ai.operation.name': 'embeddings',
+      'gen_ai.provider.name': providerName,
+      'gen_ai.request.model': event.modelId,
     });
 
-    const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
+    const spanName = `embeddings ${event.modelId}`;
+    const rootSpan = this.tracer.startSpan(spanName, {
+      attributes,
+      kind: SpanKind.CLIENT,
+    });
     const rootContext = trace.setSpan(context.active(), rootSpan);
 
     this.callStates.set(event.callId, {
@@ -492,51 +486,44 @@ export class OpenTelemetry implements Telemetry {
       rootContext,
       stepSpan: undefined,
       stepContext: undefined,
+      inferenceSpan: undefined,
+      inferenceContext: undefined,
       embedSpans: new Map(),
       rerankSpan: undefined,
       toolSpans: new Map(),
-      baseTelemetryAttributes,
       settings,
+      provider: event.provider,
+      modelId: event.modelId,
     });
   }
 
-  onStepStart(event: OtelStepStartEvent): void {
+  onStepStart(event: GenerateTextStepStartEvent<ToolSet>): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan || !state.rootContext) return;
 
     const { telemetry } = state;
+    const stepAttributes = selectAttributes(telemetry, {
+      'gen_ai.operation.name': 'agent_step',
+    });
 
-    const stepOperationId =
-      state.operationId === 'ai.streamText'
-        ? 'ai.streamText.doStream'
-        : 'ai.generateText.doGenerate';
+    state.stepSpan = this.tracer.startSpan(
+      `step ${event.steps.length + 1}`,
+      { attributes: stepAttributes, kind: SpanKind.INTERNAL },
+      state.rootContext,
+    );
+    state.stepContext = trace.setSpan(state.rootContext, state.stepSpan);
+  }
 
-    const attributes = selectAttributes(telemetry, {
-      ...assembleOperationName({
-        operationId: stepOperationId,
-        telemetry,
-      }),
-      ...state.baseTelemetryAttributes,
-      'ai.model.provider': event.provider,
-      'ai.model.id': event.modelId,
+  onLanguageModelCallStart(event: LanguageModelCallStartEvent): void {
+    const state = this.getCallState(event.callId);
+    if (!state?.stepContext) return;
 
-      'ai.prompt.messages': {
-        input: () =>
-          event.promptMessages
-            ? stringifyForTelemetry(event.promptMessages)
-            : undefined,
-      },
-      'ai.prompt.tools': {
-        input: () => event.stepTools?.map(tool => JSON.stringify(tool)),
-      },
-      'ai.prompt.toolChoice': {
-        input: () =>
-          event.stepToolChoice != null
-            ? JSON.stringify(event.stepToolChoice)
-            : undefined,
-      },
+    const { telemetry } = state;
+    const providerName = mapProviderName(event.provider);
 
-      'gen_ai.system': 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 as
         | number
@@ -555,14 +542,75 @@ export class OpenTelemetry implements Telemetry {
         | undefined,
       'gen_ai.request.top_k': state.settings.topK as number | undefined,
       'gen_ai.request.top_p': state.settings.topP as number | undefined,
+      'gen_ai.input.messages': {
+        input: () => {
+          const formattedMessages = formatModelMessages({
+            prompt: undefined,
+            messages: event.messages,
+          });
+
+          return formattedMessages.length > 0
+            ? JSON.stringify(formattedMessages)
+            : undefined;
+        },
+      },
+      'gen_ai.tool.definitions': {
+        input: () => (event.tools ? JSON.stringify(event.tools) : undefined),
+      },
     });
 
-    state.stepSpan = this.tracer.startSpan(
-      stepOperationId,
-      { attributes },
-      state.rootContext,
+    state.inferenceSpan = this.tracer.startSpan(
+      `chat ${event.modelId}`,
+      { attributes: inferenceAttributes, kind: SpanKind.CLIENT },
+      state.stepContext,
+    );
+    state.inferenceContext = trace.setSpan(
+      state.stepContext,
+      state.inferenceSpan,
     );
-    state.stepContext = trace.setSpan(state.rootContext, state.stepSpan);
+  }
+
+  onLanguageModelCallEnd(event: LanguageModelCallEndEvent<ToolSet>): void {
+    const state = this.getCallState(event.callId);
+    if (!state?.inferenceSpan) return;
+
+    const { telemetry } = state;
+
+    state.inferenceSpan.setAttributes(
+      selectAttributes(telemetry, {
+        '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':
+          event.usage.inputTokenDetails?.cacheReadTokens ??
+          event.usage.cachedInputTokens,
+        'gen_ai.usage.cache_creation.input_tokens':
+          event.usage.inputTokenDetails?.cacheWriteTokens,
+        'gen_ai.output.messages': {
+          output: () =>
+            JSON.stringify(
+              formatOutputMessages({
+                text:
+                  event.content
+                    .filter(p => p.type === 'text')
+                    .map(p => p.text)
+                    .join('') || undefined,
+                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,
+              }),
+            ),
+        },
+      }),
+    );
+
+    state.inferenceSpan.end();
+    state.inferenceSpan = undefined;
+    state.inferenceContext = undefined;
   }
 
   onToolExecutionStart(event: ToolExecutionStartEvent<ToolSet>): void {
@@ -573,20 +621,19 @@ export class OpenTelemetry implements Telemetry {
     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),
+      '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(
-      'ai.toolCall',
-      { attributes },
+      spanName,
+      { attributes, kind: SpanKind.INTERNAL },
       state.stepContext,
     );
     const toolContext = trace.setSpan(state.stepContext, toolSpan);
@@ -607,12 +654,13 @@ export class OpenTelemetry implements Telemetry {
     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),
+            'gen_ai.tool.call.result': {
+              output: () => JSON.stringify(toolOutput.output),
             },
           }),
         );
@@ -620,89 +668,17 @@ export class OpenTelemetry implements Telemetry {
         // 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;
 
-    const { telemetry } = state;
-
-    state.stepSpan.setAttributes(
-      selectAttributes(telemetry, {
-        'ai.response.finishReason': event.finishReason,
-        'ai.response.text': {
-          output: () => event.text ?? undefined,
-        },
-        'ai.response.reasoning': {
-          output: () =>
-            event.reasoning.length > 0
-              ? event.reasoning
-                  .filter(part => 'text' in part)
-                  .map(part => part.text)
-                  .join('\n')
-              : undefined,
-        },
-        'ai.response.toolCalls': {
-          output: () =>
-            event.toolCalls.length > 0
-              ? JSON.stringify(
-                  event.toolCalls.map(toolCall => ({
-                    toolCallId: toolCall.toolCallId,
-                    toolName: toolCall.toolName,
-                    input: toolCall.input,
-                  })),
-                )
-              : undefined,
-        },
-        'ai.response.files': {
-          output: () =>
-            event.files.length > 0
-              ? JSON.stringify(
-                  event.files.map(file => ({
-                    type: 'file',
-                    mediaType: file.mediaType,
-                    data: file.base64,
-                  })),
-                )
-              : undefined,
-        },
-        '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)
-          : undefined,
-
-        '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':
-          event.usage.inputTokenDetails?.noCacheTokens,
-        'ai.usage.inputTokenDetails.cacheReadTokens':
-          event.usage.inputTokenDetails?.cacheReadTokens,
-        'ai.usage.inputTokenDetails.cacheWriteTokens':
-          event.usage.inputTokenDetails?.cacheWriteTokens,
-        'ai.usage.outputTokenDetails.textTokens':
-          event.usage.outputTokenDetails?.textTokens,
-        'ai.usage.outputTokenDetails.reasoningTokens':
-          event.usage.outputTokenDetails?.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 = undefined;
     state.stepContext = undefined;
@@ -710,10 +686,10 @@ export class OpenTelemetry implements Telemetry {
 
   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;
@@ -722,12 +698,12 @@ export class OpenTelemetry implements Telemetry {
       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;
     }
 
@@ -735,14 +711,14 @@ export class OpenTelemetry implements Telemetry {
       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;
 
@@ -750,62 +726,26 @@ export class OpenTelemetry implements Telemetry {
 
     state.rootSpan.setAttributes(
       selectAttributes(telemetry, {
-        'ai.response.finishReason': event.finishReason,
-        'ai.response.text': {
-          output: () => event.text ?? undefined,
-        },
-        'ai.response.reasoning': {
-          output: () =>
-            event.reasoning.length > 0
-              ? event.reasoning
-                  .filter(part => 'text' in part)
-                  .map(part => part.text)
-                  .join('\n')
-              : undefined,
-        },
-        'ai.response.toolCalls': {
-          output: () =>
-            event.toolCalls.length > 0
-              ? JSON.stringify(
-                  event.toolCalls.map(toolCall => ({
-                    toolCallId: toolCall.toolCallId,
-                    toolName: toolCall.toolName,
-                    input: toolCall.input,
-                  })),
-                )
-              : undefined,
-        },
-        'ai.response.files': {
+        'gen_ai.response.finish_reasons': [event.finishReason],
+        'gen_ai.usage.input_tokens': event.totalUsage.inputTokens,
+        'gen_ai.usage.output_tokens': event.totalUsage.outputTokens,
+        'gen_ai.usage.cache_read.input_tokens':
+          event.totalUsage.inputTokenDetails?.cacheReadTokens ??
+          event.totalUsage.cachedInputTokens,
+        'gen_ai.usage.cache_creation.input_tokens':
+          event.totalUsage.inputTokenDetails?.cacheWriteTokens,
+        'gen_ai.output.messages': {
           output: () =>
-            event.files.length > 0
-              ? JSON.stringify(
-                  event.files.map(file => ({
-                    type: 'file',
-                    mediaType: file.mediaType,
-                    data: file.base64,
-                  })),
-                )
-              : undefined,
+            JSON.stringify(
+              formatOutputMessages({
+                text: event.text ?? undefined,
+                reasoning: event.reasoning as ReadonlyArray<{ text?: string }>,
+                toolCalls: event.toolCalls,
+                files: event.files,
+                finishReason: event.finishReason,
+              }),
+            ),
         },
-        'ai.response.providerMetadata': event.providerMetadata
-          ? JSON.stringify(event.providerMetadata)
-          : undefined,
-
-        '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':
-          event.totalUsage.inputTokenDetails?.noCacheTokens,
-        'ai.usage.inputTokenDetails.cacheReadTokens':
-          event.totalUsage.inputTokenDetails?.cacheReadTokens,
-        'ai.usage.inputTokenDetails.cacheWriteTokens':
-          event.totalUsage.inputTokenDetails?.cacheWriteTokens,
-        'ai.usage.outputTokenDetails.textTokens':
-          event.totalUsage.outputTokenDetails?.textTokens,
-        'ai.usage.outputTokenDetails.reasoningTokens':
-          event.totalUsage.outputTokenDetails?.reasoningTokens,
       }),
     );
 
@@ -813,7 +753,9 @@ export class OpenTelemetry implements Telemetry {
     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;
 
@@ -821,20 +763,21 @@ export class OpenTelemetry implements Telemetry {
 
     state.rootSpan.setAttributes(
       selectAttributes(telemetry, {
-        'ai.response.finishReason': event.finishReason,
-        'ai.response.object': {
+        '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': event.usage.cachedInputTokens,
+        'gen_ai.output.messages': {
           output: () =>
-            event.object != null ? JSON.stringify(event.object) : undefined,
+            event.object != null
+              ? JSON.stringify(
+                  formatObjectOutputMessages({
+                    objectText: JSON.stringify(event.object),
+                    finishReason: event.finishReason,
+                  }),
+                )
+              : undefined,
         },
-        'ai.response.providerMetadata': event.providerMetadata
-          ? JSON.stringify(event.providerMetadata)
-          : undefined,
-
-        '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,
       }),
     );
 
@@ -842,28 +785,15 @@ export class OpenTelemetry implements Telemetry {
     this.cleanupCallState(event.callId);
   }
 
-  private onEmbedOperationFinish(event: EmbedOnFinishEvent): void {
+  private onEmbedOperationFinish(event: EmbedEndEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan) return;
 
     const { telemetry } = state;
-    const isMany = state.operationId === 'ai.embedMany';
 
     state.rootSpan.setAttributes(
       selectAttributes(telemetry, {
-        ...(isMany
-          ? {
-              'ai.embeddings': {
-                output: () =>
-                  (event.embedding as number[][]).map(e => JSON.stringify(e)),
-              },
-            }
-          : {
-              'ai.embedding': {
-                output: () => JSON.stringify(event.embedding),
-              },
-            }),
-        'ai.usage.tokens': event.usage.tokens,
+        'gen_ai.usage.input_tokens': event.usage.tokens,
       }),
     );
 
@@ -871,26 +801,23 @@ export class OpenTelemetry implements Telemetry {
     this.cleanupCallState(event.callId);
   }
 
-  onEmbedStart(event: EmbedStartEvent): void {
+  onEmbedStart(event: EmbeddingModelCallStartEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan || !state.rootContext) return;
 
     const { telemetry } = state;
+    const providerName = mapProviderName(state.provider);
 
     const attributes = selectAttributes(telemetry, {
-      ...assembleOperationName({
-        operationId: event.operationId,
-        telemetry,
-      }),
-      ...state.baseTelemetryAttributes,
-      'ai.values': {
-        input: () => event.values.map(v => JSON.stringify(v)),
-      },
+      'gen_ai.operation.name': 'embeddings',
+      'gen_ai.provider.name': providerName,
+      'gen_ai.request.model': state.modelId,
     });
 
+    const spanName = `embeddings ${state.modelId}`;
     const embedSpan = this.tracer.startSpan(
-      event.operationId,
-      { attributes },
+      spanName,
+      { attributes, kind: SpanKind.CLIENT },
       state.rootContext,
     );
     const embedContext = trace.setSpan(state.rootContext, embedSpan);
@@ -901,7 +828,7 @@ export class OpenTelemetry implements Telemetry {
     });
   }
 
-  onEmbedFinish(event: EmbedFinishEvent): void {
+  onEmbedFinish(event: EmbeddingModelCallEndEvent): void {
     const state = this.getCallState(event.callId);
     if (!state) return;
 
@@ -913,11 +840,7 @@ export class OpenTelemetry implements Telemetry {
 
     span.setAttributes(
       selectAttributes(telemetry, {
-        'ai.embeddings': {
-          output: () =>
-            event.embeddings.map(embedding => JSON.stringify(embedding)),
-        },
-        'ai.usage.tokens': event.usage.tokens,
+        'gen_ai.usage.input_tokens': event.usage.tokens,
       }),
     );
 
@@ -925,9 +848,10 @@ export class OpenTelemetry implements Telemetry {
     state.embedSpans.delete(event.embedCallId);
   }
 
-  private onRerankOperationStart(event: RerankOnStartEvent): void {
+  private onRerankOperationStart(
+    event: InferTelemetryEvent<RerankStartEvent>,
+  ): void {
     const telemetry: TelemetryOptions = {
-      isEnabled: event.isEnabled,
       recordInputs: event.recordInputs,
       recordOutputs: event.recordOutputs,
       functionId: event.functionId,
@@ -937,25 +861,19 @@ export class OpenTelemetry implements Telemetry {
       maxRetries: event.maxRetries,
     };
 
-    const baseTelemetryAttributes = getBaseTelemetryAttributes({
-      model: { provider: event.provider, modelId: event.modelId },
-      headers: event.headers,
-      settings,
-      context: undefined,
-    });
+    const providerName = mapProviderName(event.provider);
 
     const attributes = selectAttributes(telemetry, {
-      ...assembleOperationName({
-        operationId: event.operationId,
-        telemetry,
-      }),
-      ...baseTelemetryAttributes,
-      'ai.documents': {
-        input: () => event.documents.map(d => JSON.stringify(d)),
-      },
+      'gen_ai.operation.name': 'rerank',
+      'gen_ai.provider.name': providerName,
+      'gen_ai.request.model': event.modelId,
     });
 
-    const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
+    const spanName = `rerank ${event.modelId}`;
+    const rootSpan = this.tracer.startSpan(spanName, {
+      attributes,
+      kind: SpanKind.CLIENT,
+    });
     const rootContext = trace.setSpan(context.active(), rootSpan);
 
     this.callStates.set(event.callId, {
@@ -965,15 +883,18 @@ export class OpenTelemetry implements Telemetry {
       rootContext,
       stepSpan: undefined,
       stepContext: undefined,
+      inferenceSpan: undefined,
+      inferenceContext: undefined,
       embedSpans: new Map(),
       rerankSpan: undefined,
       toolSpans: new Map(),
-      baseTelemetryAttributes,
       settings,
+      provider: event.provider,
+      modelId: event.modelId,
     });
   }
 
-  private onRerankOperationFinish(event: RerankOnFinishEvent): void {
+  private onRerankOperationFinish(event: RerankEndEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan) return;
 
@@ -981,26 +902,23 @@ export class OpenTelemetry implements Telemetry {
     this.cleanupCallState(event.callId);
   }
 
-  onRerankStart(event: RerankStartEvent): void {
+  onRerankStart(event: RerankingModelCallStartEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.rootSpan || !state.rootContext) return;
 
     const { telemetry } = state;
+    const providerName = mapProviderName(state.provider);
 
     const attributes = selectAttributes(telemetry, {
-      ...assembleOperationName({
-        operationId: event.operationId,
-        telemetry,
-      }),
-      ...state.baseTelemetryAttributes,
-      'ai.documents': {
-        input: () => event.documents.map(d => JSON.stringify(d)),
-      },
+      'gen_ai.operation.name': 'rerank',
+      'gen_ai.provider.name': providerName,
+      'gen_ai.request.model': state.modelId,
     });
 
+    const spanName = `rerank ${state.modelId}`;
     const rerankSpan = this.tracer.startSpan(
-      event.operationId,
-      { attributes },
+      spanName,
+      { attributes, kind: SpanKind.CLIENT },
       state.rootContext,
     );
     const rerankContext = trace.setSpan(state.rootContext, rerankSpan);
@@ -1008,57 +926,18 @@ export class OpenTelemetry implements Telemetry {
     state.rerankSpan = { span: rerankSpan, context: rerankContext };
   }
 
-  onRerankFinish(event: RerankFinishEvent): void {
+  onRerankFinish(event: RerankingModelCallEndEvent): void {
     const state = this.getCallState(event.callId);
     if (!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 = undefined;
   }
 
-  onChunk(event: OnChunkEvent<ToolSet>): void {
-    const chunk = event.chunk as {
-      type: string;
-      callId?: unknown;
-      attributes?: unknown;
-    };
-
-    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?.stepSpan) return;
-
-    const attributes = Object.fromEntries(
-      Object.entries(
-        (chunk.attributes as Record<string, unknown>) ?? {},
-      ).filter(([, value]) => value != null),
-    ) as Attributes;
-
-    state.stepSpan.addEvent(chunk.type, attributes);
-    if (Object.keys(attributes).length > 0) {
-      state.stepSpan.setAttributes(attributes);
-    }
+  onChunk(_event: StreamTextChunkEvent<ToolSet>): void {
+    // No-op: streaming chunk events are not part of the GenAI SemConv.
   }
 
   onError(error: unknown): void {
@@ -1070,9 +949,24 @@ export class OpenTelemetry implements Telemetry {
 
     const actualError = event.error ?? error;
 
+    for (const { span: toolSpan } of state.toolSpans.values()) {
+      recordSpanError(toolSpan, actualError);
+      toolSpan.end();
+    }
+    state.toolSpans.clear();
+
+    if (state.inferenceSpan) {
+      recordSpanError(state.inferenceSpan, actualError);
+      state.inferenceSpan.end();
+      state.inferenceSpan = undefined;
+      state.inferenceContext = undefined;
+    }
+
     if (state.stepSpan) {
       recordSpanError(state.stepSpan, actualError);
       state.stepSpan.end();
+      state.stepSpan = undefined;
+      state.stepContext = undefined;
     }
 
     for (const { span: embedSpan } of state.embedSpans.values()) {