@livekit/agents 1.0.21 → 1.0.23

package/src/voice/agent_session.ts

@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0
 import type { AudioFrame, Room } from '@livekit/rtc-node';
 import type { TypedEventEmitter as TypedEmitter } from '@livekit/typed-emitter';
+import type { Context, Span } from '@opentelemetry/api';
+import { ROOT_CONTEXT, context as otelContext, trace } from '@opentelemetry/api';
 import { EventEmitter } from 'node:events';
 import type { ReadableStream } from 'node:stream/web';
 import {
@@ -14,12 +16,14 @@ import {
   type TTSModelString,
 } from '../inference/index.js';
 import { getJobContext } from '../job.js';
+import type { FunctionCall, FunctionCallOutput } from '../llm/chat_context.js';
 import { AgentHandoffItem, ChatContext, ChatMessage } from '../llm/chat_context.js';
 import type { LLM, RealtimeModel, RealtimeModelError, ToolChoice } from '../llm/index.js';
 import type { LLMError } from '../llm/llm.js';
 import { log } from '../log.js';
 import type { STT } from '../stt/index.js';
 import type { STTError } from '../stt/stt.js';
+import { traceTypes, tracer } from '../telemetry/index.js';
 import type { TTS, TTSError } from '../tts/tts.js';
 import type { VAD } from '../vad.js';
 import type { Agent } from './agent.js';
@@ -128,9 +132,22 @@ export class AgentSession<
   private closingTask: Promise<void> | null = null;
   private userAwayTimer: NodeJS.Timeout | null = null;
 
+  private sessionSpan?: Span;
+  private userSpeakingSpan?: Span;
+  private agentSpeakingSpan?: Span;
+
+  /** @internal */
+  rootSpanContext?: Context;
+
   /** @internal */
   _recordedEvents: AgentEvent[] = [];
 
+  /** @internal */
+  _enableRecording = false;
+
+  /** @internal - Timestamp when the session started (milliseconds) */
+  _startedAt?: number;
+
   constructor(opts: AgentSessionOptions<UserData>) {
     super();
 
@@ -175,7 +192,8 @@ export class AgentSession<
     this._chatCtx = ChatContext.empty();
     this.options = { ...defaultVoiceOptions, ...voiceOptions };
 
-    this.on(AgentSessionEventTypes.UserInputTranscribed, this._onUserInputTranscribed.bind(this));
+    this._onUserInputTranscribed = this._onUserInputTranscribed.bind(this);
+    this.on(AgentSessionEventTypes.UserInputTranscribed, this._onUserInputTranscribed);
   }
 
   emit<K extends keyof AgentSessionCallbacks>(
@@ -211,25 +229,22 @@ export class AgentSession<
     this._userData = value;
   }
 
-  async start({
-    // TODO(brian): PR2 - Add setupCloudTracer() call if on LiveKit Cloud with recording enabled
-    // TODO(brian): PR3 - Add span: this._sessionSpan = tracer.startSpan('agent_session'), store as instance property
-    // TODO(brian): PR4 - Add setupCloudLogger() call in setupCloudTracer() to setup OTEL logging with Pino bridge
+  private async _startImpl({
     agent,
     room,
     inputOptions,
     outputOptions,
-    record = true,
+    record,
+    span,
   }: {
     agent: Agent;
     room: Room;
     inputOptions?: Partial<RoomInputOptions>;
     outputOptions?: Partial<RoomOutputOptions>;
-    record?: boolean;
+    record: boolean;
+    span: Span;
   }): Promise<void> {
-    if (this.started) {
-      return;
-    }
+    span.setAttribute(traceTypes.ATTR_AGENT_LABEL, agent.id);
 
     this.agent = agent;
     this._updateAgentState('initializing');
@@ -291,9 +306,62 @@ export class AgentSession<
     );
 
     this.started = true;
+    this._startedAt = Date.now();
     this._updateAgentState('listening');
   }
 
+  async start({
+    agent,
+    room,
+    inputOptions,
+    outputOptions,
+    record = true,
+  }: {
+    agent: Agent;
+    room: Room;
+    inputOptions?: Partial<RoomInputOptions>;
+    outputOptions?: Partial<RoomOutputOptions>;
+    record?: boolean;
+  }): Promise<void> {
+    if (this.started) {
+      return;
+    }
+
+    const ctx = getJobContext();
+
+    record = record ?? ctx.info.job.enableRecording;
+    this._enableRecording = record;
+
+    this.logger.info(
+      { record, enableRecording: ctx.info.job.enableRecording },
+      'Configuring session recording',
+    );
+
+    if (this._enableRecording) {
+      await ctx.initRecording();
+    }
+
+    // Create agent_session as a ROOT span (new trace) to match Python behavior
+    // This creates a separate trace for better cloud dashboard organization
+    this.sessionSpan = tracer.startSpan({
+      name: 'agent_session',
+      context: ROOT_CONTEXT,
+    });
+
+    // Set the session span as the active span in the context
+    // This ensures all child spans (agent_turn, user_turn, etc.) are parented to it
+    this.rootSpanContext = trace.setSpan(ROOT_CONTEXT, this.sessionSpan);
+
+    await this._startImpl({
+      agent,
+      room,
+      inputOptions,
+      outputOptions,
+      record,
+      span: this.sessionSpan,
+    });
+  }
+
   updateAgent(agent: Agent): void {
     this.agent = agent;
 
@@ -367,32 +435,41 @@ export class AgentSession<
   }
 
   private async updateActivity(agent: Agent): Promise<void> {
-    // TODO(AJS-129): add lock to agent activity core lifecycle
-    this.nextActivity = new AgentActivity(agent, this);
+    const runWithContext = async () => {
+      // TODO(AJS-129): add lock to agent activity core lifecycle
+      this.nextActivity = new AgentActivity(agent, this);
 
-    const previousActivity = this.activity;
+      const previousActivity = this.activity;
 
-    if (this.activity) {
-      await this.activity.drain();
-      await this.activity.close();
-    }
+      if (this.activity) {
+        await this.activity.drain();
+        await this.activity.close();
+      }
 
-    this.activity = this.nextActivity;
-    this.nextActivity = undefined;
+      this.activity = this.nextActivity;
+      this.nextActivity = undefined;
 
-    this._chatCtx.insert(
-      new AgentHandoffItem({
-        oldAgentId: previousActivity?.agent.id,
-        newAgentId: agent.id,
-      }),
-    );
-    this.logger.debug({ previousActivity, agent }, 'Agent handoff inserted into chat context');
+      this._chatCtx.insert(
+        new AgentHandoffItem({
+          oldAgentId: previousActivity?.agent.id,
+          newAgentId: agent.id,
+        }),
+      );
+      this.logger.debug({ previousActivity, agent }, 'Agent handoff inserted into chat context');
 
-    await this.activity.start();
+      await this.activity.start();
 
-    if (this._input.audio) {
-      this.activity.attachAudioInput(this._input.audio.stream);
+      if (this._input.audio) {
+        this.activity.attachAudioInput(this._input.audio.stream);
+      }
+    };
+
+    // Run within session span context if available
+    if (this.rootSpanContext) {
+      return otelContext.with(this.rootSpanContext, runWithContext);
     }
+
+    return runWithContext();
   }
 
   get chatCtx(): ChatContext {
@@ -452,14 +529,35 @@ export class AgentSession<
     this.emit(AgentSessionEventTypes.ConversationItemAdded, createConversationItemAddedEvent(item));
   }
 
+  /** @internal */
+  _toolItemsAdded(items: (FunctionCall | FunctionCallOutput)[]): void {
+    this._chatCtx.insert(items);
+  }
+
   /** @internal */
   _updateAgentState(state: AgentState) {
     if (this._agentState === state) {
       return;
     }
 
-    // TODO(brian): PR3 - Add span: if state === 'speaking' && !this._agentSpeakingSpan, create tracer.startSpan('agent_speaking') with participant attributes
-    // TODO(brian): PR3 - Add span: if state !== 'speaking' && this._agentSpeakingSpan, end and clear this._agentSpeakingSpan
+    if (state === 'speaking') {
+      // TODO(brian): PR4 - Track error counts
+
+      if (this.agentSpeakingSpan === undefined) {
+        this.agentSpeakingSpan = tracer.startSpan({
+          name: 'agent_speaking',
+          context: this.rootSpanContext,
+        });
+
+        // TODO(brian): PR4 - Set participant attributes if roomIO.room.localParticipant is available
+        // (Ref: Python agent_session.py line 1161-1164)
+      }
+    } else if (this.agentSpeakingSpan !== undefined) {
+      // TODO(brian): PR4 - Set ATTR_END_TIME attribute if available
+      this.agentSpeakingSpan.end();
+      this.agentSpeakingSpan = undefined;
+    }
+
     const oldState = this._agentState;
     this._agentState = state;
 
@@ -482,8 +580,20 @@ export class AgentSession<
       return;
     }
 
-    // TODO(brian): PR3 - Add span: if state === 'speaking' && !this._userSpeakingSpan, create tracer.startSpan('user_speaking') with participant attributes
-    // TODO(brian): PR3 - Add span: if state !== 'speaking' && this._userSpeakingSpan, end and clear this._userSpeakingSpan
+    if (state === 'speaking' && this.userSpeakingSpan === undefined) {
+      this.userSpeakingSpan = tracer.startSpan({
+        name: 'user_speaking',
+        context: this.rootSpanContext,
+      });
+
+      // TODO(brian): PR4 - Set participant attributes if roomIO.linkedParticipant is available
+      // (Ref: Python agent_session.py line 1192-1195)
+    } else if (this.userSpeakingSpan !== undefined) {
+      // TODO(brian): PR4 - Set ATTR_END_TIME attribute with lastSpeakingTime if available
+      this.userSpeakingSpan.end();
+      this.userSpeakingSpan = undefined;
+    }
+
     const oldState = this.userState;
     this.userState = state;
 
@@ -550,19 +660,33 @@ export class AgentSession<
     reason: CloseReason,
     error: RealtimeModelError | LLMError | TTSError | STTError | null = null,
     drain: boolean = false,
+  ): Promise<void> {
+    if (this.rootSpanContext) {
+      return otelContext.with(this.rootSpanContext, async () => {
+        await this.closeImplInner(reason, error, drain);
+      });
+    }
+
+    return this.closeImplInner(reason, error, drain);
+  }
+
+  private async closeImplInner(
+    reason: CloseReason,
+    error: RealtimeModelError | LLMError | TTSError | STTError | null = null,
+    drain: boolean = false,
   ): Promise<void> {
     if (!this.started) {
       return;
     }
 
     this._cancelUserAwayTimer();
+    this.off(AgentSessionEventTypes.UserInputTranscribed, this._onUserInputTranscribed);
 
     if (this.activity) {
       if (!drain) {
         try {
           this.activity.interrupt();
         } catch (error) {
-          // uninterruptible speech [copied from python]
           // TODO(shubhra): force interrupt or wait for it to finish?
           // it might be an audio played from the error callback
         }
@@ -584,12 +708,28 @@ export class AgentSession<
     await this.activity?.close();
     this.activity = undefined;
 
+    if (this.sessionSpan) {
+      this.sessionSpan.end();
+      this.sessionSpan = undefined;
+    }
+
+    if (this.userSpeakingSpan) {
+      this.userSpeakingSpan.end();
+      this.userSpeakingSpan = undefined;
+    }
+
+    if (this.agentSpeakingSpan) {
+      this.agentSpeakingSpan.end();
+      this.agentSpeakingSpan = undefined;
+    }
+
     this.started = false;
 
     this.emit(AgentSessionEventTypes.Close, createCloseEvent(reason, error));
 
     this.userState = 'listening';
     this._agentState = 'initializing';
+    this.rootSpanContext = undefined;
 
     this.logger.info({ reason, error }, 'AgentSession closed');
   }

package/src/voice/audio_recognition.ts

@@ -2,6 +2,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 import { AudioFrame } from '@livekit/rtc-node';
+import type { Context, Span } from '@opentelemetry/api';
 import type { WritableStreamDefaultWriter } from 'node:stream/web';
 import { ReadableStream } from 'node:stream/web';
 import { type ChatContext } from '../llm/chat_context.js';
@@ -10,6 +11,7 @@ import { DeferredReadableStream, isStreamReaderReleaseError } from '../stream/de
 import { IdentityTransform } from '../stream/identity_transform.js';
 import { mergeReadableStreams } from '../stream/merge_readable_streams.js';
 import { type SpeechEvent, SpeechEventType } from '../stt/stt.js';
+import { traceTypes, tracer } from '../telemetry/index.js';
 import { Task, delay } from '../utils.js';
 import { type VAD, type VADEvent, VADEventType } from '../vad.js';
 import type { TurnDetectionMode } from './agent_session.js';
@@ -55,10 +57,9 @@ export interface AudioRecognitionOptions {
   turnDetectionMode?: Exclude<TurnDetectionMode, _TurnDetector>;
   minEndpointingDelay: number;
   maxEndpointingDelay: number;
+  rootSpanContext?: Context;
 }
 
-// TODO(brian): PR3 - Add span: private _userTurnSpan?: Span, create lazily in _ensureUserTurnSpan() method (tracer.startSpan('user_turn') with participant attributes)
-// TODO(brian): PR3 - Add span: 'eou_detection' span when running EOU detection (in runEOUDetection method)
 export class AudioRecognition {
   private hooks: RecognitionHooks;
   private stt?: STTNode;
@@ -68,6 +69,7 @@ export class AudioRecognition {
   private minEndpointingDelay: number;
   private maxEndpointingDelay: number;
   private lastLanguage?: string;
+  private rootSpanContext?: Context;
 
   private deferredInputStream: DeferredReadableStream<AudioFrame>;
   private logger = log();
@@ -82,6 +84,8 @@ export class AudioRecognition {
   private speaking = false;
   private sampleRate?: number;
 
+  private userTurnSpan?: Span;
+
   private vadInputStream: ReadableStream<AudioFrame>;
   private sttInputStream: ReadableStream<AudioFrame>;
   private silenceAudioTransform = new IdentityTransform<AudioFrame>();
@@ -102,6 +106,7 @@ export class AudioRecognition {
     this.minEndpointingDelay = opts.minEndpointingDelay;
     this.maxEndpointingDelay = opts.maxEndpointingDelay;
     this.lastLanguage = undefined;
+    this.rootSpanContext = opts.rootSpanContext;
 
     this.deferredInputStream = new DeferredReadableStream<AudioFrame>();
     const [vadInputStream, sttInputStream] = this.deferredInputStream.stream.tee();
@@ -357,31 +362,47 @@ export class AudioRecognition {
         let endpointingDelay = this.minEndpointingDelay;
 
         if (turnDetector) {
-          this.logger.debug('Running turn detector model');
-          if (!(await turnDetector.supportsLanguage(this.lastLanguage))) {
-            this.logger.debug(`Turn detector does not support language ${this.lastLanguage}`);
-          } else {
-            const endOfTurnProbability = await turnDetector.predictEndOfTurn(chatCtx);
-            this.logger.debug(
-              { endOfTurnProbability, language: this.lastLanguage },
-              'end of turn probability',
-            );
-
-            const unlikelyThreshold = await turnDetector.unlikelyThreshold(this.lastLanguage);
-            this.logger.debug(
-              {
-                unlikelyThreshold,
-                endOfTurnProbability,
-                language: this.lastLanguage,
-                transcript: this.audioTranscript,
-              },
-              'EOU Detection',
-            );
+          await tracer.startActiveSpan(
+            async (span) => {
+              this.logger.debug('Running turn detector model');
+
+              let endOfTurnProbability = 0.0;
+              let unlikelyThreshold: number | undefined;
+
+              if (!(await turnDetector.supportsLanguage(this.lastLanguage))) {
+                this.logger.debug(`Turn detector does not support language ${this.lastLanguage}`);
+              } else {
+                try {
+                  endOfTurnProbability = await turnDetector.predictEndOfTurn(chatCtx);
+                  unlikelyThreshold = await turnDetector.unlikelyThreshold(this.lastLanguage);
+
+                  this.logger.debug(
+                    { endOfTurnProbability, unlikelyThreshold, language: this.lastLanguage },
+                    'end of turn probability',
+                  );
+
+                  if (unlikelyThreshold && endOfTurnProbability < unlikelyThreshold) {
+                    endpointingDelay = this.maxEndpointingDelay;
+                  }
+                } catch (error) {
+                  this.logger.error(error, 'Error predicting end of turn');
+                }
+              }
 
-            if (unlikelyThreshold && endOfTurnProbability < unlikelyThreshold) {
-              endpointingDelay = this.maxEndpointingDelay;
-            }
-          }
+              span.setAttribute(
+                traceTypes.ATTR_CHAT_CTX,
+                JSON.stringify(chatCtx.toJSON({ excludeTimestamp: false })),
+              );
+              span.setAttribute(traceTypes.ATTR_EOU_PROBABILITY, endOfTurnProbability);
+              span.setAttribute(traceTypes.ATTR_EOU_UNLIKELY_THRESHOLD, unlikelyThreshold ?? 0);
+              span.setAttribute(traceTypes.ATTR_EOU_DELAY, endpointingDelay);
+              span.setAttribute(traceTypes.ATTR_EOU_LANGUAGE, this.lastLanguage ?? '');
+            },
+            {
+              name: 'eou_detection',
+              context: this.rootSpanContext,
+            },
+          );
         }
 
         let extraSleep = endpointingDelay;
@@ -430,6 +451,13 @@ export class AudioRecognition {
         });
 
         if (committed) {
+          this._endUserTurnSpan({
+            transcript: this.audioTranscript,
+            confidence: confidenceAvg,
+            transcriptionDelay: transcriptionDelay ?? 0,
+            endOfUtteranceDelay: endOfUtteranceDelay ?? 0,
+          });
+
           // clear the transcript if the user turn was committed
           this.audioTranscript = '';
           this.finalTranscriptConfidence = [];
@@ -537,6 +565,13 @@ export class AudioRecognition {
             this.hooks.onStartOfSpeech(ev);
             this.speaking = true;
 
+            if (!this.userTurnSpan) {
+              this.userTurnSpan = tracer.startSpan({
+                name: 'user_turn',
+                context: this.rootSpanContext,
+              });
+            }
+
             // Capture sample rate from the first VAD event if not already set
             if (ev.frames.length > 0 && ev.frames[0]) {
               this.sampleRate = ev.frames[0].sampleRate;
@@ -646,12 +681,36 @@ export class AudioRecognition {
 
   async close() {
     this.detachInputAudioStream();
+    this.silenceAudioWriter.releaseLock();
     await this.commitUserTurnTask?.cancelAndWait();
     await this.sttTask?.cancelAndWait();
     await this.vadTask?.cancelAndWait();
     await this.bounceEOUTask?.cancelAndWait();
   }
 
+  private _endUserTurnSpan({
+    transcript,
+    confidence,
+    transcriptionDelay,
+    endOfUtteranceDelay,
+  }: {
+    transcript: string;
+    confidence: number;
+    transcriptionDelay: number;
+    endOfUtteranceDelay: number;
+  }): void {
+    if (this.userTurnSpan) {
+      this.userTurnSpan.setAttributes({
+        [traceTypes.ATTR_USER_TRANSCRIPT]: transcript,
+        [traceTypes.ATTR_TRANSCRIPT_CONFIDENCE]: confidence,
+        [traceTypes.ATTR_TRANSCRIPTION_DELAY]: transcriptionDelay,
+        [traceTypes.ATTR_END_OF_TURN_DELAY]: endOfUtteranceDelay,
+      });
+      this.userTurnSpan.end();
+      this.userTurnSpan = undefined;
+    }
+  }
+
   private get vadBaseTurnDetection() {
     return ['vad', undefined].includes(this.turnDetectionMode);
   }

package/src/voice/generation.ts

@@ -3,6 +3,8 @@
 // SPDX-License-Identifier: Apache-2.0
 import type { AudioFrame } from '@livekit/rtc-node';
 import { AudioResampler } from '@livekit/rtc-node';
+import type { Span } from '@opentelemetry/api';
+import { context as otelContext } from '@opentelemetry/api';
 import type { ReadableStream, ReadableStreamDefaultReader } from 'stream/web';
 import {
   type ChatContext,
@@ -21,6 +23,7 @@ import {
 import { isZodSchema, parseZodSchema } from '../llm/zod-utils.js';
 import { log } from '../log.js';
 import { IdentityTransform } from '../stream/identity_transform.js';
+import { traceTypes, tracer } from '../telemetry/index.js';
 import { Future, Task, shortuuid, toError } from '../utils.js';
 import { type Agent, type ModelSettings, asyncLocalStorage, isStopResponse } from './agent.js';
 import type { AgentSession } from './agent_session.js';
@@ -377,7 +380,6 @@ export function updateInstructions(options: {
   }
 }
 
-// TODO(brian): PR3 - Add @tracer.startActiveSpan('llm_node') decorator/wrapper
 export function performLLMInference(
   node: LLMNode,
   chatCtx: ChatContext,
@@ -392,7 +394,13 @@ export function performLLMInference(
   const toolCallWriter = toolCallStream.writable.getWriter();
   const data = new _LLMGenerationData(textStream.readable, toolCallStream.readable);
 
-  const inferenceTask = async (signal: AbortSignal) => {
+  const _performLLMInferenceImpl = async (signal: AbortSignal, span: Span) => {
+    span.setAttribute(
+      traceTypes.ATTR_CHAT_CTX,
+      JSON.stringify(chatCtx.toJSON({ excludeTimestamp: false })),
+    );
+    span.setAttribute(traceTypes.ATTR_FUNCTION_TOOLS, JSON.stringify(Object.keys(toolCtx)));
+
     let llmStreamReader: ReadableStreamDefaultReader<string | ChatChunk> | null = null;
     let llmStream: ReadableStream<string | ChatChunk> | null = null;
 
@@ -448,6 +456,8 @@ export function performLLMInference(
         // No need to check if chunk is of type other than ChatChunk or string like in
         // Python since chunk is defined in the type ChatChunk | string in TypeScript
       }
+
+      span.setAttribute(traceTypes.ATTR_RESPONSE_TEXT, data.generatedText);
     } catch (error) {
       if (error instanceof DOMException && error.name === 'AbortError') {
         // Abort signal was triggered, handle gracefully
@@ -462,13 +472,21 @@ export function performLLMInference(
     }
   };
 
+  // Capture the current context (agent_turn) to ensure llm_node is properly parented
+  const currentContext = otelContext.active();
+
+  const inferenceTask = async (signal: AbortSignal) =>
+    tracer.startActiveSpan(async (span) => _performLLMInferenceImpl(signal, span), {
+      name: 'llm_node',
+      context: currentContext,
+    });
+
   return [
     Task.from((controller) => inferenceTask(controller.signal), controller, 'performLLMInference'),
     data,
   ];
 }
 
-// TODO(brian): PR3 - Add @tracer.startActiveSpan('tts_node') decorator/wrapper
 export function performTTSInference(
   node: TTSNode,
   text: ReadableStream<string>,
@@ -479,7 +497,7 @@ export function performTTSInference(
   const outputWriter = audioStream.writable.getWriter();
   const audioOutputStream = audioStream.readable;
 
-  const inferenceTask = async (signal: AbortSignal) => {
+  const _performTTSInferenceImpl = async (signal: AbortSignal) => {
     let ttsStreamReader: ReadableStreamDefaultReader<AudioFrame> | null = null;
     let ttsStream: ReadableStream<AudioFrame> | null = null;
 
@@ -514,6 +532,15 @@ export function performTTSInference(
     }
   };
 
+  // Capture the current context (agent_turn) to ensure tts_node is properly parented
+  const currentContext = otelContext.active();
+
+  const inferenceTask = async (signal: AbortSignal) =>
+    tracer.startActiveSpan(async () => _performTTSInferenceImpl(signal), {
+      name: 'tts_node',
+      context: currentContext,
+    });
+
   return [
     Task.from((controller) => inferenceTask(controller.signal), controller, 'performTTSInference'),
     audioOutputStream,
@@ -652,7 +679,7 @@ export function performAudioForwarding(
   ];
 }
 
-// TODO(brian): PR3 - Add @tracer.startActiveSpan('function_tool') wrapper for each tool execution
+// function_tool span is already implemented in tracableToolExecution below (line ~796)
 export function performToolExecutions({
   session,
   speechHandle,
@@ -788,8 +815,9 @@ export function performToolExecutions({
         });
       });
 
-      const tracableToolExecution = async (toolExecTask: Promise<unknown>) => {
-        // TODO(brian): add tracing
+      const _tracableToolExecutionImpl = async (toolExecTask: Promise<unknown>, span: Span) => {
+        span.setAttribute(traceTypes.ATTR_FUNCTION_TOOL_NAME, toolCall.name);
+        span.setAttribute(traceTypes.ATTR_FUNCTION_TOOL_ARGS, toolCall.args);
 
         // await for task to complete, if task is aborted, set exception
         let toolOutput: ToolExecutionOutput | undefined;
@@ -800,6 +828,17 @@ export function performToolExecutions({
             exception: isAborted ? new Error('tool call was aborted') : undefined,
             output: isAborted ? undefined : result,
           });
+
+          if (toolOutput.toolCallOutput) {
+            span.setAttribute(
+              traceTypes.ATTR_FUNCTION_TOOL_OUTPUT,
+              toolOutput.toolCallOutput.output,
+            );
+            span.setAttribute(
+              traceTypes.ATTR_FUNCTION_TOOL_IS_ERROR,
+              toolOutput.toolCallOutput.isError,
+            );
+          }
         } catch (rawError) {
           logger.error(
             {
@@ -813,12 +852,25 @@ export function performToolExecutions({
             toolCall,
             exception: toError(rawError),
           });
+
+          if (toolOutput.toolCallOutput) {
+            span.setAttribute(
+              traceTypes.ATTR_FUNCTION_TOOL_OUTPUT,
+              toolOutput.toolCallOutput.output,
+            );
+            span.setAttribute(traceTypes.ATTR_FUNCTION_TOOL_IS_ERROR, true);
+          }
         } finally {
           if (!toolOutput) throw new Error('toolOutput is undefined');
           toolCompleted(toolOutput);
         }
       };
 
+      const tracableToolExecution = (toolExecTask: Promise<unknown>) =>
+        tracer.startActiveSpan(async (span) => _tracableToolExecutionImpl(toolExecTask, span), {
+          name: 'function_tool',
+        });
+
       // wait, not cancelling all tool calling tasks
       tasks.push(tracableToolExecution(toolExecution));
     }