@livekit/agents 1.1.0 → 1.2.0

package/dist/voice/agent_session.js

@@ -1,3 +1,5 @@
+import { Mutex } from "@livekit/mutex";
+import { ROOT_CONTEXT, context as otelContext, trace } from "@opentelemetry/api";
 import { EventEmitter } from "node:events";
 import {
   LLM as InferenceLLM,
@@ -5,8 +7,15 @@ import {
   TTS as InferenceTTS
 } from "../inference/index.js";
 import { getJobContext } from "../job.js";
-import { ChatContext, ChatMessage } from "../llm/chat_context.js";
+import { AgentHandoffItem, ChatContext, ChatMessage } from "../llm/chat_context.js";
 import { log } from "../log.js";
+import { ModelUsageCollector, filterZeroValues } from "../metrics/model_usage.js";
+import { traceTypes, tracer } from "../telemetry/index.js";
+import {
+  DEFAULT_API_CONNECT_OPTIONS,
+  DEFAULT_SESSION_CONNECT_OPTIONS
+} from "../types.js";
+import { Task } from "../utils.js";
 import { AgentActivity } from "./agent_activity.js";
 import {
   AgentSessionEventTypes,
@@ -17,15 +26,22 @@ import {
   createUserStateChangedEvent
 } from "./events.js";
 import { AgentInput, AgentOutput } from "./io.js";
-import { RoomIO } from "./room_io/index.js";
-const defaultVoiceOptions = {
-  allowInterruptions: true,
-  discardAudioIfUninterruptible: true,
-  minInterruptionDuration: 500,
-  minInterruptionWords: 0,
-  minEndpointingDelay: 500,
-  maxEndpointingDelay: 6e3,
-  maxToolSteps: 3
+import { RecorderIO } from "./recorder_io/index.js";
+import { RoomSessionTransport, SessionHost } from "./remote_session.js";
+import {
+  DEFAULT_TEXT_INPUT_CALLBACK,
+  RoomIO
+} from "./room_io/index.js";
+import { RunResult } from "./testing/run_result.js";
+import { migrateLegacyOptions } from "./turn_config/utils.js";
+import { setParticipantSpanAttributes } from "./utils.js";
+const defaultAgentSessionOptions = {
+  maxToolSteps: 3,
+  preemptiveGeneration: true,
+  userAwayTimeout: 15,
+  aecWarmupDuration: 3e3,
+  turnHandling: {},
+  useTtsAlignedTranscript: true
 };
 class AgentSession extends EventEmitter {
   vad;
@@ -33,53 +49,97 @@ class AgentSession extends EventEmitter {
   llm;
   tts;
   turnDetection;
+  /** @deprecated use {@link sessionOptions } instead */
   options;
+  sessionOptions;
+  activityLock = new Mutex();
   agent;
   activity;
   nextActivity;
+  updateActivityTask;
   started = false;
-  userState = "listening";
-  roomIO;
-  logger = log();
+  sessionHost;
   _chatCtx;
   _userData;
+  _userState = "listening";
   _agentState = "initializing";
   _input;
   _output;
   closingTask = null;
-  constructor(opts) {
+  userAwayTimer = null;
+  _aecWarmupTimer = null;
+  // Connection options for STT, LLM, and TTS
+  _connOptions;
+  // Unrecoverable error counts, reset after agent speaking
+  llmErrorCounts = 0;
+  ttsErrorCounts = 0;
+  sessionSpan;
+  agentSpeakingSpan;
+  _interruptionDetection;
+  /** @internal */
+  _usageCollector = new ModelUsageCollector();
+  /** @internal */
+  _roomIO;
+  /** @internal */
+  _aecWarmupRemaining = 0;
+  /** @internal */
+  _recorderIO;
+  /** @internal */
+  rootSpanContext;
+  /** @internal */
+  _recordedEvents = [];
+  /** @internal */
+  _enableRecording = false;
+  /** @internal - Timestamp when the session started (milliseconds) */
+  _startedAt;
+  /** @internal - Current run state for testing */
+  _globalRunState;
+  /** @internal */
+  _userSpeakingSpan;
+  logger = log();
+  constructor(options) {
+    var _a;
     super();
-    const {
-      vad,
-      stt,
-      llm,
-      tts,
-      turnDetection,
-      userData,
-      voiceOptions = defaultVoiceOptions
-    } = opts;
+    const { agentSessionOptions: opts, legacyVoiceOptions } = migrateLegacyOptions(options);
+    const { vad, stt, llm, tts, userData, connOptions, ...resolvedSessionOptions } = opts;
+    this._connOptions = {
+      sttConnOptions: { ...DEFAULT_API_CONNECT_OPTIONS, ...connOptions == null ? void 0 : connOptions.sttConnOptions },
+      llmConnOptions: { ...DEFAULT_API_CONNECT_OPTIONS, ...connOptions == null ? void 0 : connOptions.llmConnOptions },
+      ttsConnOptions: { ...DEFAULT_API_CONNECT_OPTIONS, ...connOptions == null ? void 0 : connOptions.ttsConnOptions },
+      maxUnrecoverableErrors: (connOptions == null ? void 0 : connOptions.maxUnrecoverableErrors) ?? DEFAULT_SESSION_CONNECT_OPTIONS.maxUnrecoverableErrors
+    };
     this.vad = vad;
     if (typeof stt === "string") {
-      this.stt = new InferenceSTT({ model: stt });
+      this.stt = InferenceSTT.fromModelString(stt);
     } else {
       this.stt = stt;
     }
     if (typeof llm === "string") {
-      this.llm = new InferenceLLM({ model: llm });
+      this.llm = InferenceLLM.fromModelString(llm);
     } else {
       this.llm = llm;
     }
     if (typeof tts === "string") {
-      this.tts = new InferenceTTS({ model: tts });
+      this.tts = InferenceTTS.fromModelString(tts);
     } else {
       this.tts = tts;
     }
-    this.turnDetection = turnDetection;
+    this.turnDetection = resolvedSessionOptions.turnHandling.turnDetection;
+    this._interruptionDetection = (_a = resolvedSessionOptions.turnHandling.interruption) == null ? void 0 : _a.mode;
     this._userData = userData;
     this._input = new AgentInput(this.onAudioInputChanged);
     this._output = new AgentOutput(this.onAudioOutputChanged, this.onTextOutputChanged);
     this._chatCtx = ChatContext.empty();
-    this.options = { ...defaultVoiceOptions, ...voiceOptions };
+    this.sessionOptions = resolvedSessionOptions;
+    this.options = legacyVoiceOptions;
+    this._aecWarmupRemaining = this.sessionOptions.aecWarmupDuration ?? 0;
+    this._onUserInputTranscribed = this._onUserInputTranscribed.bind(this);
+    this.on(AgentSessionEventTypes.UserInputTranscribed, this._onUserInputTranscribed);
+  }
+  emit(event, ...args) {
+    const eventData = args[0];
+    this._recordedEvents.push(eventData);
+    return super.emit(event, ...args);
   }
   get input() {
     return this._input;
@@ -96,48 +156,100 @@ class AgentSession extends EventEmitter {
   get history() {
     return this._chatCtx;
   }
+  /** Connection options for STT, LLM, and TTS. */
+  get connOptions() {
+    return this._connOptions;
+  }
+  get interruptionDetection() {
+    return this._interruptionDetection;
+  }
+  /**
+   * Returns usage summaries for this session, one per model/provider combination.
+   */
+  get usage() {
+    return { modelUsage: this._usageCollector.flatten().map(filterZeroValues) };
+  }
+  get useTtsAlignedTranscript() {
+    return this.sessionOptions.useTtsAlignedTranscript;
+  }
   set userData(value) {
     this._userData = value;
   }
-  async start({
+  async _startImpl({
     agent,
     room,
     inputOptions,
-    outputOptions
+    outputOptions,
+    span
   }) {
-    if (this.started) {
-      return;
-    }
+    span.setAttribute(traceTypes.ATTR_AGENT_LABEL, agent.id);
     this.agent = agent;
     this._updateAgentState("initializing");
     const tasks = [];
-    if (this.input.audio && (inputOptions == null ? void 0 : inputOptions.audioEnabled) !== false) {
-      this.logger.warn("RoomIO audio input is enabled but input.audio is already set, ignoring..");
-    }
-    if (this.output.audio && (outputOptions == null ? void 0 : outputOptions.audioEnabled) !== false) {
-      this.logger.warn(
-        "RoomIO audio output is enabled but output.audio is already set, ignoring.."
-      );
+    if (room && !this._roomIO) {
+      if (this.input.audio && (inputOptions == null ? void 0 : inputOptions.audioEnabled) !== false) {
+        this.logger.warn(
+          "RoomIO audio input is enabled but input.audio is already set, ignoring.."
+        );
+      }
+      if (this.output.audio && (outputOptions == null ? void 0 : outputOptions.audioEnabled) !== false) {
+        this.logger.warn(
+          "RoomIO audio output is enabled but output.audio is already set, ignoring.."
+        );
+      }
+      if (this.output.transcription && (outputOptions == null ? void 0 : outputOptions.transcriptionEnabled) !== false) {
+        this.logger.warn(
+          "RoomIO transcription output is enabled but output.transcription is already set, ignoring.."
+        );
+      }
+      this._roomIO = new RoomIO({
+        agentSession: this,
+        room,
+        inputOptions,
+        outputOptions
+      });
+      this._roomIO.start();
+      const transport = new RoomSessionTransport(room, this._roomIO);
+      this.sessionHost = new SessionHost(transport);
+      this.sessionHost.registerSession(this);
+      if ((inputOptions == null ? void 0 : inputOptions.textEnabled) !== false) {
+        this.sessionHost.registerTextInput(
+          (inputOptions == null ? void 0 : inputOptions.textInputCallback) ?? DEFAULT_TEXT_INPUT_CALLBACK
+        );
+      }
     }
-    if (this.output.transcription && (outputOptions == null ? void 0 : outputOptions.transcriptionEnabled) !== false) {
-      this.logger.warn(
-        "RoomIO transcription output is enabled but output.transcription is already set, ignoring.."
-      );
+    let ctx = void 0;
+    try {
+      ctx = getJobContext();
+    } catch {
     }
-    this.roomIO = new RoomIO({
-      agentSession: this,
-      room,
-      inputOptions,
-      outputOptions
-    });
-    this.roomIO.start();
-    const ctx = getJobContext();
-    if (ctx && ctx.room === room && !room.isConnected) {
-      this.logger.debug("Auto-connecting to room via job context");
-      tasks.push(ctx.connect());
+    if (ctx) {
+      if (room && ctx.room === room && !room.isConnected) {
+        this.logger.debug("Auto-connecting to room via job context");
+        tasks.push(ctx.connect());
+      }
+      if (ctx._primaryAgentSession === void 0) {
+        ctx._primaryAgentSession = this;
+      } else if (this._enableRecording) {
+        throw new Error(
+          "Only one `AgentSession` can be the primary at a time. If you want to ignore primary designation, use `session.start({ record: false })`."
+        );
+      }
+      if (this.input.audio && this.output.audio && this._enableRecording) {
+        this._recorderIO = new RecorderIO({ agentSession: this });
+        this.input.audio = this._recorderIO.recordInput(this.input.audio);
+        this.output.audio = this._recorderIO.recordOutput(this.output.audio);
+        const sessionDir = ctx.sessionDirectory;
+        if (sessionDir) {
+          tasks.push(this._recorderIO.start(`${sessionDir}/audio.ogg`));
+        }
+      }
     }
-    tasks.push(this.updateActivity(this.agent));
+    tasks.push(this._updateActivity(this.agent, { waitOnEnter: false }));
     await Promise.allSettled(tasks);
+    if (this.sessionHost) {
+      await this.sessionHost.start();
+    }
     this.logger.debug(
       `using audio io: ${this.input.audio ? "`" + this.input.audio.constructor.name + "`" : "(none)"} -> \`AgentSession\` -> ${this.output.audio ? "`" + this.output.audio.constructor.name + "`" : "(none)"}`
     );
@@ -145,12 +257,70 @@ class AgentSession extends EventEmitter {
       `using transcript io: \`AgentSession\` -> ${this.output.transcription ? "`" + this.output.transcription.constructor.name + "`" : "(none)"}`
     );
     this.started = true;
+    this._startedAt = Date.now();
     this._updateAgentState("listening");
   }
+  async start({
+    agent,
+    room,
+    inputOptions,
+    outputOptions,
+    record
+  }) {
+    if (this.started) {
+      return;
+    }
+    this._usageCollector = new ModelUsageCollector();
+    let ctx = void 0;
+    try {
+      ctx = getJobContext();
+      if (record === void 0) {
+        record = ctx.job.enableRecording;
+      }
+      this._enableRecording = record;
+      if (this._enableRecording) {
+        ctx.initRecording();
+      }
+    } catch (error) {
+      this.logger.warn("JobContext is not available");
+    }
+    this.sessionSpan = tracer.startSpan({
+      name: "agent_session",
+      context: ROOT_CONTEXT
+    });
+    this.rootSpanContext = trace.setSpan(ROOT_CONTEXT, this.sessionSpan);
+    await this._startImpl({
+      agent,
+      room,
+      inputOptions,
+      outputOptions,
+      span: this.sessionSpan
+    });
+  }
   updateAgent(agent) {
     this.agent = agent;
-    if (this.started) {
-      this.updateActivity(agent);
+    if (!this.started) {
+      return;
+    }
+    const _updateActivityTask = async (oldTask2, agent2) => {
+      if (oldTask2) {
+        try {
+          await oldTask2.result;
+        } catch (error) {
+          this.logger.error(error, "previous updateAgent transition failed");
+        }
+      }
+      await this._updateActivity(agent2);
+    };
+    const oldTask = this.updateActivityTask;
+    this.updateActivityTask = Task.from(
+      async () => _updateActivityTask(oldTask, agent),
+      void 0,
+      "AgentSession_updateActivityTask"
+    );
+    const runState = this._globalRunState;
+    if (runState) {
+      runState._watchHandle(this.updateActivityTask);
     }
   }
   commitUserTurn() {
@@ -169,13 +339,36 @@ class AgentSession extends EventEmitter {
     if (!this.activity) {
       throw new Error("AgentSession is not running");
     }
-    return this.activity.say(text, options);
+    const doSay = (activity, nextActivity) => {
+      if (activity.schedulingPaused) {
+        if (!nextActivity) {
+          throw new Error("AgentSession is closing, cannot use say()");
+        }
+        return nextActivity.say(text, options);
+      }
+      return activity.say(text, options);
+    };
+    const runState = this._globalRunState;
+    let handle;
+    const activeSpan = trace.getActiveSpan();
+    if (!activeSpan && this.rootSpanContext) {
+      handle = otelContext.with(
+        this.rootSpanContext,
+        () => doSay(this.activity, this.nextActivity)
+      );
+    } else {
+      handle = doSay(this.activity, this.nextActivity);
+    }
+    if (runState) {
+      runState._watchHandle(handle);
+    }
+    return handle;
   }
-  interrupt() {
+  interrupt(options) {
     if (!this.activity) {
       throw new Error("AgentSession is not running");
     }
-    return this.activity.interrupt();
+    return this.activity.interrupt(options);
   }
   generateReply(options) {
     if (!this.activity) {
@@ -185,26 +378,142 @@ class AgentSession extends EventEmitter {
       role: "user",
       content: options.userInput
     }) : void 0;
-    if (this.activity.draining) {
-      if (!this.nextActivity) {
-        throw new Error("AgentSession is closing, cannot use generateReply()");
+    const doGenerateReply = (activity, nextActivity) => {
+      if (activity.schedulingPaused) {
+        if (!nextActivity) {
+          throw new Error("AgentSession is closing, cannot use generateReply()");
+        }
+        return nextActivity.generateReply({ userMessage, ...options });
       }
-      return this.nextActivity.generateReply({ userMessage, ...options });
+      return activity.generateReply({ userMessage, ...options });
+    };
+    const activeSpan = trace.getActiveSpan();
+    let handle;
+    if (!activeSpan && this.rootSpanContext) {
+      handle = otelContext.with(
+        this.rootSpanContext,
+        () => doGenerateReply(this.activity, this.nextActivity)
+      );
+    } else {
+      handle = doGenerateReply(this.activity, this.nextActivity);
     }
-    return this.activity.generateReply({ userMessage, ...options });
+    if (this._globalRunState) {
+      this._globalRunState._watchHandle(handle);
+    }
+    return handle;
   }
-  async updateActivity(agent) {
-    this.nextActivity = new AgentActivity(agent, this);
-    if (this.activity) {
-      await this.activity.drain();
-      await this.activity.close();
+  /**
+   * Run a test with user input and return a result for assertions.
+   *
+   * This method is primarily used for testing agent behavior without
+   * requiring a real room connection.
+   *
+   * @example
+   * ```typescript
+   * const result = await session.run({ userInput: 'Hello' });
+   * result.expect.nextEvent().isMessage({ role: 'assistant' });
+   * result.expect.noMoreEvents();
+   * ```
+   *
+   * @param options - Run options including user input and optional output type
+   * @returns A RunResult that resolves when the agent finishes responding
+   */
+  run({
+    userInput,
+    outputType
+  }) {
+    if (this._globalRunState && !this._globalRunState.done()) {
+      throw new Error("nested runs are not supported");
     }
-    this.activity = this.nextActivity;
-    this.nextActivity = void 0;
-    await this.activity.start();
-    if (this._input.audio) {
-      this.activity.attachAudioInput(this._input.audio.stream);
+    const runState = new RunResult({
+      userInput,
+      outputType
+    });
+    this._globalRunState = runState;
+    (async () => {
+      try {
+        const unlock = await this.activityLock.lock();
+        unlock();
+        this.generateReply({ userInput });
+      } catch (e) {
+        runState._reject(e instanceof Error ? e : new Error(String(e)));
+      }
+    })();
+    return runState;
+  }
+  /** @internal */
+  async _updateActivity(agent, options = {}) {
+    const { previousActivity = "close", newActivity = "start", blockedTasks = [] } = options;
+    const waitOnEnter = options.waitOnEnter ?? newActivity === "start";
+    const runWithContext = async () => {
+      const unlock = await this.activityLock.lock();
+      let onEnterTask;
+      try {
+        this.agent = agent;
+        const prevActivityObj = this.activity;
+        if (newActivity === "start") {
+          const prevAgent = prevActivityObj == null ? void 0 : prevActivityObj.agent;
+          if (agent._agentActivity && // allow updating the same agent that is running
+          (agent !== prevAgent || previousActivity !== "close")) {
+            throw new Error("Cannot start agent: an activity is already running");
+          }
+          this.nextActivity = new AgentActivity(agent, this);
+        } else if (newActivity === "resume") {
+          if (!agent._agentActivity) {
+            throw new Error("Cannot resume agent: no existing activity to resume");
+          }
+          this.nextActivity = agent._agentActivity;
+        }
+        if (prevActivityObj && prevActivityObj !== this.nextActivity) {
+          if (previousActivity === "pause") {
+            await prevActivityObj.pause({ blockedTasks });
+          } else {
+            await prevActivityObj.drain();
+            await prevActivityObj.close();
+          }
+        }
+        this.activity = this.nextActivity;
+        this.nextActivity = void 0;
+        const runState = this._globalRunState;
+        const handoffItem = new AgentHandoffItem({
+          oldAgentId: prevActivityObj == null ? void 0 : prevActivityObj.agent.id,
+          newAgentId: agent.id
+        });
+        if (runState) {
+          runState._agentHandoff({
+            item: handoffItem,
+            oldAgent: prevActivityObj == null ? void 0 : prevActivityObj.agent,
+            newAgent: this.activity.agent
+          });
+        }
+        this._chatCtx.insert(handoffItem);
+        this.logger.debug(
+          { previousAgentId: prevActivityObj == null ? void 0 : prevActivityObj.agent.id, newAgentId: agent.id },
+          "Agent handoff inserted into chat context"
+        );
+        if (newActivity === "start") {
+          await this.activity.start();
+        } else {
+          await this.activity.resume();
+        }
+        onEnterTask = this.activity._onEnterTask;
+        if (this._input.audio) {
+          this.activity.attachAudioInput(this._input.audio.stream);
+        }
+      } finally {
+        unlock();
+      }
+      if (waitOnEnter) {
+        if (!onEnterTask) {
+          throw new Error("expected onEnter task to be available while waitOnEnter=true");
+        }
+        await onEnterTask.result;
+      }
+    };
+    if (this.rootSpanContext) {
+      return otelContext.with(this.rootSpanContext, runWithContext);
     }
+    return runWithContext();
   }
   get chatCtx() {
     return this._chatCtx.copy();
@@ -212,6 +521,9 @@ class AgentSession extends EventEmitter {
   get agentState() {
     return this._agentState;
   }
+  get userState() {
+    return this._userState;
+  }
   get currentAgent() {
     if (!this.agent) {
       throw new Error("AgentSession is not running");
@@ -221,6 +533,13 @@ class AgentSession extends EventEmitter {
   async close() {
     await this.closeImpl(CloseReason.USER_INITIATED);
   }
+  shutdown(options) {
+    const { drain = true, reason = CloseReason.USER_INITIATED } = options ?? {};
+    this._closeSoon({
+      reason,
+      drain
+    });
+  }
   /** @internal */
   _closeSoon({
     reason,
@@ -230,14 +549,30 @@ class AgentSession extends EventEmitter {
     if (this.closingTask) {
       return;
     }
-    this.closeImpl(reason, error, drain);
+    this.closingTask = this.closeImpl(reason, error, drain).finally(() => {
+      this.closingTask = null;
+    });
   }
   /** @internal */
   _onError(error) {
     if (this.closingTask || error.recoverable) {
       return;
     }
-    this.logger.error(error, "AgentSession is closing due to unrecoverable error");
+    if (error.type === "llm_error") {
+      this.llmErrorCounts += 1;
+      if (this.llmErrorCounts <= this._connOptions.maxUnrecoverableErrors) {
+        return;
+      }
+    } else if (error.type === "tts_error") {
+      this.ttsErrorCounts += 1;
+      if (this.ttsErrorCounts <= this._connOptions.maxUnrecoverableErrors) {
+        return;
+      }
+    } else if (error.type === "interruption_detection_error") {
+      this.logger.error(error.toString());
+      return;
+    }
+    this.logger.error(error, "AgentSession is closing due to an unrecoverable error");
     this.closingTask = (async () => {
       await this.closeImpl(CloseReason.ERROR, error);
     })().then(() => {
@@ -250,24 +585,79 @@ class AgentSession extends EventEmitter {
     this.emit(AgentSessionEventTypes.ConversationItemAdded, createConversationItemAddedEvent(item));
   }
   /** @internal */
-  _updateAgentState(state) {
+  _toolItemsAdded(items) {
+    this._chatCtx.insert(items);
+  }
+  /** @internal */
+  _updateAgentState(state, options) {
+    var _a;
     if (this._agentState === state) {
       return;
     }
+    if (state === "speaking") {
+      this.llmErrorCounts = 0;
+      this.ttsErrorCounts = 0;
+      if (this.agentSpeakingSpan === void 0) {
+        this.agentSpeakingSpan = tracer.startSpan({
+          name: "agent_speaking",
+          context: (options == null ? void 0 : options.otelContext) ?? this.rootSpanContext,
+          startTime: options == null ? void 0 : options.startTime
+        });
+        const localParticipant = (_a = this._roomIO) == null ? void 0 : _a.localParticipant;
+        if (localParticipant) {
+          setParticipantSpanAttributes(this.agentSpeakingSpan, localParticipant);
+        }
+      }
+    } else if (this.agentSpeakingSpan !== void 0) {
+      this.agentSpeakingSpan.end();
+      this.agentSpeakingSpan = void 0;
+    }
+    if (state === "speaking" && this._aecWarmupRemaining > 0 && this._aecWarmupTimer === null) {
+      this._aecWarmupTimer = setTimeout(() => this._onAecWarmupExpired(), this._aecWarmupRemaining);
+      this.logger.debug(
+        { warmupDurationMs: this._aecWarmupRemaining },
+        "aec warmup active, disabling interruptions"
+      );
+    }
     const oldState = this._agentState;
     this._agentState = state;
+    if (state === "listening" && this._userState === "listening") {
+      this._setUserAwayTimer();
+    } else {
+      this._cancelUserAwayTimer();
+    }
     this.emit(
       AgentSessionEventTypes.AgentStateChanged,
       createAgentStateChangedEvent(oldState, state)
     );
   }
   /** @internal */
-  _updateUserState(state) {
-    if (this.userState === state) {
+  _updateUserState(state, options) {
+    var _a;
+    if (this._userState === state) {
       return;
     }
-    const oldState = this.userState;
-    this.userState = state;
+    if (state === "speaking" && this._userSpeakingSpan === void 0) {
+      this._userSpeakingSpan = tracer.startSpan({
+        name: "user_speaking",
+        context: (options == null ? void 0 : options.otelContext) ?? this.rootSpanContext,
+        startTime: options == null ? void 0 : options.lastSpeakingTime
+      });
+      const linked = (_a = this._roomIO) == null ? void 0 : _a.linkedParticipant;
+      if (linked) {
+        setParticipantSpanAttributes(this._userSpeakingSpan, linked);
+      }
+    } else if (this._userSpeakingSpan !== void 0) {
+      this._userSpeakingSpan.end(options == null ? void 0 : options.lastSpeakingTime);
+      this._userSpeakingSpan = void 0;
+    }
+    const oldState = this._userState;
+    this._userState = state;
+    if (state === "listening" && this._agentState === "listening") {
+      this._setUserAwayTimer();
+    } else {
+      this._cancelUserAwayTimer();
+    }
     this.emit(
       AgentSessionEventTypes.UserStateChanged,
       createUserStateChangedEvent(oldState, state)
@@ -286,37 +676,112 @@ class AgentSession extends EventEmitter {
   }
   onTextOutputChanged() {
   }
+  _setUserAwayTimer() {
+    this._cancelUserAwayTimer();
+    if (this.sessionOptions.userAwayTimeout === null || this.sessionOptions.userAwayTimeout === void 0) {
+      return;
+    }
+    if (this._roomIO && !this._roomIO.isParticipantAvailable) {
+      return;
+    }
+    this.userAwayTimer = setTimeout(() => {
+      this.logger.debug("User away timeout triggered");
+      this._updateUserState("away");
+    }, this.sessionOptions.userAwayTimeout * 1e3);
+  }
+  _cancelUserAwayTimer() {
+    if (this.userAwayTimer !== null) {
+      clearTimeout(this.userAwayTimer);
+      this.userAwayTimer = null;
+    }
+  }
+  /** @internal */
+  _onAecWarmupExpired() {
+    if (this._aecWarmupRemaining > 0) {
+      this.logger.debug("aec warmup expired, re-enabling interruptions");
+    }
+    this._aecWarmupRemaining = 0;
+    if (this._aecWarmupTimer !== null) {
+      clearTimeout(this._aecWarmupTimer);
+      this._aecWarmupTimer = null;
+    }
+  }
+  _onUserInputTranscribed(ev) {
+    if (this._userState === "away" && ev.isFinal) {
+      this.logger.debug("User returned from away state due to speech input");
+      this._updateUserState("listening");
+    }
+  }
   async closeImpl(reason, error = null, drain = false) {
-    var _a, _b, _c;
+    if (this.rootSpanContext) {
+      return otelContext.with(this.rootSpanContext, async () => {
+        await this.closeImplInner(reason, error, drain);
+      });
+    }
+    return this.closeImplInner(reason, error, drain);
+  }
+  async closeImplInner(reason, error = null, drain = false) {
+    var _a, _b, _c, _d;
     if (!this.started) {
       return;
     }
+    this._cancelUserAwayTimer();
+    this._onAecWarmupExpired();
+    this.off(AgentSessionEventTypes.UserInputTranscribed, this._onUserInputTranscribed);
     if (this.activity) {
       if (!drain) {
         try {
-          this.activity.interrupt();
+          await this.activity.interrupt({ force: true }).await;
         } catch (error2) {
+          this.logger.warn({ error: error2 }, "Error interrupting activity");
         }
       }
       await this.activity.drain();
       await ((_a = this.activity.currentSpeech) == null ? void 0 : _a.waitForPlayout());
-      this.activity.detachAudioInput();
+      if (reason !== CloseReason.ERROR) {
+        this.activity.commitUserTurn({ audioDetached: true, throwIfNotReady: false });
+      }
+      try {
+        this.activity.detachAudioInput();
+      } catch (error2) {
+      }
+    }
+    if (this._recorderIO) {
+      await this._recorderIO.close();
     }
     this.input.audio = null;
     this.output.audio = null;
     this.output.transcription = null;
-    await ((_b = this.roomIO) == null ? void 0 : _b.close());
-    this.roomIO = void 0;
-    await ((_c = this.activity) == null ? void 0 : _c.close());
+    await ((_b = this.sessionHost) == null ? void 0 : _b.close());
+    this.sessionHost = void 0;
+    await ((_c = this._roomIO) == null ? void 0 : _c.close());
+    this._roomIO = void 0;
+    await ((_d = this.activity) == null ? void 0 : _d.close());
     this.activity = void 0;
+    if (this.sessionSpan) {
+      this.sessionSpan.end();
+      this.sessionSpan = void 0;
+    }
+    if (this._userSpeakingSpan) {
+      this._userSpeakingSpan.end();
+      this._userSpeakingSpan = void 0;
+    }
+    if (this.agentSpeakingSpan) {
+      this.agentSpeakingSpan.end();
+      this.agentSpeakingSpan = void 0;
+    }
     this.started = false;
     this.emit(AgentSessionEventTypes.Close, createCloseEvent(reason, error));
-    this.userState = "listening";
+    this._userState = "listening";
     this._agentState = "initializing";
+    this.rootSpanContext = void 0;
+    this.llmErrorCounts = 0;
+    this.ttsErrorCounts = 0;
     this.logger.info({ reason, error }, "AgentSession closed");
   }
 }
 export {
-  AgentSession
+  AgentSession,
+  defaultAgentSessionOptions
 };
 //# sourceMappingURL=agent_session.js.map