@livekit/agents 1.1.0 → 1.2.0

package/dist/voice/turn_config/utils.js

@@ -0,0 +1,131 @@
+import { log } from "../../log.js";
+import {
+} from "../agent_session.js";
+import { defaultEndpointingOptions } from "./endpointing.js";
+import { defaultInterruptionOptions } from "./interruption.js";
+import { defaultTurnHandlingOptions } from "./turn_handling.js";
+const defaultSessionOptions = {
+  maxToolSteps: 3,
+  preemptiveGeneration: true,
+  userAwayTimeout: 15,
+  aecWarmupDuration: 3e3,
+  turnHandling: {},
+  useTtsAlignedTranscript: true
+};
+const defaultLegacyVoiceOptions = {
+  minEndpointingDelay: defaultTurnHandlingOptions.endpointing.minDelay,
+  maxEndpointingDelay: defaultTurnHandlingOptions.endpointing.maxDelay,
+  maxToolSteps: defaultSessionOptions.maxToolSteps,
+  preemptiveGeneration: defaultSessionOptions.preemptiveGeneration
+};
+function migrateLegacyOptions(legacyOptions) {
+  var _a, _b, _c;
+  const logger = log();
+  const {
+    voiceOptions,
+    turnDetection,
+    stt,
+    vad,
+    llm,
+    tts,
+    userData,
+    connOptions,
+    ...sessionOptions
+  } = legacyOptions;
+  if (voiceOptions !== void 0) {
+    logger.warn(
+      "voiceOptions is deprecated, use top-level SessionOptions fields on AgentSessionOptions instead"
+    );
+  }
+  const turnHandling = {
+    interruption: {
+      discardAudioIfUninterruptible: voiceOptions == null ? void 0 : voiceOptions.discardAudioIfUninterruptible,
+      minDuration: voiceOptions == null ? void 0 : voiceOptions.minInterruptionDuration,
+      minWords: voiceOptions == null ? void 0 : voiceOptions.minInterruptionWords,
+      ...(_a = sessionOptions.turnHandling) == null ? void 0 : _a.interruption
+    },
+    endpointing: {
+      minDelay: voiceOptions == null ? void 0 : voiceOptions.minEndpointingDelay,
+      maxDelay: voiceOptions == null ? void 0 : voiceOptions.maxEndpointingDelay,
+      ...(_b = sessionOptions.turnHandling) == null ? void 0 : _b.endpointing
+    },
+    turnDetection: ((_c = sessionOptions == null ? void 0 : sessionOptions.turnHandling) == null ? void 0 : _c.turnDetection) ?? turnDetection
+  };
+  if ((voiceOptions == null ? void 0 : voiceOptions.allowInterruptions) === false && turnHandling.interruption.enabled === void 0) {
+    turnHandling.interruption.enabled = false;
+  }
+  const migratedVoiceOptions = {};
+  if ((voiceOptions == null ? void 0 : voiceOptions.maxToolSteps) !== void 0) {
+    migratedVoiceOptions.maxToolSteps = voiceOptions.maxToolSteps;
+  }
+  if ((voiceOptions == null ? void 0 : voiceOptions.preemptiveGeneration) !== void 0) {
+    migratedVoiceOptions.preemptiveGeneration = voiceOptions.preemptiveGeneration;
+  }
+  if ((voiceOptions == null ? void 0 : voiceOptions.userAwayTimeout) !== void 0) {
+    migratedVoiceOptions.userAwayTimeout = voiceOptions.userAwayTimeout;
+  }
+  const legacyVoiceOptions = { ...defaultLegacyVoiceOptions, ...voiceOptions };
+  const agentSessionOptions = {
+    stt,
+    vad,
+    llm,
+    tts,
+    userData,
+    connOptions,
+    ...defaultSessionOptions,
+    ...migratedVoiceOptions,
+    ...sessionOptions,
+    turnHandling: mergeWithDefaults(turnHandling),
+    // repopulate the deprecated voice options with migrated options for backwards compatibility
+    voiceOptions: legacyVoiceOptions
+  };
+  return { agentSessionOptions, legacyVoiceOptions };
+}
+function stripUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+function mergeWithDefaults(config) {
+  return {
+    turnDetection: config.turnDetection ?? defaultTurnHandlingOptions.turnDetection,
+    endpointing: { ...defaultEndpointingOptions, ...stripUndefined(config.endpointing) },
+    interruption: { ...defaultInterruptionOptions, ...stripUndefined(config.interruption) }
+  };
+}
+function migrateTurnHandling(opts) {
+  if (opts.turnHandling !== void 0) {
+    return opts.turnHandling;
+  }
+  const migrated = {};
+  const endpointing = {};
+  if (opts.minEndpointingDelay !== void 0) {
+    endpointing.minDelay = opts.minEndpointingDelay;
+  }
+  if (opts.maxEndpointingDelay !== void 0) {
+    endpointing.maxDelay = opts.maxEndpointingDelay;
+  }
+  if (Object.keys(endpointing).length > 0) {
+    migrated.endpointing = endpointing;
+  }
+  const interruption = {};
+  if (opts.allowInterruptions === false) {
+    interruption.enabled = false;
+  }
+  if (Object.keys(interruption).length > 0) {
+    migrated.interruption = interruption;
+  }
+  if (opts.turnDetection !== void 0) {
+    migrated.turnDetection = opts.turnDetection;
+  }
+  return {
+    ...migrated.endpointing ? { endpointing: migrated.endpointing } : {},
+    ...migrated.interruption ? { interruption: migrated.interruption } : {},
+    ...migrated.turnDetection !== void 0 ? { turnDetection: migrated.turnDetection } : {}
+  };
+}
+export {
+  mergeWithDefaults,
+  migrateLegacyOptions,
+  migrateTurnHandling,
+  stripUndefined
+};
+//# sourceMappingURL=utils.js.map

package/dist/voice/turn_config/utils.js.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  type TurnDetectionMode,\n  type VoiceOptions,\n} from '../agent_session.js';\nimport { defaultEndpointingOptions } from './endpointing.js';\nimport { defaultInterruptionOptions } from './interruption.js';\nimport { type TurnHandlingOptions, defaultTurnHandlingOptions } from './turn_handling.js';\n\nconst defaultSessionOptions = {\n  maxToolSteps: 3,\n  preemptiveGeneration: true,\n  userAwayTimeout: 15.0,\n  aecWarmupDuration: 3000,\n  turnHandling: {},\n  useTtsAlignedTranscript: true,\n} as const satisfies AgentSessionOptions;\n\nconst defaultLegacyVoiceOptions: VoiceOptions = {\n  minEndpointingDelay: defaultTurnHandlingOptions.endpointing.minDelay,\n  maxEndpointingDelay: defaultTurnHandlingOptions.endpointing.maxDelay,\n  maxToolSteps: defaultSessionOptions.maxToolSteps,\n  preemptiveGeneration: defaultSessionOptions.preemptiveGeneration,\n};\n\nexport function migrateLegacyOptions<UserData>(legacyOptions: AgentSessionOptions<UserData>): {\n  agentSessionOptions: InternalSessionOptions<UserData>;\n  legacyVoiceOptions: VoiceOptions;\n} {\n  const logger = log();\n  const {\n    voiceOptions,\n    turnDetection,\n    stt,\n    vad,\n    llm,\n    tts,\n    userData,\n    connOptions,\n    ...sessionOptions\n  } = legacyOptions;\n\n  if (voiceOptions !== undefined) {\n    logger.warn(\n      'voiceOptions is deprecated, use top-level SessionOptions fields on AgentSessionOptions instead',\n    );\n  }\n\n  const turnHandling: TurnHandlingOptions = {\n    interruption: {\n      discardAudioIfUninterruptible: voiceOptions?.discardAudioIfUninterruptible,\n      minDuration: voiceOptions?.minInterruptionDuration,\n      minWords: voiceOptions?.minInterruptionWords,\n      ...sessionOptions.turnHandling?.interruption,\n    },\n    endpointing: {\n      minDelay: voiceOptions?.minEndpointingDelay,\n      maxDelay: voiceOptions?.maxEndpointingDelay,\n      ...sessionOptions.turnHandling?.endpointing,\n    },\n\n    turnDetection: sessionOptions?.turnHandling?.turnDetection ?? turnDetection,\n  } as const;\n\n  if (\n    voiceOptions?.allowInterruptions === false &&\n    turnHandling.interruption.enabled === undefined\n  ) {\n    turnHandling.interruption.enabled = false;\n  }\n\n  const migratedVoiceOptions: AgentSessionOptions<UserData> = {};\n\n  if (voiceOptions?.maxToolSteps !== undefined) {\n    migratedVoiceOptions.maxToolSteps = voiceOptions.maxToolSteps;\n  }\n  if (voiceOptions?.preemptiveGeneration !== undefined) {\n    migratedVoiceOptions.preemptiveGeneration = voiceOptions.preemptiveGeneration;\n  }\n  if (voiceOptions?.userAwayTimeout !== undefined) {\n    migratedVoiceOptions.userAwayTimeout = voiceOptions.userAwayTimeout;\n  }\n\n  const legacyVoiceOptions = { ...defaultLegacyVoiceOptions, ...voiceOptions };\n\n  const agentSessionOptions = {\n    stt,\n    vad,\n    llm,\n    tts,\n    userData,\n    connOptions,\n    ...defaultSessionOptions,\n    ...migratedVoiceOptions,\n    ...sessionOptions,\n    turnHandling: mergeWithDefaults(turnHandling),\n    // repopulate the deprecated voice options with migrated options for backwards compatibility\n    voiceOptions: legacyVoiceOptions,\n  };\n\n  return { agentSessionOptions, legacyVoiceOptions };\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\n/**\n * Build a partial {@link TurnHandlingOptions} from deprecated Agent constructor fields.\n * Mirrors the Python Agent compatibility path, but keeps the JS API surface explicit.\n */\nexport function migrateTurnHandling(opts: {\n  turnDetection?: TurnDetectionMode;\n  allowInterruptions?: boolean;\n  minEndpointingDelay?: number;\n  maxEndpointingDelay?: number;\n  turnHandling?: TurnHandlingOptions;\n}): Partial<TurnHandlingOptions> {\n  if (opts.turnHandling !== undefined) {\n    return opts.turnHandling;\n  }\n\n  const migrated: Partial<TurnHandlingOptions> = {};\n\n  const endpointing: Partial<TurnHandlingOptions['endpointing']> = {};\n  if (opts.minEndpointingDelay !== undefined) {\n    endpointing.minDelay = opts.minEndpointingDelay;\n  }\n  if (opts.maxEndpointingDelay !== undefined) {\n    endpointing.maxDelay = opts.maxEndpointingDelay;\n  }\n  if (Object.keys(endpointing).length > 0) {\n    migrated.endpointing = endpointing;\n  }\n\n  const interruption: Partial<TurnHandlingOptions['interruption']> = {};\n  if (opts.allowInterruptions === false) {\n    interruption.enabled = false;\n  }\n  if (Object.keys(interruption).length > 0) {\n    migrated.interruption = interruption;\n  }\n\n  if (opts.turnDetection !== undefined) {\n    migrated.turnDetection = opts.turnDetection;\n  }\n\n  return {\n    ...(migrated.endpointing ? { endpointing: migrated.endpointing } : {}),\n    ...(migrated.interruption ? { interruption: migrated.interruption } : {}),\n    ...(migrated.turnDetection !== undefined ? { turnDetection: migrated.turnDetection } : {}),\n  };\n}\n"],"mappings":"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","names":[]}

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

@@ -0,0 +1,128 @@
+"use strict";
+var import_vitest = require("vitest");
+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");
+var import_utils = require("./utils.cjs");
+(0, import_vitest.beforeAll)(() => {
+  (0, import_log.initializeLogger)({ pretty: true, level: "info" });
+});
+(0, import_vitest.describe)("migrateLegacyOptions", () => {
+  (0, import_vitest.it)("should return all defaults when no options are provided", () => {
+    const { agentSessionOptions: result } = (0, import_utils.migrateLegacyOptions)({});
+    (0, import_vitest.expect)(result.turnHandling).toEqual({
+      turnDetection: import_turn_handling.defaultTurnHandlingOptions.turnDetection,
+      endpointing: import_endpointing.defaultEndpointingOptions,
+      interruption: import_interruption.defaultInterruptionOptions
+    });
+    (0, import_vitest.expect)(result.maxToolSteps).toBe(import_agent_session.defaultAgentSessionOptions.maxToolSteps);
+    (0, import_vitest.expect)(result.preemptiveGeneration).toBe(import_agent_session.defaultAgentSessionOptions.preemptiveGeneration);
+    (0, import_vitest.expect)(result.userAwayTimeout).toBe(import_agent_session.defaultAgentSessionOptions.userAwayTimeout);
+  });
+  (0, import_vitest.it)("should migrate legacy flat fields into nested turnHandling config", () => {
+    const { agentSessionOptions: result } = (0, import_utils.migrateLegacyOptions)({
+      voiceOptions: {
+        minInterruptionDuration: 1e3,
+        minInterruptionWords: 3,
+        discardAudioIfUninterruptible: false,
+        minEndpointingDelay: 800,
+        maxEndpointingDelay: 5e3
+      }
+    });
+    (0, import_vitest.expect)(result.turnHandling.interruption.minDuration).toBe(1e3);
+    (0, import_vitest.expect)(result.turnHandling.interruption.minWords).toBe(3);
+    (0, import_vitest.expect)(result.turnHandling.interruption.discardAudioIfUninterruptible).toBe(false);
+    (0, import_vitest.expect)(result.turnHandling.endpointing.minDelay).toBe(800);
+    (0, import_vitest.expect)(result.turnHandling.endpointing.maxDelay).toBe(5e3);
+  });
+  (0, import_vitest.it)("should set interruption.enabled to false when allowInterruptions is false", () => {
+    const { agentSessionOptions: result } = (0, import_utils.migrateLegacyOptions)({
+      voiceOptions: { allowInterruptions: false }
+    });
+    (0, import_vitest.expect)(result.turnHandling.interruption.enabled).toBe(false);
+  });
+  (0, import_vitest.it)("should give top-level fields precedence over voiceOptions", () => {
+    const { agentSessionOptions: result } = (0, import_utils.migrateLegacyOptions)({
+      voiceOptions: {
+        minInterruptionDuration: 1e3,
+        maxEndpointingDelay: 5e3,
+        maxToolSteps: 10
+      },
+      turnHandling: {
+        interruption: {
+          minDuration: 2e3
+        },
+        endpointing: {
+          maxDelay: 8e3
+        }
+      },
+      maxToolSteps: 5
+    });
+    (0, import_vitest.expect)(result.turnHandling.interruption.minDuration).toBe(2e3);
+    (0, import_vitest.expect)(result.turnHandling.endpointing.maxDelay).toBe(8e3);
+    (0, import_vitest.expect)(result.maxToolSteps).toBe(5);
+  });
+  (0, import_vitest.it)("should preserve top-level turnDetection in the result", () => {
+    const { agentSessionOptions: result } = (0, import_utils.migrateLegacyOptions)({
+      turnDetection: "vad"
+    });
+    (0, import_vitest.expect)(result.turnHandling.turnDetection).toBe("vad");
+  });
+});
+(0, import_vitest.describe)("migrateTurnHandling", () => {
+  (0, import_vitest.it)("should return empty partial when no deprecated Agent fields are given", () => {
+    const result = (0, import_utils.migrateTurnHandling)({});
+    (0, import_vitest.expect)(result).toEqual({});
+  });
+  (0, import_vitest.it)("should set interruption.enabled to false when allowInterruptions is false", () => {
+    const result = (0, import_utils.migrateTurnHandling)({ allowInterruptions: false });
+    (0, import_vitest.expect)(result.interruption).toEqual({ enabled: false });
+    (0, import_vitest.expect)(result.endpointing).toBeUndefined();
+    (0, import_vitest.expect)(result.turnDetection).toBeUndefined();
+  });
+  (0, import_vitest.it)("should not set interruption when allowInterruptions is true or undefined", () => {
+    (0, import_vitest.expect)((0, import_utils.migrateTurnHandling)({ allowInterruptions: true })).toEqual({});
+    (0, import_vitest.expect)((0, import_utils.migrateTurnHandling)({ allowInterruptions: void 0 })).toEqual({});
+  });
+  (0, import_vitest.it)("should map minEndpointingDelay to endpointing.minDelay", () => {
+    const result = (0, import_utils.migrateTurnHandling)({ minEndpointingDelay: 800 });
+    (0, import_vitest.expect)(result.endpointing).toEqual({ minDelay: 800 });
+  });
+  (0, import_vitest.it)("should map maxEndpointingDelay to endpointing.maxDelay", () => {
+    const result = (0, import_utils.migrateTurnHandling)({ maxEndpointingDelay: 5e3 });
+    (0, import_vitest.expect)(result.endpointing).toEqual({ maxDelay: 5e3 });
+  });
+  (0, import_vitest.it)("should pass through turnDetection", () => {
+    const result = (0, import_utils.migrateTurnHandling)({ turnDetection: "vad" });
+    (0, import_vitest.expect)(result.turnDetection).toBe("vad");
+  });
+  (0, import_vitest.it)("should combine all deprecated Agent fields", () => {
+    const result = (0, import_utils.migrateTurnHandling)({
+      turnDetection: "stt",
+      allowInterruptions: false,
+      minEndpointingDelay: 400,
+      maxEndpointingDelay: 3e3
+    });
+    (0, import_vitest.expect)(result.turnDetection).toBe("stt");
+    (0, import_vitest.expect)(result.interruption).toEqual({ enabled: false });
+    (0, import_vitest.expect)(result.endpointing).toEqual({ minDelay: 400, maxDelay: 3e3 });
+  });
+  (0, import_vitest.it)("should ignore deprecated Agent fields when explicit turnHandling is provided", () => {
+    const turnHandling = {
+      endpointing: { minDelay: 999, maxDelay: 4e3 },
+      interruption: { enabled: true },
+      turnDetection: "vad"
+    };
+    const result = (0, import_utils.migrateTurnHandling)({
+      turnHandling,
+      turnDetection: "stt",
+      allowInterruptions: false,
+      minEndpointingDelay: 100,
+      maxEndpointingDelay: 200
+    });
+    (0, import_vitest.expect)(result).toEqual(turnHandling);
+  });
+});
+//# sourceMappingURL=utils.test.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/voice/turn_config/utils.test.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { beforeAll, describe, expect, it } from 'vitest';\nimport { initializeLogger } from '../../log.js';\nimport { defaultAgentSessionOptions } from '../agent_session.js';\nimport { defaultEndpointingOptions } from './endpointing.js';\nimport { defaultInterruptionOptions } from './interruption.js';\nimport { defaultTurnHandlingOptions } from './turn_handling.js';\nimport { migrateLegacyOptions, migrateTurnHandling } from './utils.js';\n\nbeforeAll(() => {\n  initializeLogger({ pretty: true, level: 'info' });\n});\n\ndescribe('migrateLegacyOptions', () => {\n  it('should return all defaults when no options are provided', () => {\n    const { agentSessionOptions: result } = migrateLegacyOptions({});\n\n    expect(result.turnHandling).toEqual({\n      turnDetection: defaultTurnHandlingOptions.turnDetection,\n      endpointing: defaultEndpointingOptions,\n      interruption: defaultInterruptionOptions,\n    });\n    expect(result.maxToolSteps).toBe(defaultAgentSessionOptions.maxToolSteps);\n    expect(result.preemptiveGeneration).toBe(defaultAgentSessionOptions.preemptiveGeneration);\n    expect(result.userAwayTimeout).toBe(defaultAgentSessionOptions.userAwayTimeout);\n  });\n\n  it('should migrate legacy flat fields into nested turnHandling config', () => {\n    const { agentSessionOptions: result } = migrateLegacyOptions({\n      voiceOptions: {\n        minInterruptionDuration: 1000,\n        minInterruptionWords: 3,\n        discardAudioIfUninterruptible: false,\n        minEndpointingDelay: 800,\n        maxEndpointingDelay: 5000,\n      },\n    });\n\n    expect(result.turnHandling.interruption!.minDuration).toBe(1000);\n    expect(result.turnHandling.interruption!.minWords).toBe(3);\n    expect(result.turnHandling.interruption!.discardAudioIfUninterruptible).toBe(false);\n    expect(result.turnHandling.endpointing!.minDelay).toBe(800);\n    expect(result.turnHandling.endpointing!.maxDelay).toBe(5000);\n  });\n\n  it('should set interruption.enabled to false when allowInterruptions is false', () => {\n    const { agentSessionOptions: result } = migrateLegacyOptions({\n      voiceOptions: { allowInterruptions: false },\n    });\n\n    expect(result.turnHandling.interruption!.enabled).toBe(false);\n  });\n\n  it('should give top-level fields precedence over voiceOptions', () => {\n    const { agentSessionOptions: result } = migrateLegacyOptions({\n      voiceOptions: {\n        minInterruptionDuration: 1000,\n        maxEndpointingDelay: 5000,\n        maxToolSteps: 10,\n      },\n      turnHandling: {\n        interruption: {\n          minDuration: 2000,\n        },\n        endpointing: {\n          maxDelay: 8000,\n        },\n      },\n      maxToolSteps: 5,\n    });\n\n    expect(result.turnHandling.interruption!.minDuration).toBe(2000);\n    expect(result.turnHandling.endpointing!.maxDelay).toBe(8000);\n    expect(result.maxToolSteps).toBe(5);\n  });\n\n  it('should preserve top-level turnDetection in the result', () => {\n    const { agentSessionOptions: result } = migrateLegacyOptions({\n      turnDetection: 'vad',\n    });\n\n    expect(result.turnHandling.turnDetection).toBe('vad');\n  });\n});\n\ndescribe('migrateTurnHandling', () => {\n  it('should return empty partial when no deprecated Agent fields are given', () => {\n    const result = migrateTurnHandling({});\n    expect(result).toEqual({});\n  });\n\n  it('should set interruption.enabled to false when allowInterruptions is false', () => {\n    const result = migrateTurnHandling({ allowInterruptions: false });\n    expect(result.interruption).toEqual({ enabled: false });\n    expect(result.endpointing).toBeUndefined();\n    expect(result.turnDetection).toBeUndefined();\n  });\n\n  it('should not set interruption when allowInterruptions is true or undefined', () => {\n    expect(migrateTurnHandling({ allowInterruptions: true })).toEqual({});\n    expect(migrateTurnHandling({ allowInterruptions: undefined })).toEqual({});\n  });\n\n  it('should map minEndpointingDelay to endpointing.minDelay', () => {\n    const result = migrateTurnHandling({ minEndpointingDelay: 800 });\n    expect(result.endpointing).toEqual({ minDelay: 800 });\n  });\n\n  it('should map maxEndpointingDelay to endpointing.maxDelay', () => {\n    const result = migrateTurnHandling({ maxEndpointingDelay: 5000 });\n    expect(result.endpointing).toEqual({ maxDelay: 5000 });\n  });\n\n  it('should pass through turnDetection', () => {\n    const result = migrateTurnHandling({ turnDetection: 'vad' });\n    expect(result.turnDetection).toBe('vad');\n  });\n\n  it('should combine all deprecated Agent fields', () => {\n    const result = migrateTurnHandling({\n      turnDetection: 'stt',\n      allowInterruptions: false,\n      minEndpointingDelay: 400,\n      maxEndpointingDelay: 3000,\n    });\n    expect(result.turnDetection).toBe('stt');\n    expect(result.interruption).toEqual({ enabled: false });\n    expect(result.endpointing).toEqual({ minDelay: 400, maxDelay: 3000 });\n  });\n\n  it('should ignore deprecated Agent fields when explicit turnHandling is provided', () => {\n    const turnHandling = {\n      endpointing: { minDelay: 999, maxDelay: 4000 },\n      interruption: { enabled: true },\n      turnDetection: 'vad' as const,\n    };\n    const result = migrateTurnHandling({\n      turnHandling,\n      turnDetection: 'stt',\n      allowInterruptions: false,\n      minEndpointingDelay: 100,\n      maxEndpointingDelay: 200,\n    });\n    expect(result).toEqual(turnHandling);\n  });\n});\n"],"mappings":"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","names":[]}

package/dist/voice/turn_config/utils.test.js

@@ -0,0 +1,127 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { initializeLogger } from "../../log.js";
+import { defaultAgentSessionOptions } from "../agent_session.js";
+import { defaultEndpointingOptions } from "./endpointing.js";
+import { defaultInterruptionOptions } from "./interruption.js";
+import { defaultTurnHandlingOptions } from "./turn_handling.js";
+import { migrateLegacyOptions, migrateTurnHandling } from "./utils.js";
+beforeAll(() => {
+  initializeLogger({ pretty: true, level: "info" });
+});
+describe("migrateLegacyOptions", () => {
+  it("should return all defaults when no options are provided", () => {
+    const { agentSessionOptions: result } = migrateLegacyOptions({});
+    expect(result.turnHandling).toEqual({
+      turnDetection: defaultTurnHandlingOptions.turnDetection,
+      endpointing: defaultEndpointingOptions,
+      interruption: defaultInterruptionOptions
+    });
+    expect(result.maxToolSteps).toBe(defaultAgentSessionOptions.maxToolSteps);
+    expect(result.preemptiveGeneration).toBe(defaultAgentSessionOptions.preemptiveGeneration);
+    expect(result.userAwayTimeout).toBe(defaultAgentSessionOptions.userAwayTimeout);
+  });
+  it("should migrate legacy flat fields into nested turnHandling config", () => {
+    const { agentSessionOptions: result } = migrateLegacyOptions({
+      voiceOptions: {
+        minInterruptionDuration: 1e3,
+        minInterruptionWords: 3,
+        discardAudioIfUninterruptible: false,
+        minEndpointingDelay: 800,
+        maxEndpointingDelay: 5e3
+      }
+    });
+    expect(result.turnHandling.interruption.minDuration).toBe(1e3);
+    expect(result.turnHandling.interruption.minWords).toBe(3);
+    expect(result.turnHandling.interruption.discardAudioIfUninterruptible).toBe(false);
+    expect(result.turnHandling.endpointing.minDelay).toBe(800);
+    expect(result.turnHandling.endpointing.maxDelay).toBe(5e3);
+  });
+  it("should set interruption.enabled to false when allowInterruptions is false", () => {
+    const { agentSessionOptions: result } = migrateLegacyOptions({
+      voiceOptions: { allowInterruptions: false }
+    });
+    expect(result.turnHandling.interruption.enabled).toBe(false);
+  });
+  it("should give top-level fields precedence over voiceOptions", () => {
+    const { agentSessionOptions: result } = migrateLegacyOptions({
+      voiceOptions: {
+        minInterruptionDuration: 1e3,
+        maxEndpointingDelay: 5e3,
+        maxToolSteps: 10
+      },
+      turnHandling: {
+        interruption: {
+          minDuration: 2e3
+        },
+        endpointing: {
+          maxDelay: 8e3
+        }
+      },
+      maxToolSteps: 5
+    });
+    expect(result.turnHandling.interruption.minDuration).toBe(2e3);
+    expect(result.turnHandling.endpointing.maxDelay).toBe(8e3);
+    expect(result.maxToolSteps).toBe(5);
+  });
+  it("should preserve top-level turnDetection in the result", () => {
+    const { agentSessionOptions: result } = migrateLegacyOptions({
+      turnDetection: "vad"
+    });
+    expect(result.turnHandling.turnDetection).toBe("vad");
+  });
+});
+describe("migrateTurnHandling", () => {
+  it("should return empty partial when no deprecated Agent fields are given", () => {
+    const result = migrateTurnHandling({});
+    expect(result).toEqual({});
+  });
+  it("should set interruption.enabled to false when allowInterruptions is false", () => {
+    const result = migrateTurnHandling({ allowInterruptions: false });
+    expect(result.interruption).toEqual({ enabled: false });
+    expect(result.endpointing).toBeUndefined();
+    expect(result.turnDetection).toBeUndefined();
+  });
+  it("should not set interruption when allowInterruptions is true or undefined", () => {
+    expect(migrateTurnHandling({ allowInterruptions: true })).toEqual({});
+    expect(migrateTurnHandling({ allowInterruptions: void 0 })).toEqual({});
+  });
+  it("should map minEndpointingDelay to endpointing.minDelay", () => {
+    const result = migrateTurnHandling({ minEndpointingDelay: 800 });
+    expect(result.endpointing).toEqual({ minDelay: 800 });
+  });
+  it("should map maxEndpointingDelay to endpointing.maxDelay", () => {
+    const result = migrateTurnHandling({ maxEndpointingDelay: 5e3 });
+    expect(result.endpointing).toEqual({ maxDelay: 5e3 });
+  });
+  it("should pass through turnDetection", () => {
+    const result = migrateTurnHandling({ turnDetection: "vad" });
+    expect(result.turnDetection).toBe("vad");
+  });
+  it("should combine all deprecated Agent fields", () => {
+    const result = migrateTurnHandling({
+      turnDetection: "stt",
+      allowInterruptions: false,
+      minEndpointingDelay: 400,
+      maxEndpointingDelay: 3e3
+    });
+    expect(result.turnDetection).toBe("stt");
+    expect(result.interruption).toEqual({ enabled: false });
+    expect(result.endpointing).toEqual({ minDelay: 400, maxDelay: 3e3 });
+  });
+  it("should ignore deprecated Agent fields when explicit turnHandling is provided", () => {
+    const turnHandling = {
+      endpointing: { minDelay: 999, maxDelay: 4e3 },
+      interruption: { enabled: true },
+      turnDetection: "vad"
+    };
+    const result = migrateTurnHandling({
+      turnHandling,
+      turnDetection: "stt",
+      allowInterruptions: false,
+      minEndpointingDelay: 100,
+      maxEndpointingDelay: 200
+    });
+    expect(result).toEqual(turnHandling);
+  });
+});
+//# sourceMappingURL=utils.test.js.map

package/dist/voice/turn_config/utils.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/voice/turn_config/utils.test.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { beforeAll, describe, expect, it } from 'vitest';\nimport { initializeLogger } from '../../log.js';\nimport { defaultAgentSessionOptions } from '../agent_session.js';\nimport { defaultEndpointingOptions } from './endpointing.js';\nimport { defaultInterruptionOptions } from './interruption.js';\nimport { defaultTurnHandlingOptions } from './turn_handling.js';\nimport { migrateLegacyOptions, migrateTurnHandling } from './utils.js';\n\nbeforeAll(() => {\n  initializeLogger({ pretty: true, level: 'info' });\n});\n\ndescribe('migrateLegacyOptions', () => {\n  it('should return all defaults when no options are provided', () => {\n    const { agentSessionOptions: result } = migrateLegacyOptions({});\n\n    expect(result.turnHandling).toEqual({\n      turnDetection: defaultTurnHandlingOptions.turnDetection,\n      endpointing: defaultEndpointingOptions,\n      interruption: defaultInterruptionOptions,\n    });\n    expect(result.maxToolSteps).toBe(defaultAgentSessionOptions.maxToolSteps);\n    expect(result.preemptiveGeneration).toBe(defaultAgentSessionOptions.preemptiveGeneration);\n    expect(result.userAwayTimeout).toBe(defaultAgentSessionOptions.userAwayTimeout);\n  });\n\n  it('should migrate legacy flat fields into nested turnHandling config', () => {\n    const { agentSessionOptions: result } = migrateLegacyOptions({\n      voiceOptions: {\n        minInterruptionDuration: 1000,\n        minInterruptionWords: 3,\n        discardAudioIfUninterruptible: false,\n        minEndpointingDelay: 800,\n        maxEndpointingDelay: 5000,\n      },\n    });\n\n    expect(result.turnHandling.interruption!.minDuration).toBe(1000);\n    expect(result.turnHandling.interruption!.minWords).toBe(3);\n    expect(result.turnHandling.interruption!.discardAudioIfUninterruptible).toBe(false);\n    expect(result.turnHandling.endpointing!.minDelay).toBe(800);\n    expect(result.turnHandling.endpointing!.maxDelay).toBe(5000);\n  });\n\n  it('should set interruption.enabled to false when allowInterruptions is false', () => {\n    const { agentSessionOptions: result } = migrateLegacyOptions({\n      voiceOptions: { allowInterruptions: false },\n    });\n\n    expect(result.turnHandling.interruption!.enabled).toBe(false);\n  });\n\n  it('should give top-level fields precedence over voiceOptions', () => {\n    const { agentSessionOptions: result } = migrateLegacyOptions({\n      voiceOptions: {\n        minInterruptionDuration: 1000,\n        maxEndpointingDelay: 5000,\n        maxToolSteps: 10,\n      },\n      turnHandling: {\n        interruption: {\n          minDuration: 2000,\n        },\n        endpointing: {\n          maxDelay: 8000,\n        },\n      },\n      maxToolSteps: 5,\n    });\n\n    expect(result.turnHandling.interruption!.minDuration).toBe(2000);\n    expect(result.turnHandling.endpointing!.maxDelay).toBe(8000);\n    expect(result.maxToolSteps).toBe(5);\n  });\n\n  it('should preserve top-level turnDetection in the result', () => {\n    const { agentSessionOptions: result } = migrateLegacyOptions({\n      turnDetection: 'vad',\n    });\n\n    expect(result.turnHandling.turnDetection).toBe('vad');\n  });\n});\n\ndescribe('migrateTurnHandling', () => {\n  it('should return empty partial when no deprecated Agent fields are given', () => {\n    const result = migrateTurnHandling({});\n    expect(result).toEqual({});\n  });\n\n  it('should set interruption.enabled to false when allowInterruptions is false', () => {\n    const result = migrateTurnHandling({ allowInterruptions: false });\n    expect(result.interruption).toEqual({ enabled: false });\n    expect(result.endpointing).toBeUndefined();\n    expect(result.turnDetection).toBeUndefined();\n  });\n\n  it('should not set interruption when allowInterruptions is true or undefined', () => {\n    expect(migrateTurnHandling({ allowInterruptions: true })).toEqual({});\n    expect(migrateTurnHandling({ allowInterruptions: undefined })).toEqual({});\n  });\n\n  it('should map minEndpointingDelay to endpointing.minDelay', () => {\n    const result = migrateTurnHandling({ minEndpointingDelay: 800 });\n    expect(result.endpointing).toEqual({ minDelay: 800 });\n  });\n\n  it('should map maxEndpointingDelay to endpointing.maxDelay', () => {\n    const result = migrateTurnHandling({ maxEndpointingDelay: 5000 });\n    expect(result.endpointing).toEqual({ maxDelay: 5000 });\n  });\n\n  it('should pass through turnDetection', () => {\n    const result = migrateTurnHandling({ turnDetection: 'vad' });\n    expect(result.turnDetection).toBe('vad');\n  });\n\n  it('should combine all deprecated Agent fields', () => {\n    const result = migrateTurnHandling({\n      turnDetection: 'stt',\n      allowInterruptions: false,\n      minEndpointingDelay: 400,\n      maxEndpointingDelay: 3000,\n    });\n    expect(result.turnDetection).toBe('stt');\n    expect(result.interruption).toEqual({ enabled: false });\n    expect(result.endpointing).toEqual({ minDelay: 400, maxDelay: 3000 });\n  });\n\n  it('should ignore deprecated Agent fields when explicit turnHandling is provided', () => {\n    const turnHandling = {\n      endpointing: { minDelay: 999, maxDelay: 4000 },\n      interruption: { enabled: true },\n      turnDetection: 'vad' as const,\n    };\n    const result = migrateTurnHandling({\n      turnHandling,\n      turnDetection: 'stt',\n      allowInterruptions: false,\n      minEndpointingDelay: 100,\n      maxEndpointingDelay: 200,\n    });\n    expect(result).toEqual(turnHandling);\n  });\n});\n"],"mappings":"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","names":[]}

package/dist/voice/utils.cjs

@@ -0,0 +1,47 @@
+"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, {
+  setParticipantSpanAttributes: () => setParticipantSpanAttributes
+});
+module.exports = __toCommonJS(utils_exports);
+var import_telemetry = require("../telemetry/index.cjs");
+function setParticipantSpanAttributes(span, participant) {
+  if (participant.sid) {
+    span.setAttribute(import_telemetry.traceTypes.ATTR_PARTICIPANT_ID, participant.sid);
+  }
+  span.setAttribute(import_telemetry.traceTypes.ATTR_PARTICIPANT_IDENTITY, participant.identity);
+  span.setAttribute(import_telemetry.traceTypes.ATTR_PARTICIPANT_KIND, participantKindName(participant.kind));
+}
+function participantKindName(kind) {
+  const names = {
+    0: "STANDARD",
+    1: "INGRESS",
+    2: "EGRESS",
+    3: "SIP",
+    4: "AGENT",
+    5: "CONNECTOR"
+  };
+  return names[kind] ?? String(kind);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setParticipantSpanAttributes
+});
+//# sourceMappingURL=utils.cjs.map

package/dist/voice/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/voice/utils.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2025 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { Participant, ParticipantKind } from '@livekit/rtc-node';\nimport type { Span } from '@opentelemetry/api';\nimport { traceTypes } from '../telemetry/index.js';\n\nexport function setParticipantSpanAttributes(\n  span: Span,\n  participant: Pick<Participant, 'sid' | 'identity' | 'kind'>,\n): void {\n  if (participant.sid) {\n    span.setAttribute(traceTypes.ATTR_PARTICIPANT_ID, participant.sid);\n  }\n  span.setAttribute(traceTypes.ATTR_PARTICIPANT_IDENTITY, participant.identity);\n  span.setAttribute(traceTypes.ATTR_PARTICIPANT_KIND, participantKindName(participant.kind));\n}\n\nfunction participantKindName(kind: ParticipantKind): string {\n  const names: Record<number, string> = {\n    0: 'STANDARD',\n    1: 'INGRESS',\n    2: 'EGRESS',\n    3: 'SIP',\n    4: 'AGENT',\n    5: 'CONNECTOR',\n  };\n  return names[kind as number] ?? String(kind);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,uBAA2B;AAEpB,SAAS,6BACd,MACA,aACM;AACN,MAAI,YAAY,KAAK;AACnB,SAAK,aAAa,4BAAW,qBAAqB,YAAY,GAAG;AAAA,EACnE;AACA,OAAK,aAAa,4BAAW,2BAA2B,YAAY,QAAQ;AAC5E,OAAK,aAAa,4BAAW,uBAAuB,oBAAoB,YAAY,IAAI,CAAC;AAC3F;AAEA,SAAS,oBAAoB,MAA+B;AAC1D,QAAM,QAAgC;AAAA,IACpC,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,EACL;AACA,SAAO,MAAM,IAAc,KAAK,OAAO,IAAI;AAC7C;","names":[]}

package/dist/voice/utils.d.cts

@@ -0,0 +1,4 @@
+import type { Participant } from '@livekit/rtc-node';
+import type { Span } from '@opentelemetry/api';
+export declare function setParticipantSpanAttributes(span: Span, participant: Pick<Participant, 'sid' | 'identity' | 'kind'>): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/voice/utils.d.ts

@@ -0,0 +1,4 @@
+import type { Participant } from '@livekit/rtc-node';
+import type { Span } from '@opentelemetry/api';
+export declare function setParticipantSpanAttributes(span: Span, participant: Pick<Participant, 'sid' | 'identity' | 'kind'>): void;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/voice/utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAmB,MAAM,mBAAmB,CAAC;AACtE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAG/C,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,UAAU,GAAG,MAAM,CAAC,GAC1D,IAAI,CAMN"}

package/dist/voice/utils.js

@@ -0,0 +1,23 @@
+import { traceTypes } from "../telemetry/index.js";
+function setParticipantSpanAttributes(span, participant) {
+  if (participant.sid) {
+    span.setAttribute(traceTypes.ATTR_PARTICIPANT_ID, participant.sid);
+  }
+  span.setAttribute(traceTypes.ATTR_PARTICIPANT_IDENTITY, participant.identity);
+  span.setAttribute(traceTypes.ATTR_PARTICIPANT_KIND, participantKindName(participant.kind));
+}
+function participantKindName(kind) {
+  const names = {
+    0: "STANDARD",
+    1: "INGRESS",
+    2: "EGRESS",
+    3: "SIP",
+    4: "AGENT",
+    5: "CONNECTOR"
+  };
+  return names[kind] ?? String(kind);
+}
+export {
+  setParticipantSpanAttributes
+};
+//# sourceMappingURL=utils.js.map

package/dist/voice/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/voice/utils.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2025 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { Participant, ParticipantKind } from '@livekit/rtc-node';\nimport type { Span } from '@opentelemetry/api';\nimport { traceTypes } from '../telemetry/index.js';\n\nexport function setParticipantSpanAttributes(\n  span: Span,\n  participant: Pick<Participant, 'sid' | 'identity' | 'kind'>,\n): void {\n  if (participant.sid) {\n    span.setAttribute(traceTypes.ATTR_PARTICIPANT_ID, participant.sid);\n  }\n  span.setAttribute(traceTypes.ATTR_PARTICIPANT_IDENTITY, participant.identity);\n  span.setAttribute(traceTypes.ATTR_PARTICIPANT_KIND, participantKindName(participant.kind));\n}\n\nfunction participantKindName(kind: ParticipantKind): string {\n  const names: Record<number, string> = {\n    0: 'STANDARD',\n    1: 'INGRESS',\n    2: 'EGRESS',\n    3: 'SIP',\n    4: 'AGENT',\n    5: 'CONNECTOR',\n  };\n  return names[kind as number] ?? String(kind);\n}\n"],"mappings":"AAKA,SAAS,kBAAkB;AAEpB,SAAS,6BACd,MACA,aACM;AACN,MAAI,YAAY,KAAK;AACnB,SAAK,aAAa,WAAW,qBAAqB,YAAY,GAAG;AAAA,EACnE;AACA,OAAK,aAAa,WAAW,2BAA2B,YAAY,QAAQ;AAC5E,OAAK,aAAa,WAAW,uBAAuB,oBAAoB,YAAY,IAAI,CAAC;AAC3F;AAEA,SAAS,oBAAoB,MAA+B;AAC1D,QAAM,QAAgC;AAAA,IACpC,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,IACH,GAAG;AAAA,EACL;AACA,SAAO,MAAM,IAAc,KAAK,OAAO,IAAI;AAC7C;","names":[]}