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

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

@@ -6,45 +6,39 @@ import {
   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,
+  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 {
-  formatInputMessages,
-  formatModelMessages,
-  formatObjectOutputMessages,
-  formatOutputMessages,
-  formatSystemInstructions,
-  mapOperationName,
-  mapProviderName,
-} from './gen-ai-format-messages';
+import { assembleOperationName } from './assemble-operation-name';
+import { getBaseTelemetryAttributes } from './get-base-telemetry-attributes';
+import { stringifyForTelemetry } from './stringify-for-telemetry';
 
 function recordSpanError(span: Span, error: unknown): void {
   if (error instanceof Error) {
@@ -119,7 +113,7 @@ interface OtelStepStartEvent<
   TOOLS extends ToolSet = ToolSet,
   RUNTIME_CONTEXT extends AISDKContext = AISDKContext,
   OUTPUT extends Output = Output,
-> extends OnStepStartEvent<TOOLS, RUNTIME_CONTEXT, OUTPUT> {
+> extends GenerateTextStepStartEvent<TOOLS, RUNTIME_CONTEXT, OUTPUT> {
   readonly promptMessages?: LanguageModelV4Prompt;
   readonly stepTools?: ReadonlyArray<Record<string, unknown>>;
   readonly stepToolChoice?: unknown;
@@ -135,14 +129,16 @@ interface CallState {
   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 GenAIOpenTelemetry implements Telemetry {
+export class LegacyOpenTelemetry implements Telemetry {
   private readonly callStates = new Map<string, CallState>();
 
+  /**
+   * The tracer to use for the telemetry data.
+   */
   private readonly tracer: Tracer;
 
   constructor(
@@ -150,7 +146,7 @@ export class GenAIOpenTelemetry implements Telemetry {
       tracer?: Tracer;
     } = {},
   ) {
-    this.tracer = options.tracer ?? trace.getTracer('gen_ai');
+    this.tracer = options.tracer ?? trace.getTracer('ai');
   }
 
   private getCallState(callId: string): CallState | undefined {
@@ -181,23 +177,23 @@ export class GenAIOpenTelemetry 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;
     }
 
@@ -205,16 +201,19 @@ export class GenAIOpenTelemetry 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,
@@ -232,46 +231,31 @@ export class GenAIOpenTelemetry implements Telemetry {
       maxRetries: event.maxRetries,
     };
 
-    const providerName = mapProviderName(event.provider);
-    const operationName = mapOperationName(event.operationId);
+    const baseTelemetryAttributes = getBaseTelemetryAttributes({
+      model: { provider: event.provider, modelId: event.modelId },
+      headers: event.headers,
+      settings,
+      context: event.runtimeContext as Record<string, unknown> | undefined,
+    });
 
     const attributes = selectAttributes(telemetry, {
-      'gen_ai.operation.name': operationName,
-      'gen_ai.provider.name': providerName,
-      'gen_ai.request.model': event.modelId,
-      'gen_ai.agent.name': telemetry.functionId,
-      'gen_ai.request.frequency_penalty': event.frequencyPenalty,
-      'gen_ai.request.max_tokens': event.maxOutputTokens,
-      'gen_ai.request.presence_penalty': event.presencePenalty,
-      'gen_ai.request.temperature': (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': {
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry,
+      }),
+      ...baseTelemetryAttributes,
+      'ai.model.provider': event.provider,
+      'ai.model.id': event.modelId,
+      'ai.prompt': {
         input: () =>
-          JSON.stringify(
-            formatModelMessages({
-              prompt: event.prompt,
-              messages: event.messages,
-            }),
-          ),
+          JSON.stringify({
+            system: event.system,
+            messages: event.messages,
+          }),
       },
     });
 
-    const spanName = `${operationName} ${event.modelId}`;
-    const rootSpan = this.tracer.startSpan(spanName, {
-      attributes,
-      kind: SpanKind.INTERNAL,
-    });
+    const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
     const rootContext = trace.setSpan(context.active(), rootSpan);
 
     this.callStates.set(event.callId, {
@@ -284,15 +268,15 @@ export class GenAIOpenTelemetry implements Telemetry {
       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,
@@ -309,46 +293,36 @@ export class GenAIOpenTelemetry implements Telemetry {
       maxRetries: event.maxRetries,
     };
 
-    const providerName = mapProviderName(event.provider);
-    const operationName = mapOperationName(event.operationId);
+    const baseTelemetryAttributes = getBaseTelemetryAttributes({
+      model: { provider: event.provider, modelId: event.modelId },
+      headers: event.headers,
+      settings,
+      context: undefined,
+    });
 
     const attributes = selectAttributes(telemetry, {
-      'gen_ai.operation.name': operationName,
-      'gen_ai.provider.name': providerName,
-      'gen_ai.request.model': event.modelId,
-      'gen_ai.agent.name': telemetry.functionId,
-      'gen_ai.output.type': 'json',
-      'gen_ai.request.frequency_penalty': event.frequencyPenalty,
-      'gen_ai.request.max_tokens': event.maxOutputTokens,
-      'gen_ai.request.presence_penalty': event.presencePenalty,
-      'gen_ai.request.temperature': (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': {
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry,
+      }),
+      ...baseTelemetryAttributes,
+      'ai.prompt': {
         input: () =>
-          JSON.stringify(
-            formatModelMessages({
-              prompt: event.prompt,
-              messages: event.messages,
-            }),
-          ),
+          JSON.stringify({
+            system: event.system,
+            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 spanName = `${operationName} ${event.modelId}`;
-    const rootSpan = this.tracer.startSpan(spanName, {
-      attributes,
-      kind: SpanKind.INTERNAL,
-    });
+    const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
     const rootContext = trace.setSpan(context.active(), rootSpan);
 
     this.callStates.set(event.callId, {
@@ -361,25 +335,38 @@ export class GenAIOpenTelemetry implements Telemetry {
       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 providerName = mapProviderName(event.provider);
+
+    const stepOperationId =
+      state.operationId === 'ai.streamObject'
+        ? 'ai.streamObject.doStream'
+        : 'ai.generateObject.doGenerate';
 
     const attributes = selectAttributes(telemetry, {
-      'gen_ai.operation.name': 'chat',
-      'gen_ai.provider.name': providerName,
+      ...assembleOperationName({
+        operationId: stepOperationId,
+        telemetry,
+      }),
+      ...state.baseTelemetryAttributes,
+      'ai.prompt.messages': {
+        input: () =>
+          event.promptMessages
+            ? stringifyForTelemetry(event.promptMessages)
+            : undefined,
+      },
+
+      'gen_ai.system': event.provider,
       'gen_ai.request.model': event.modelId,
-      'gen_ai.output.type': 'json',
       'gen_ai.request.frequency_penalty': state.settings.frequencyPenalty as
         | number
         | undefined,
@@ -394,25 +381,18 @@ export class GenAIOpenTelemetry 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,
-      },
     });
 
-    const spanName = `chat ${event.modelId}`;
     state.stepSpan = this.tracer.startSpan(
-      spanName,
-      { attributes, kind: SpanKind.CLIENT },
+      stepOperationId,
+      { attributes },
       state.rootContext,
     );
     state.stepContext = trace.setSpan(state.rootContext, state.stepSpan);
   }
 
   /** @deprecated */
-  onObjectStepFinish(event: ObjectOnStepFinishEvent): void {
+  onObjectStepFinish(event: GenerateObjectStepEndEvent): void {
     const state = this.getCallState(event.callId);
     if (!state?.stepSpan) return;
 
@@ -420,37 +400,55 @@ export class GenAIOpenTelemetry implements Telemetry {
 
     state.stepSpan.setAttributes(
       selectAttributes(telemetry, {
-        'gen_ai.response.finish_reasons': [event.finishReason],
-        'gen_ai.response.id': event.response.id,
-        'gen_ai.response.model': event.response.modelId,
-        'gen_ai.usage.input_tokens': event.usage.inputTokens,
-        'gen_ai.usage.output_tokens': event.usage.outputTokens,
-        'gen_ai.usage.cache_read.input_tokens': event.usage.cachedInputTokens,
-        'gen_ai.output.messages': {
+        'ai.response.finishReason': event.finishReason,
+        'ai.response.object': {
           output: () => {
             try {
-              return JSON.stringify(
-                formatObjectOutputMessages({
-                  objectText: event.objectText,
-                  finishReason: event.finishReason,
-                }),
-              );
+              return JSON.stringify(JSON.parse(event.objectText));
             } 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;
   }
 
-  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,
@@ -460,19 +458,36 @@ export class GenAIOpenTelemetry implements Telemetry {
       maxRetries: event.maxRetries,
     };
 
-    const providerName = mapProviderName(event.provider);
+    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 attributes = selectAttributes(telemetry, {
-      'gen_ai.operation.name': 'embeddings',
-      'gen_ai.provider.name': providerName,
-      'gen_ai.request.model': event.modelId,
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry,
+      }),
+      ...baseTelemetryAttributes,
+      ...(isMany
+        ? {
+            'ai.values': {
+              input: () => (value as string[]).map(v => JSON.stringify(v)),
+            },
+          }
+        : {
+            'ai.value': {
+              input: () => JSON.stringify(value),
+            },
+          }),
     });
 
-    const spanName = `embeddings ${event.modelId}`;
-    const rootSpan = this.tracer.startSpan(spanName, {
-      attributes,
-      kind: SpanKind.CLIENT,
-    });
+    const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
     const rootContext = trace.setSpan(context.active(), rootSpan);
 
     this.callStates.set(event.callId, {
@@ -485,9 +500,8 @@ export class GenAIOpenTelemetry implements Telemetry {
       embedSpans: new Map(),
       rerankSpan: undefined,
       toolSpans: new Map(),
+      baseTelemetryAttributes,
       settings,
-      provider: event.provider,
-      modelId: event.modelId,
     });
   }
 
@@ -496,11 +510,38 @@ export class GenAIOpenTelemetry implements Telemetry {
     if (!state?.rootSpan || !state.rootContext) return;
 
     const { telemetry } = state;
-    const providerName = mapProviderName(event.provider);
+
+    const stepOperationId =
+      state.operationId === 'ai.streamText'
+        ? 'ai.streamText.doStream'
+        : 'ai.generateText.doGenerate';
 
     const attributes = selectAttributes(telemetry, {
-      'gen_ai.operation.name': 'chat',
-      'gen_ai.provider.name': providerName,
+      ...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)
+            : undefined,
+      },
+      'ai.prompt.tools': {
+        input: () => event.stepTools?.map(tool => JSON.stringify(tool)),
+      },
+      'ai.prompt.toolChoice': {
+        input: () =>
+          event.stepToolChoice != null
+            ? JSON.stringify(event.stepToolChoice)
+            : undefined,
+      },
+
+      'gen_ai.system': event.provider,
       'gen_ai.request.model': event.modelId,
       'gen_ai.request.frequency_penalty': state.settings.frequencyPenalty as
         | number
@@ -519,22 +560,11 @@ export class GenAIOpenTelemetry 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,
-      },
-      'gen_ai.tool.definitions': {
-        input: () =>
-          event.stepTools ? JSON.stringify(event.stepTools) : undefined,
-      },
     });
 
-    const spanName = `chat ${event.modelId}`;
     state.stepSpan = this.tracer.startSpan(
-      spanName,
-      { attributes, kind: SpanKind.CLIENT },
+      stepOperationId,
+      { attributes },
       state.rootContext,
     );
     state.stepContext = trace.setSpan(state.rootContext, state.stepSpan);
@@ -548,19 +578,20 @@ export class GenAIOpenTelemetry implements Telemetry {
     const { toolCall } = event;
 
     const attributes = selectAttributes(telemetry, {
-      'gen_ai.operation.name': 'execute_tool',
-      'gen_ai.tool.name': toolCall.toolName,
-      'gen_ai.tool.call.id': toolCall.toolCallId,
-      'gen_ai.tool.type': 'function',
-      'gen_ai.tool.call.arguments': {
-        input: () => JSON.stringify(toolCall.input),
+      ...assembleOperationName({
+        operationId: 'ai.toolCall',
+        telemetry,
+      }),
+      'ai.toolCall.name': toolCall.toolName,
+      'ai.toolCall.id': toolCall.toolCallId,
+      'ai.toolCall.args': {
+        output: () => JSON.stringify(toolCall.input),
       },
     });
 
-    const spanName = `execute_tool ${toolCall.toolName}`;
     const toolSpan = this.tracer.startSpan(
-      spanName,
-      { attributes, kind: SpanKind.INTERNAL },
+      'ai.toolCall',
+      { attributes },
       state.stepContext,
     );
     const toolContext = trace.setSpan(state.stepContext, toolSpan);
@@ -581,12 +612,13 @@ export class GenAIOpenTelemetry implements Telemetry {
     const { span } = toolSpanEntry;
     const { telemetry } = state;
 
-    if (event.success) {
+    const { toolOutput } = event;
+    if (toolOutput.type === 'tool-result') {
       try {
         span.setAttributes(
           selectAttributes(telemetry, {
-            'gen_ai.tool.call.result': {
-              output: () => JSON.stringify(event.output),
+            'ai.toolCall.result': {
+              output: () => JSON.stringify(toolOutput.output),
             },
           }),
         );
@@ -594,14 +626,14 @@ export class GenAIOpenTelemetry 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;
 
@@ -609,28 +641,71 @@ export class GenAIOpenTelemetry implements Telemetry {
 
     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,
-        '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.text ?? undefined,
-                reasoning: event.reasoning as ReadonlyArray<{ text?: string }>,
-                toolCalls: event.toolCalls,
-                files: event.files,
-                finishReason: event.finishReason,
-              }),
-            ),
-        },
       }),
     );
 
@@ -641,10 +716,10 @@ export class GenAIOpenTelemetry 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;
@@ -653,12 +728,12 @@ export class GenAIOpenTelemetry 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;
     }
 
@@ -666,14 +741,14 @@ export class GenAIOpenTelemetry 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;
 
@@ -681,26 +756,62 @@ export class GenAIOpenTelemetry implements Telemetry {
 
     state.rootSpan.setAttributes(
       selectAttributes(telemetry, {
-        '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': {
+        '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: () =>
-            JSON.stringify(
-              formatOutputMessages({
-                text: event.text ?? undefined,
-                reasoning: event.reasoning as ReadonlyArray<{ text?: string }>,
-                toolCalls: event.toolCalls,
-                files: event.files,
-                finishReason: event.finishReason,
-              }),
-            ),
+            event.files.length > 0
+              ? JSON.stringify(
+                  event.files.map(file => ({
+                    type: 'file',
+                    mediaType: file.mediaType,
+                    data: file.base64,
+                  })),
+                )
+              : undefined,
         },
+        '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,
       }),
     );
 
@@ -708,7 +819,9 @@ export class GenAIOpenTelemetry 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;
 
@@ -716,21 +829,20 @@ export class GenAIOpenTelemetry implements Telemetry {
 
     state.rootSpan.setAttributes(
       selectAttributes(telemetry, {
-        'gen_ai.response.finish_reasons': [event.finishReason],
-        'gen_ai.usage.input_tokens': event.usage.inputTokens,
-        'gen_ai.usage.output_tokens': event.usage.outputTokens,
-        'gen_ai.usage.cache_read.input_tokens': event.usage.cachedInputTokens,
-        'gen_ai.output.messages': {
+        'ai.response.finishReason': event.finishReason,
+        'ai.response.object': {
           output: () =>
-            event.object != null
-              ? JSON.stringify(
-                  formatObjectOutputMessages({
-                    objectText: JSON.stringify(event.object),
-                    finishReason: event.finishReason,
-                  }),
-                )
-              : undefined,
+            event.object != null ? JSON.stringify(event.object) : 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,
       }),
     );
 
@@ -738,15 +850,28 @@ export class GenAIOpenTelemetry 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, {
-        'gen_ai.usage.input_tokens': event.usage.tokens,
+        ...(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,
       }),
     );
 
@@ -754,23 +879,26 @@ export class GenAIOpenTelemetry 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, {
-      'gen_ai.operation.name': 'embeddings',
-      'gen_ai.provider.name': providerName,
-      'gen_ai.request.model': state.modelId,
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry,
+      }),
+      ...state.baseTelemetryAttributes,
+      'ai.values': {
+        input: () => event.values.map(v => JSON.stringify(v)),
+      },
     });
 
-    const spanName = `embeddings ${state.modelId}`;
     const embedSpan = this.tracer.startSpan(
-      spanName,
-      { attributes, kind: SpanKind.CLIENT },
+      event.operationId,
+      { attributes },
       state.rootContext,
     );
     const embedContext = trace.setSpan(state.rootContext, embedSpan);
@@ -781,7 +909,7 @@ export class GenAIOpenTelemetry implements Telemetry {
     });
   }
 
-  onEmbedFinish(event: EmbedFinishEvent): void {
+  onEmbedFinish(event: EmbeddingModelCallEndEvent): void {
     const state = this.getCallState(event.callId);
     if (!state) return;
 
@@ -793,7 +921,11 @@ export class GenAIOpenTelemetry implements Telemetry {
 
     span.setAttributes(
       selectAttributes(telemetry, {
-        'gen_ai.usage.input_tokens': event.usage.tokens,
+        'ai.embeddings': {
+          output: () =>
+            event.embeddings.map(embedding => JSON.stringify(embedding)),
+        },
+        'ai.usage.tokens': event.usage.tokens,
       }),
     );
 
@@ -801,9 +933,10 @@ export class GenAIOpenTelemetry 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,
@@ -813,19 +946,25 @@ export class GenAIOpenTelemetry implements Telemetry {
       maxRetries: event.maxRetries,
     };
 
-    const providerName = mapProviderName(event.provider);
+    const baseTelemetryAttributes = getBaseTelemetryAttributes({
+      model: { provider: event.provider, modelId: event.modelId },
+      headers: event.headers,
+      settings,
+      context: undefined,
+    });
 
     const attributes = selectAttributes(telemetry, {
-      'gen_ai.operation.name': 'rerank',
-      'gen_ai.provider.name': providerName,
-      'gen_ai.request.model': event.modelId,
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry,
+      }),
+      ...baseTelemetryAttributes,
+      'ai.documents': {
+        input: () => event.documents.map(d => JSON.stringify(d)),
+      },
     });
 
-    const spanName = `rerank ${event.modelId}`;
-    const rootSpan = this.tracer.startSpan(spanName, {
-      attributes,
-      kind: SpanKind.CLIENT,
-    });
+    const rootSpan = this.tracer.startSpan(event.operationId, { attributes });
     const rootContext = trace.setSpan(context.active(), rootSpan);
 
     this.callStates.set(event.callId, {
@@ -838,13 +977,12 @@ export class GenAIOpenTelemetry implements Telemetry {
       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;
 
@@ -852,23 +990,26 @@ export class GenAIOpenTelemetry 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, {
-      'gen_ai.operation.name': 'rerank',
-      'gen_ai.provider.name': providerName,
-      'gen_ai.request.model': state.modelId,
+      ...assembleOperationName({
+        operationId: event.operationId,
+        telemetry,
+      }),
+      ...state.baseTelemetryAttributes,
+      'ai.documents': {
+        input: () => event.documents.map(d => JSON.stringify(d)),
+      },
     });
 
-    const spanName = `rerank ${state.modelId}`;
     const rerankSpan = this.tracer.startSpan(
-      spanName,
-      { attributes, kind: SpanKind.CLIENT },
+      event.operationId,
+      { attributes },
       state.rootContext,
     );
     const rerankContext = trace.setSpan(state.rootContext, rerankSpan);
@@ -876,18 +1017,57 @@ export class GenAIOpenTelemetry 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 {
-    // No-op: streaming chunk events are not part of the GenAI SemConv.
+  onChunk(event: StreamTextChunkEvent<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);
+    }
   }
 
   onError(error: unknown): void {