@livekit/agents 1.0.47 → 1.1.0-dev.0

package/dist/voice/testing/index.js

@@ -15,11 +15,13 @@ import {
   isFunctionCallEvent,
   isFunctionCallOutputEvent
 } from "./types.js";
+import { FakeLLM } from "./fake_llm.js";
 export {
   AgentHandoffAssert,
   AssertionError,
   EventAssert,
   EventRangeAssert,
+  FakeLLM,
   FunctionCallAssert,
   FunctionCallOutputAssert,
   MessageAssert,

package/dist/voice/testing/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/voice/testing/index.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2025 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Testing utilities for agent evaluation.\n *\n * @example\n * ```typescript\n * import { AgentSession, Agent, voice } from '@livekit/agents';\n *\n * const session = new AgentSession({ llm });\n * await session.start(agent);\n *\n * const result = await session.run({ userInput: 'Hello' });\n * result.expect.nextEvent().isMessage({ role: 'assistant' });\n * result.expect.noMoreEvents();\n * ```\n *\n * @packageDocumentation\n */\n\nexport {\n  AgentHandoffAssert,\n  AssertionError,\n  EventAssert,\n  EventRangeAssert,\n  FunctionCallAssert,\n  FunctionCallOutputAssert,\n  MessageAssert,\n  RunAssert,\n  RunResult,\n} from './run_result.js';\n\nexport {\n  isAgentHandoffEvent,\n  isChatMessageEvent,\n  isFunctionCallEvent,\n  isFunctionCallOutputEvent,\n  type AgentHandoffAssertOptions,\n  type AgentHandoffEvent,\n  type ChatMessageEvent,\n  type EventType,\n  type FunctionCallAssertOptions,\n  type FunctionCallEvent,\n  type FunctionCallOutputAssertOptions,\n  type FunctionCallOutputEvent,\n  type MessageAssertOptions,\n  type RunEvent,\n} from './types.js';\n"],"mappings":"AAsBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAWK;","names":[]}
+{"version":3,"sources":["../../../src/voice/testing/index.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2025 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * Testing utilities for agent evaluation.\n *\n * @example\n * ```typescript\n * import { AgentSession, Agent, voice } from '@livekit/agents';\n *\n * const session = new AgentSession({ llm });\n * await session.start(agent);\n *\n * const result = await session.run({ userInput: 'Hello' });\n * result.expect.nextEvent().isMessage({ role: 'assistant' });\n * result.expect.noMoreEvents();\n * ```\n *\n * @packageDocumentation\n */\n\nexport {\n  AgentHandoffAssert,\n  AssertionError,\n  EventAssert,\n  EventRangeAssert,\n  FunctionCallAssert,\n  FunctionCallOutputAssert,\n  MessageAssert,\n  RunAssert,\n  RunResult,\n} from './run_result.js';\n\nexport {\n  isAgentHandoffEvent,\n  isChatMessageEvent,\n  isFunctionCallEvent,\n  isFunctionCallOutputEvent,\n  type AgentHandoffAssertOptions,\n  type AgentHandoffEvent,\n  type ChatMessageEvent,\n  type EventType,\n  type FunctionCallAssertOptions,\n  type FunctionCallEvent,\n  type FunctionCallOutputAssertOptions,\n  type FunctionCallOutputEvent,\n  type MessageAssertOptions,\n  type RunEvent,\n} from './types.js';\n\nexport { FakeLLM, type FakeLLMResponse } from './fake_llm.js';\n"],"mappings":"AAsBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAWK;AAEP,SAAS,eAAqC;","names":[]}

package/dist/voice/turn_config/endpointing.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var endpointing_exports = {};
+__export(endpointing_exports, {
+  defaultEndpointingOptions: () => defaultEndpointingOptions
+});
+module.exports = __toCommonJS(endpointing_exports);
+const defaultEndpointingOptions = {
+  mode: "fixed",
+  minDelay: 500,
+  maxDelay: 3e3
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultEndpointingOptions
+});
+//# sourceMappingURL=endpointing.cjs.map

package/dist/voice/turn_config/endpointing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/voice/turn_config/endpointing.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\n/**\n * Configuration for endpointing, which determines when the user's turn is complete.\n */\nexport interface EndpointingOptions {\n  /**\n   * Endpointing mode. `\"fixed\"` uses a fixed delay, `\"dynamic\"` adjusts delay based on\n   * end-of-utterance prediction.\n   * @defaultValue \"fixed\"\n   */\n  mode: 'fixed' | 'dynamic';\n  /**\n   * Minimum time in milliseconds since the last detected speech before the agent declares the user's\n   * turn complete. In VAD mode this effectively behaves like `max(VAD silence, minDelay)`;\n   * in STT mode it is applied after the STT end-of-speech signal, so it can be additive with\n   * the STT provider's endpointing delay.\n   * @defaultValue 500\n   */\n  minDelay: number;\n  /**\n   * Maximum time in milliseconds the agent will wait before terminating the turn.\n   * @defaultValue 3000\n   */\n  maxDelay: number;\n}\n\nexport const defaultEndpointingOptions = {\n  mode: 'fixed',\n  minDelay: 500,\n  maxDelay: 3000,\n} as const satisfies EndpointingOptions;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA4BO,MAAM,4BAA4B;AAAA,EACvC,MAAM;AAAA,EACN,UAAU;AAAA,EACV,UAAU;AACZ;","names":[]}

package/dist/voice/turn_config/endpointing.d.cts

@@ -0,0 +1,30 @@
+/**
+ * Configuration for endpointing, which determines when the user's turn is complete.
+ */
+export interface EndpointingOptions {
+    /**
+     * Endpointing mode. `"fixed"` uses a fixed delay, `"dynamic"` adjusts delay based on
+     * end-of-utterance prediction.
+     * @defaultValue "fixed"
+     */
+    mode: 'fixed' | 'dynamic';
+    /**
+     * Minimum time in milliseconds since the last detected speech before the agent declares the user's
+     * turn complete. In VAD mode this effectively behaves like `max(VAD silence, minDelay)`;
+     * in STT mode it is applied after the STT end-of-speech signal, so it can be additive with
+     * the STT provider's endpointing delay.
+     * @defaultValue 500
+     */
+    minDelay: number;
+    /**
+     * Maximum time in milliseconds the agent will wait before terminating the turn.
+     * @defaultValue 3000
+     */
+    maxDelay: number;
+}
+export declare const defaultEndpointingOptions: {
+    readonly mode: "fixed";
+    readonly minDelay: 500;
+    readonly maxDelay: 3000;
+};
+//# sourceMappingURL=endpointing.d.ts.map

package/dist/voice/turn_config/endpointing.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Configuration for endpointing, which determines when the user's turn is complete.
+ */
+export interface EndpointingOptions {
+    /**
+     * Endpointing mode. `"fixed"` uses a fixed delay, `"dynamic"` adjusts delay based on
+     * end-of-utterance prediction.
+     * @defaultValue "fixed"
+     */
+    mode: 'fixed' | 'dynamic';
+    /**
+     * Minimum time in milliseconds since the last detected speech before the agent declares the user's
+     * turn complete. In VAD mode this effectively behaves like `max(VAD silence, minDelay)`;
+     * in STT mode it is applied after the STT end-of-speech signal, so it can be additive with
+     * the STT provider's endpointing delay.
+     * @defaultValue 500
+     */
+    minDelay: number;
+    /**
+     * Maximum time in milliseconds the agent will wait before terminating the turn.
+     * @defaultValue 3000
+     */
+    maxDelay: number;
+}
+export declare const defaultEndpointingOptions: {
+    readonly mode: "fixed";
+    readonly minDelay: 500;
+    readonly maxDelay: 3000;
+};
+//# sourceMappingURL=endpointing.d.ts.map

package/dist/voice/turn_config/endpointing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpointing.d.ts","sourceRoot":"","sources":["../../../src/voice/turn_config/endpointing.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,yBAAyB;;;;CAIC,CAAC"}

package/dist/voice/turn_config/endpointing.js

@@ -0,0 +1,9 @@
+const defaultEndpointingOptions = {
+  mode: "fixed",
+  minDelay: 500,
+  maxDelay: 3e3
+};
+export {
+  defaultEndpointingOptions
+};
+//# sourceMappingURL=endpointing.js.map

package/dist/voice/turn_config/endpointing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/voice/turn_config/endpointing.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\n/**\n * Configuration for endpointing, which determines when the user's turn is complete.\n */\nexport interface EndpointingOptions {\n  /**\n   * Endpointing mode. `\"fixed\"` uses a fixed delay, `\"dynamic\"` adjusts delay based on\n   * end-of-utterance prediction.\n   * @defaultValue \"fixed\"\n   */\n  mode: 'fixed' | 'dynamic';\n  /**\n   * Minimum time in milliseconds since the last detected speech before the agent declares the user's\n   * turn complete. In VAD mode this effectively behaves like `max(VAD silence, minDelay)`;\n   * in STT mode it is applied after the STT end-of-speech signal, so it can be additive with\n   * the STT provider's endpointing delay.\n   * @defaultValue 500\n   */\n  minDelay: number;\n  /**\n   * Maximum time in milliseconds the agent will wait before terminating the turn.\n   * @defaultValue 3000\n   */\n  maxDelay: number;\n}\n\nexport const defaultEndpointingOptions = {\n  mode: 'fixed',\n  minDelay: 500,\n  maxDelay: 3000,\n} as const satisfies EndpointingOptions;\n"],"mappings":"AA4BO,MAAM,4BAA4B;AAAA,EACvC,MAAM;AAAA,EACN,UAAU;AAAA,EACV,UAAU;AACZ;","names":[]}

package/dist/voice/turn_config/interruption.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var interruption_exports = {};
+__export(interruption_exports, {
+  defaultInterruptionOptions: () => defaultInterruptionOptions
+});
+module.exports = __toCommonJS(interruption_exports);
+const defaultInterruptionOptions = {
+  enabled: true,
+  mode: void 0,
+  discardAudioIfUninterruptible: true,
+  minDuration: 500,
+  minWords: 0,
+  falseInterruptionTimeout: 2e3,
+  resumeFalseInterruption: true
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultInterruptionOptions
+});
+//# sourceMappingURL=interruption.cjs.map

package/dist/voice/turn_config/interruption.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/voice/turn_config/interruption.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\n/**\n * Configuration for interruption handling.\n */\nexport interface InterruptionOptions {\n  /**\n   * Whether interruptions are enabled.\n   * @defaultValue true\n   */\n  enabled: boolean;\n  /**\n   * Interruption handling strategy. `\"adaptive\"` for ML-based detection, `\"vad\"` for simple\n   * voice-activity detection. `undefined` means auto-detect.\n   * @defaultValue undefined\n   */\n  mode: 'adaptive' | 'vad' | false | undefined;\n  /**\n   * When `true`, buffered audio is dropped while the agent is speaking and cannot be interrupted.\n   * @defaultValue true\n   */\n  discardAudioIfUninterruptible: boolean;\n  /**\n   * Minimum speech length in milliseconds to register as an interruption.\n   * @defaultValue 500\n   */\n  minDuration: number;\n  /**\n   * Minimum number of words to consider an interruption, only used if STT is enabled.\n   * @defaultValue 0\n   */\n  minWords: number;\n  /**\n   * If set, emit an `agentFalseInterruption` event after this amount of time if the user is\n   * silent and no user transcript is detected after the interruption. Set to `undefined` to\n   * disable. The value is in milliseconds.\n   * @defaultValue 2000\n   */\n  falseInterruptionTimeout: number;\n  /**\n   * Whether to resume the false interruption after the `falseInterruptionTimeout`.\n   * @defaultValue true\n   */\n  resumeFalseInterruption: boolean;\n}\n\nexport const defaultInterruptionOptions = {\n  enabled: true,\n  mode: undefined,\n  discardAudioIfUninterruptible: true,\n  minDuration: 500,\n  minWords: 0,\n  falseInterruptionTimeout: 2000,\n  resumeFalseInterruption: true,\n} as const satisfies InterruptionOptions;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA+CO,MAAM,6BAA6B;AAAA,EACxC,SAAS;AAAA,EACT,MAAM;AAAA,EACN,+BAA+B;AAAA,EAC/B,aAAa;AAAA,EACb,UAAU;AAAA,EACV,0BAA0B;AAAA,EAC1B,yBAAyB;AAC3B;","names":[]}

package/dist/voice/turn_config/interruption.d.cts

@@ -0,0 +1,53 @@
+/**
+ * Configuration for interruption handling.
+ */
+export interface InterruptionOptions {
+    /**
+     * Whether interruptions are enabled.
+     * @defaultValue true
+     */
+    enabled: boolean;
+    /**
+     * Interruption handling strategy. `"adaptive"` for ML-based detection, `"vad"` for simple
+     * voice-activity detection. `undefined` means auto-detect.
+     * @defaultValue undefined
+     */
+    mode: 'adaptive' | 'vad' | false | undefined;
+    /**
+     * When `true`, buffered audio is dropped while the agent is speaking and cannot be interrupted.
+     * @defaultValue true
+     */
+    discardAudioIfUninterruptible: boolean;
+    /**
+     * Minimum speech length in milliseconds to register as an interruption.
+     * @defaultValue 500
+     */
+    minDuration: number;
+    /**
+     * Minimum number of words to consider an interruption, only used if STT is enabled.
+     * @defaultValue 0
+     */
+    minWords: number;
+    /**
+     * If set, emit an `agentFalseInterruption` event after this amount of time if the user is
+     * silent and no user transcript is detected after the interruption. Set to `undefined` to
+     * disable. The value is in milliseconds.
+     * @defaultValue 2000
+     */
+    falseInterruptionTimeout: number;
+    /**
+     * Whether to resume the false interruption after the `falseInterruptionTimeout`.
+     * @defaultValue true
+     */
+    resumeFalseInterruption: boolean;
+}
+export declare const defaultInterruptionOptions: {
+    readonly enabled: true;
+    readonly mode: undefined;
+    readonly discardAudioIfUninterruptible: true;
+    readonly minDuration: 500;
+    readonly minWords: 0;
+    readonly falseInterruptionTimeout: 2000;
+    readonly resumeFalseInterruption: true;
+};
+//# sourceMappingURL=interruption.d.ts.map

package/dist/voice/turn_config/interruption.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Configuration for interruption handling.
+ */
+export interface InterruptionOptions {
+    /**
+     * Whether interruptions are enabled.
+     * @defaultValue true
+     */
+    enabled: boolean;
+    /**
+     * Interruption handling strategy. `"adaptive"` for ML-based detection, `"vad"` for simple
+     * voice-activity detection. `undefined` means auto-detect.
+     * @defaultValue undefined
+     */
+    mode: 'adaptive' | 'vad' | false | undefined;
+    /**
+     * When `true`, buffered audio is dropped while the agent is speaking and cannot be interrupted.
+     * @defaultValue true
+     */
+    discardAudioIfUninterruptible: boolean;
+    /**
+     * Minimum speech length in milliseconds to register as an interruption.
+     * @defaultValue 500
+     */
+    minDuration: number;
+    /**
+     * Minimum number of words to consider an interruption, only used if STT is enabled.
+     * @defaultValue 0
+     */
+    minWords: number;
+    /**
+     * If set, emit an `agentFalseInterruption` event after this amount of time if the user is
+     * silent and no user transcript is detected after the interruption. Set to `undefined` to
+     * disable. The value is in milliseconds.
+     * @defaultValue 2000
+     */
+    falseInterruptionTimeout: number;
+    /**
+     * Whether to resume the false interruption after the `falseInterruptionTimeout`.
+     * @defaultValue true
+     */
+    resumeFalseInterruption: boolean;
+}
+export declare const defaultInterruptionOptions: {
+    readonly enabled: true;
+    readonly mode: undefined;
+    readonly discardAudioIfUninterruptible: true;
+    readonly minDuration: 500;
+    readonly minWords: 0;
+    readonly falseInterruptionTimeout: 2000;
+    readonly resumeFalseInterruption: true;
+};
+//# sourceMappingURL=interruption.d.ts.map

package/dist/voice/turn_config/interruption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interruption.d.ts","sourceRoot":"","sources":["../../../src/voice/turn_config/interruption.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,IAAI,EAAE,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC;IAC7C;;;OAGG;IACH,6BAA6B,EAAE,OAAO,CAAC;IACvC;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,wBAAwB,EAAE,MAAM,CAAC;IACjC;;;OAGG;IACH,uBAAuB,EAAE,OAAO,CAAC;CAClC;AAED,eAAO,MAAM,0BAA0B;;;;;;;;CAQC,CAAC"}

package/dist/voice/turn_config/interruption.js

@@ -0,0 +1,13 @@
+const defaultInterruptionOptions = {
+  enabled: true,
+  mode: void 0,
+  discardAudioIfUninterruptible: true,
+  minDuration: 500,
+  minWords: 0,
+  falseInterruptionTimeout: 2e3,
+  resumeFalseInterruption: true
+};
+export {
+  defaultInterruptionOptions
+};
+//# sourceMappingURL=interruption.js.map

package/dist/voice/turn_config/interruption.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/voice/turn_config/interruption.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\n/**\n * Configuration for interruption handling.\n */\nexport interface InterruptionOptions {\n  /**\n   * Whether interruptions are enabled.\n   * @defaultValue true\n   */\n  enabled: boolean;\n  /**\n   * Interruption handling strategy. `\"adaptive\"` for ML-based detection, `\"vad\"` for simple\n   * voice-activity detection. `undefined` means auto-detect.\n   * @defaultValue undefined\n   */\n  mode: 'adaptive' | 'vad' | false | undefined;\n  /**\n   * When `true`, buffered audio is dropped while the agent is speaking and cannot be interrupted.\n   * @defaultValue true\n   */\n  discardAudioIfUninterruptible: boolean;\n  /**\n   * Minimum speech length in milliseconds to register as an interruption.\n   * @defaultValue 500\n   */\n  minDuration: number;\n  /**\n   * Minimum number of words to consider an interruption, only used if STT is enabled.\n   * @defaultValue 0\n   */\n  minWords: number;\n  /**\n   * If set, emit an `agentFalseInterruption` event after this amount of time if the user is\n   * silent and no user transcript is detected after the interruption. Set to `undefined` to\n   * disable. The value is in milliseconds.\n   * @defaultValue 2000\n   */\n  falseInterruptionTimeout: number;\n  /**\n   * Whether to resume the false interruption after the `falseInterruptionTimeout`.\n   * @defaultValue true\n   */\n  resumeFalseInterruption: boolean;\n}\n\nexport const defaultInterruptionOptions = {\n  enabled: true,\n  mode: undefined,\n  discardAudioIfUninterruptible: true,\n  minDuration: 500,\n  minWords: 0,\n  falseInterruptionTimeout: 2000,\n  resumeFalseInterruption: true,\n} as const satisfies InterruptionOptions;\n"],"mappings":"AA+CO,MAAM,6BAA6B;AAAA,EACxC,SAAS;AAAA,EACT,MAAM;AAAA,EACN,+BAA+B;AAAA,EAC/B,aAAa;AAAA,EACb,UAAU;AAAA,EACV,0BAA0B;AAAA,EAC1B,yBAAyB;AAC3B;","names":[]}

package/dist/voice/turn_config/turn_handling.cjs

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var turn_handling_exports = {};
+__export(turn_handling_exports, {
+  defaultTurnHandlingOptions: () => defaultTurnHandlingOptions
+});
+module.exports = __toCommonJS(turn_handling_exports);
+var import_endpointing = require("./endpointing.cjs");
+var import_interruption = require("./interruption.cjs");
+const defaultTurnHandlingOptions = {
+  turnDetection: void 0,
+  interruption: import_interruption.defaultInterruptionOptions,
+  endpointing: import_endpointing.defaultEndpointingOptions
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultTurnHandlingOptions
+});
+//# sourceMappingURL=turn_handling.cjs.map

package/dist/voice/turn_config/turn_handling.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/voice/turn_config/turn_handling.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { TurnDetectionMode } from '../agent_session.js';\nimport { type EndpointingOptions, defaultEndpointingOptions } from './endpointing.js';\nimport { type InterruptionOptions, defaultInterruptionOptions } from './interruption.js';\n\n/**\n * Configuration for the turn handling system. Used to configure the turn taking behavior of the\n * session.\n */\nexport interface TurnHandlingOptions {\n  /**\n   * Strategy for deciding when the user has finished speaking.\n   *\n   * - `\"stt\"` – rely on speech-to-text end-of-utterance cues\n   * - `\"vad\"` – rely on Voice Activity Detection start/stop cues\n   * - `\"realtime_llm\"` – use server-side detection from a realtime LLM\n   * - `\"manual\"` – caller controls turn boundaries explicitly\n   *\n   * If not set, the session chooses the best available mode in priority order\n   * `realtime_llm → vad → stt → manual`; it automatically falls back if the necessary model\n   * is missing.\n   */\n  turnDetection: TurnDetectionMode | undefined;\n  /**\n   * Configuration for endpointing.\n   */\n  endpointing: Partial<EndpointingOptions>;\n  /**\n   * Configuration for interruption handling.\n   */\n  interruption: Partial<InterruptionOptions>;\n}\n\nexport interface InternalTurnHandlingOptions extends TurnHandlingOptions {\n  endpointing: EndpointingOptions;\n  interruption: InterruptionOptions;\n}\n\nexport const defaultTurnHandlingOptions: InternalTurnHandlingOptions = {\n  turnDetection: undefined,\n  interruption: defaultInterruptionOptions,\n  endpointing: defaultEndpointingOptions,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,yBAAmE;AACnE,0BAAqE;AAmC9D,MAAM,6BAA0D;AAAA,EACrE,eAAe;AAAA,EACf,cAAc;AAAA,EACd,aAAa;AACf;","names":[]}

package/dist/voice/turn_config/turn_handling.d.cts

@@ -0,0 +1,36 @@
+import type { TurnDetectionMode } from '../agent_session.js';
+import { type EndpointingOptions } from './endpointing.js';
+import { type InterruptionOptions } from './interruption.js';
+/**
+ * Configuration for the turn handling system. Used to configure the turn taking behavior of the
+ * session.
+ */
+export interface TurnHandlingOptions {
+    /**
+     * Strategy for deciding when the user has finished speaking.
+     *
+     * - `"stt"` – rely on speech-to-text end-of-utterance cues
+     * - `"vad"` – rely on Voice Activity Detection start/stop cues
+     * - `"realtime_llm"` – use server-side detection from a realtime LLM
+     * - `"manual"` – caller controls turn boundaries explicitly
+     *
+     * If not set, the session chooses the best available mode in priority order
+     * `realtime_llm → vad → stt → manual`; it automatically falls back if the necessary model
+     * is missing.
+     */
+    turnDetection: TurnDetectionMode | undefined;
+    /**
+     * Configuration for endpointing.
+     */
+    endpointing: Partial<EndpointingOptions>;
+    /**
+     * Configuration for interruption handling.
+     */
+    interruption: Partial<InterruptionOptions>;
+}
+export interface InternalTurnHandlingOptions extends TurnHandlingOptions {
+    endpointing: EndpointingOptions;
+    interruption: InterruptionOptions;
+}
+export declare const defaultTurnHandlingOptions: InternalTurnHandlingOptions;
+//# sourceMappingURL=turn_handling.d.ts.map

package/dist/voice/turn_config/turn_handling.d.ts

@@ -0,0 +1,36 @@
+import type { TurnDetectionMode } from '../agent_session.js';
+import { type EndpointingOptions } from './endpointing.js';
+import { type InterruptionOptions } from './interruption.js';
+/**
+ * Configuration for the turn handling system. Used to configure the turn taking behavior of the
+ * session.
+ */
+export interface TurnHandlingOptions {
+    /**
+     * Strategy for deciding when the user has finished speaking.
+     *
+     * - `"stt"` – rely on speech-to-text end-of-utterance cues
+     * - `"vad"` – rely on Voice Activity Detection start/stop cues
+     * - `"realtime_llm"` – use server-side detection from a realtime LLM
+     * - `"manual"` – caller controls turn boundaries explicitly
+     *
+     * If not set, the session chooses the best available mode in priority order
+     * `realtime_llm → vad → stt → manual`; it automatically falls back if the necessary model
+     * is missing.
+     */
+    turnDetection: TurnDetectionMode | undefined;
+    /**
+     * Configuration for endpointing.
+     */
+    endpointing: Partial<EndpointingOptions>;
+    /**
+     * Configuration for interruption handling.
+     */
+    interruption: Partial<InterruptionOptions>;
+}
+export interface InternalTurnHandlingOptions extends TurnHandlingOptions {
+    endpointing: EndpointingOptions;
+    interruption: InterruptionOptions;
+}
+export declare const defaultTurnHandlingOptions: InternalTurnHandlingOptions;
+//# sourceMappingURL=turn_handling.d.ts.map

package/dist/voice/turn_config/turn_handling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn_handling.d.ts","sourceRoot":"","sources":["../../../src/voice/turn_config/turn_handling.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,KAAK,kBAAkB,EAA6B,MAAM,kBAAkB,CAAC;AACtF,OAAO,EAAE,KAAK,mBAAmB,EAA8B,MAAM,mBAAmB,CAAC;AAEzF;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;;;;;;;;OAWG;IACH,aAAa,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC7C;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACzC;;OAEG;IACH,YAAY,EAAE,OAAO,CAAC,mBAAmB,CAAC,CAAC;CAC5C;AAED,MAAM,WAAW,2BAA4B,SAAQ,mBAAmB;IACtE,WAAW,EAAE,kBAAkB,CAAC;IAChC,YAAY,EAAE,mBAAmB,CAAC;CACnC;AAED,eAAO,MAAM,0BAA0B,EAAE,2BAIxC,CAAC"}

package/dist/voice/turn_config/turn_handling.js

@@ -0,0 +1,11 @@
+import { defaultEndpointingOptions } from "./endpointing.js";
+import { defaultInterruptionOptions } from "./interruption.js";
+const defaultTurnHandlingOptions = {
+  turnDetection: void 0,
+  interruption: defaultInterruptionOptions,
+  endpointing: defaultEndpointingOptions
+};
+export {
+  defaultTurnHandlingOptions
+};
+//# sourceMappingURL=turn_handling.js.map

package/dist/voice/turn_config/turn_handling.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/voice/turn_config/turn_handling.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { TurnDetectionMode } from '../agent_session.js';\nimport { type EndpointingOptions, defaultEndpointingOptions } from './endpointing.js';\nimport { type InterruptionOptions, defaultInterruptionOptions } from './interruption.js';\n\n/**\n * Configuration for the turn handling system. Used to configure the turn taking behavior of the\n * session.\n */\nexport interface TurnHandlingOptions {\n  /**\n   * Strategy for deciding when the user has finished speaking.\n   *\n   * - `\"stt\"` – rely on speech-to-text end-of-utterance cues\n   * - `\"vad\"` – rely on Voice Activity Detection start/stop cues\n   * - `\"realtime_llm\"` – use server-side detection from a realtime LLM\n   * - `\"manual\"` – caller controls turn boundaries explicitly\n   *\n   * If not set, the session chooses the best available mode in priority order\n   * `realtime_llm → vad → stt → manual`; it automatically falls back if the necessary model\n   * is missing.\n   */\n  turnDetection: TurnDetectionMode | undefined;\n  /**\n   * Configuration for endpointing.\n   */\n  endpointing: Partial<EndpointingOptions>;\n  /**\n   * Configuration for interruption handling.\n   */\n  interruption: Partial<InterruptionOptions>;\n}\n\nexport interface InternalTurnHandlingOptions extends TurnHandlingOptions {\n  endpointing: EndpointingOptions;\n  interruption: InterruptionOptions;\n}\n\nexport const defaultTurnHandlingOptions: InternalTurnHandlingOptions = {\n  turnDetection: undefined,\n  interruption: defaultInterruptionOptions,\n  endpointing: defaultEndpointingOptions,\n};\n"],"mappings":"AAIA,SAAkC,iCAAiC;AACnE,SAAmC,kCAAkC;AAmC9D,MAAM,6BAA0D;AAAA,EACrE,eAAe;AAAA,EACf,cAAc;AAAA,EACd,aAAa;AACf;","names":[]}

package/dist/voice/turn_config/utils.cjs

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  mergeWithDefaults: () => mergeWithDefaults,
+  migrateLegacyOptions: () => migrateLegacyOptions,
+  stripUndefined: () => stripUndefined
+});
+module.exports = __toCommonJS(utils_exports);
+var import_log = require("../../log.cjs");
+var import_agent_session = require("../agent_session.cjs");
+var import_endpointing = require("./endpointing.cjs");
+var import_interruption = require("./interruption.cjs");
+var import_turn_handling = require("./turn_handling.cjs");
+function migrateLegacyOptions(legacyOptions) {
+  var _a, _b;
+  const logger = (0, import_log.log)();
+  const { voiceOptions, turnDetection, options: sessionOptions, ...rest } = legacyOptions;
+  if (voiceOptions !== void 0 && sessionOptions !== void 0) {
+    logger.warn(
+      "Both voiceOptions and options have been supplied as part of the AgentSessionOptions, voiceOptions will be merged with options taking precedence"
+    );
+  }
+  const originalTurnDetection = ((_a = sessionOptions == null ? void 0 : sessionOptions.turnHandling) == null ? void 0 : _a.turnDetection) ?? ((_b = voiceOptions == null ? void 0 : voiceOptions.turnHandling) == null ? void 0 : _b.turnDetection) ?? turnDetection;
+  const cloneableVoiceOptions = voiceOptions ? {
+    ...voiceOptions,
+    turnHandling: voiceOptions.turnHandling ? { ...voiceOptions.turnHandling, turnDetection: void 0 } : voiceOptions.turnHandling
+  } : voiceOptions;
+  const cloneableSessionOptions = sessionOptions ? {
+    ...sessionOptions,
+    turnHandling: sessionOptions.turnHandling ? { ...sessionOptions.turnHandling, turnDetection: void 0 } : sessionOptions.turnHandling
+  } : sessionOptions;
+  const mergedOptions = structuredClone({ ...cloneableVoiceOptions, ...cloneableSessionOptions });
+  const turnHandling = {
+    interruption: {
+      discardAudioIfUninterruptible: mergedOptions == null ? void 0 : mergedOptions.discardAudioIfUninterruptible,
+      minDuration: mergedOptions == null ? void 0 : mergedOptions.minInterruptionDuration,
+      minWords: mergedOptions == null ? void 0 : mergedOptions.minInterruptionWords
+    },
+    endpointing: {
+      minDelay: mergedOptions == null ? void 0 : mergedOptions.minEndpointingDelay,
+      maxDelay: mergedOptions == null ? void 0 : mergedOptions.maxEndpointingDelay
+    },
+    ...mergedOptions.turnHandling,
+    // Restore original turnDetection after spread to preserve class instance with methods
+    // (structuredClone converts class instances to plain objects, losing prototype methods)
+    turnDetection: originalTurnDetection
+  };
+  if ((mergedOptions == null ? void 0 : mergedOptions.allowInterruptions) === false) {
+    turnHandling.interruption.enabled = false;
+  }
+  const optionsWithDefaults = {
+    ...import_agent_session.defaultSessionOptions,
+    ...mergedOptions,
+    turnHandling: mergeWithDefaults(turnHandling)
+  };
+  const newAgentSessionOptions = {
+    ...rest,
+    options: optionsWithDefaults,
+    voiceOptions: optionsWithDefaults,
+    turnDetection: turnHandling.turnDetection
+  };
+  return newAgentSessionOptions;
+}
+function stripUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+function mergeWithDefaults(config) {
+  return {
+    turnDetection: config.turnDetection ?? import_turn_handling.defaultTurnHandlingOptions.turnDetection,
+    endpointing: { ...import_endpointing.defaultEndpointingOptions, ...stripUndefined(config.endpointing) },
+    interruption: { ...import_interruption.defaultInterruptionOptions, ...stripUndefined(config.interruption) }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeWithDefaults,
+  migrateLegacyOptions,
+  stripUndefined
+});
+//# sourceMappingURL=utils.cjs.map

package/dist/voice/turn_config/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/voice/turn_config/utils.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { log } from '../../log.js';\nimport {\n  type AgentSessionOptions,\n  type InternalSessionOptions,\n  defaultSessionOptions,\n} from '../agent_session.js';\nimport { defaultEndpointingOptions } from './endpointing.js';\nimport { defaultInterruptionOptions } from './interruption.js';\nimport { type TurnHandlingOptions, defaultTurnHandlingOptions } from './turn_handling.js';\n\nexport function migrateLegacyOptions<UserData>(\n  legacyOptions: AgentSessionOptions<UserData>,\n): AgentSessionOptions<UserData> & { options: InternalSessionOptions } {\n  const logger = log();\n  const { voiceOptions, turnDetection, options: sessionOptions, ...rest } = legacyOptions;\n\n  if (voiceOptions !== undefined && sessionOptions !== undefined) {\n    logger.warn(\n      'Both voiceOptions and options have been supplied as part of the AgentSessionOptions, voiceOptions will be merged with options taking precedence',\n    );\n  }\n\n  // Preserve turnDetection before cloning since structuredClone converts class instances to plain objects\n  const originalTurnDetection =\n    sessionOptions?.turnHandling?.turnDetection ??\n    voiceOptions?.turnHandling?.turnDetection ??\n    turnDetection;\n\n  // Exclude potentially non-cloneable turnDetection objects before structuredClone.\n  // They are restored from originalTurnDetection below.\n  const cloneableVoiceOptions = voiceOptions\n    ? {\n        ...voiceOptions,\n        turnHandling: voiceOptions.turnHandling\n          ? { ...voiceOptions.turnHandling, turnDetection: undefined }\n          : voiceOptions.turnHandling,\n      }\n    : voiceOptions;\n  const cloneableSessionOptions = sessionOptions\n    ? {\n        ...sessionOptions,\n        turnHandling: sessionOptions.turnHandling\n          ? { ...sessionOptions.turnHandling, turnDetection: undefined }\n          : sessionOptions.turnHandling,\n      }\n    : sessionOptions;\n\n  const mergedOptions = structuredClone({ ...cloneableVoiceOptions, ...cloneableSessionOptions });\n\n  const turnHandling: TurnHandlingOptions = {\n    interruption: {\n      discardAudioIfUninterruptible: mergedOptions?.discardAudioIfUninterruptible,\n      minDuration: mergedOptions?.minInterruptionDuration,\n      minWords: mergedOptions?.minInterruptionWords,\n    },\n    endpointing: {\n      minDelay: mergedOptions?.minEndpointingDelay,\n      maxDelay: mergedOptions?.maxEndpointingDelay,\n    },\n\n    ...mergedOptions.turnHandling,\n    // Restore original turnDetection after spread to preserve class instance with methods\n    // (structuredClone converts class instances to plain objects, losing prototype methods)\n    turnDetection: originalTurnDetection,\n  } as const;\n\n  if (mergedOptions?.allowInterruptions === false) {\n    turnHandling.interruption.enabled = false;\n  }\n\n  const optionsWithDefaults = {\n    ...defaultSessionOptions,\n    ...mergedOptions,\n    turnHandling: mergeWithDefaults(turnHandling),\n  };\n\n  const newAgentSessionOptions: AgentSessionOptions<UserData> & {\n    options: InternalSessionOptions;\n  } = {\n    ...rest,\n    options: optionsWithDefaults,\n    voiceOptions: optionsWithDefaults,\n    turnDetection: turnHandling.turnDetection,\n  };\n\n  return newAgentSessionOptions;\n}\n\n/** Remove keys whose value is `undefined` so they don't shadow defaults when spread. */\nexport function stripUndefined<T extends object>(obj: T): Partial<T> {\n  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined)) as Partial<T>;\n}\n\nexport function mergeWithDefaults(config: TurnHandlingOptions) {\n  return {\n    turnDetection: config.turnDetection ?? defaultTurnHandlingOptions.turnDetection,\n    endpointing: { ...defaultEndpointingOptions, ...stripUndefined(config.endpointing) },\n    interruption: { ...defaultInterruptionOptions, ...stripUndefined(config.interruption) },\n  } as const;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,iBAAoB;AACpB,2BAIO;AACP,yBAA0C;AAC1C,0BAA2C;AAC3C,2BAAqE;AAE9D,SAAS,qBACd,eACqE;AAfvE;AAgBE,QAAM,aAAS,gBAAI;AACnB,QAAM,EAAE,cAAc,eAAe,SAAS,gBAAgB,GAAG,KAAK,IAAI;AAE1E,MAAI,iBAAiB,UAAa,mBAAmB,QAAW;AAC9D,WAAO;AAAA,MACL;AAAA,IACF;AAAA,EACF;AAGA,QAAM,0BACJ,sDAAgB,iBAAhB,mBAA8B,oBAC9B,kDAAc,iBAAd,mBAA4B,kBAC5B;AAIF,QAAM,wBAAwB,eAC1B;AAAA,IACE,GAAG;AAAA,IACH,cAAc,aAAa,eACvB,EAAE,GAAG,aAAa,cAAc,eAAe,OAAU,IACzD,aAAa;AAAA,EACnB,IACA;AACJ,QAAM,0BAA0B,iBAC5B;AAAA,IACE,GAAG;AAAA,IACH,cAAc,eAAe,eACzB,EAAE,GAAG,eAAe,cAAc,eAAe,OAAU,IAC3D,eAAe;AAAA,EACrB,IACA;AAEJ,QAAM,gBAAgB,gBAAgB,EAAE,GAAG,uBAAuB,GAAG,wBAAwB,CAAC;AAE9F,QAAM,eAAoC;AAAA,IACxC,cAAc;AAAA,MACZ,+BAA+B,+CAAe;AAAA,MAC9C,aAAa,+CAAe;AAAA,MAC5B,UAAU,+CAAe;AAAA,IAC3B;AAAA,IACA,aAAa;AAAA,MACX,UAAU,+CAAe;AAAA,MACzB,UAAU,+CAAe;AAAA,IAC3B;AAAA,IAEA,GAAG,cAAc;AAAA;AAAA;AAAA,IAGjB,eAAe;AAAA,EACjB;AAEA,OAAI,+CAAe,wBAAuB,OAAO;AAC/C,iBAAa,aAAa,UAAU;AAAA,EACtC;AAEA,QAAM,sBAAsB;AAAA,IAC1B,GAAG;AAAA,IACH,GAAG;AAAA,IACH,cAAc,kBAAkB,YAAY;AAAA,EAC9C;AAEA,QAAM,yBAEF;AAAA,IACF,GAAG;AAAA,IACH,SAAS;AAAA,IACT,cAAc;AAAA,IACd,eAAe,aAAa;AAAA,EAC9B;AAEA,SAAO;AACT;AAGO,SAAS,eAAiC,KAAoB;AACnE,SAAO,OAAO,YAAY,OAAO,QAAQ,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,MAAM,MAAM,MAAS,CAAC;AAClF;AAEO,SAAS,kBAAkB,QAA6B;AAC7D,SAAO;AAAA,IACL,eAAe,OAAO,iBAAiB,gDAA2B;AAAA,IAClE,aAAa,EAAE,GAAG,8CAA2B,GAAG,eAAe,OAAO,WAAW,EAAE;AAAA,IACnF,cAAc,EAAE,GAAG,gDAA4B,GAAG,eAAe,OAAO,YAAY,EAAE;AAAA,EACxF;AACF;","names":[]}

package/dist/voice/turn_config/utils.d.cts

@@ -0,0 +1,25 @@
+import { type AgentSessionOptions, type InternalSessionOptions } from '../agent_session.js';
+import { type TurnHandlingOptions } from './turn_handling.js';
+export declare function migrateLegacyOptions<UserData>(legacyOptions: AgentSessionOptions<UserData>): AgentSessionOptions<UserData> & {
+    options: InternalSessionOptions;
+};
+/** Remove keys whose value is `undefined` so they don't shadow defaults when spread. */
+export declare function stripUndefined<T extends object>(obj: T): Partial<T>;
+export declare function mergeWithDefaults(config: TurnHandlingOptions): {
+    readonly turnDetection: import("../agent_session.js").TurnDetectionMode | undefined;
+    readonly endpointing: {
+        mode: "fixed" | "dynamic";
+        minDelay: number;
+        maxDelay: number;
+    };
+    readonly interruption: {
+        enabled: boolean;
+        mode: false | "vad" | "adaptive" | undefined;
+        discardAudioIfUninterruptible: boolean;
+        minDuration: number;
+        minWords: number;
+        falseInterruptionTimeout: number;
+        resumeFalseInterruption: boolean;
+    };
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/voice/turn_config/utils.d.ts

@@ -0,0 +1,25 @@
+import { type AgentSessionOptions, type InternalSessionOptions } from '../agent_session.js';
+import { type TurnHandlingOptions } from './turn_handling.js';
+export declare function migrateLegacyOptions<UserData>(legacyOptions: AgentSessionOptions<UserData>): AgentSessionOptions<UserData> & {
+    options: InternalSessionOptions;
+};
+/** Remove keys whose value is `undefined` so they don't shadow defaults when spread. */
+export declare function stripUndefined<T extends object>(obj: T): Partial<T>;
+export declare function mergeWithDefaults(config: TurnHandlingOptions): {
+    readonly turnDetection: import("../agent_session.js").TurnDetectionMode | undefined;
+    readonly endpointing: {
+        mode: "fixed" | "dynamic";
+        minDelay: number;
+        maxDelay: number;
+    };
+    readonly interruption: {
+        enabled: boolean;
+        mode: false | "vad" | "adaptive" | undefined;
+        discardAudioIfUninterruptible: boolean;
+        minDuration: number;
+        minWords: number;
+        falseInterruptionTimeout: number;
+        resumeFalseInterruption: boolean;
+    };
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/voice/turn_config/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/voice/turn_config/utils.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAE5B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,KAAK,mBAAmB,EAA8B,MAAM,oBAAoB,CAAC;AAE1F,wBAAgB,oBAAoB,CAAC,QAAQ,EAC3C,aAAa,EAAE,mBAAmB,CAAC,QAAQ,CAAC,GAC3C,mBAAmB,CAAC,QAAQ,CAAC,GAAG;IAAE,OAAO,EAAE,sBAAsB,CAAA;CAAE,CA0ErE;AAED,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAEnE;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,mBAAmB;;;;;;;;;;;;;;;;EAM5D"}