@livekit/agents 1.1.0 → 1.2.1

package/dist/inference/interruption/interruption_detector.d.cts

@@ -0,0 +1,59 @@
+import type { TypedEventEmitter } from '@livekit/typed-emitter';
+import type { InterruptionMetrics } from '../../metrics/base.js';
+import { InterruptionDetectionError } from './errors.js';
+import { InterruptionStreamBase } from './interruption_stream.js';
+import type { InterruptionOptions, OverlappingSpeechEvent } from './types.js';
+type InterruptionCallbacks = {
+    overlapping_speech: (event: OverlappingSpeechEvent) => void;
+    metrics_collected: (metrics: InterruptionMetrics) => void;
+    error: (error: InterruptionDetectionError) => void;
+};
+export type AdaptiveInterruptionDetectorOptions = Omit<Partial<InterruptionOptions>, 'useProxy'>;
+declare const AdaptiveInterruptionDetector_base: new () => TypedEventEmitter<InterruptionCallbacks>;
+export declare class AdaptiveInterruptionDetector extends AdaptiveInterruptionDetector_base {
+    options: InterruptionOptions;
+    private readonly _label;
+    private logger;
+    private streams;
+    constructor(options?: AdaptiveInterruptionDetectorOptions);
+    /**
+     * The model identifier for this detector.
+     */
+    get model(): string;
+    /**
+     * The provider identifier for this detector.
+     */
+    get provider(): string;
+    /**
+     * The label for this detector instance.
+     */
+    get label(): string;
+    /**
+     * The sample rate used for audio processing.
+     */
+    get sampleRate(): number;
+    /**
+     * Emit an error event from the detector.
+     */
+    emitError(error: InterruptionDetectionError): void;
+    /**
+     * Creates a new InterruptionStreamBase for internal use.
+     * The stream can receive audio frames and sentinels via pushFrame().
+     * Use this when you need direct access to the stream for pushing frames.
+     */
+    createStream(): InterruptionStreamBase;
+    /**
+     * Remove a stream from tracking (called when stream is closed).
+     */
+    removeStream(stream: InterruptionStreamBase): void;
+    /**
+     * Update options for the detector and propagate to all active streams.
+     * For WebSocket streams, this triggers a reconnection with new settings.
+     */
+    updateOptions(options: {
+        threshold?: number;
+        minInterruptionDurationInS?: number;
+    }): Promise<void>;
+}
+export {};
+//# sourceMappingURL=interruption_detector.d.ts.map

package/dist/inference/interruption/interruption_detector.d.ts

@@ -0,0 +1,59 @@
+import type { TypedEventEmitter } from '@livekit/typed-emitter';
+import type { InterruptionMetrics } from '../../metrics/base.js';
+import { InterruptionDetectionError } from './errors.js';
+import { InterruptionStreamBase } from './interruption_stream.js';
+import type { InterruptionOptions, OverlappingSpeechEvent } from './types.js';
+type InterruptionCallbacks = {
+    overlapping_speech: (event: OverlappingSpeechEvent) => void;
+    metrics_collected: (metrics: InterruptionMetrics) => void;
+    error: (error: InterruptionDetectionError) => void;
+};
+export type AdaptiveInterruptionDetectorOptions = Omit<Partial<InterruptionOptions>, 'useProxy'>;
+declare const AdaptiveInterruptionDetector_base: new () => TypedEventEmitter<InterruptionCallbacks>;
+export declare class AdaptiveInterruptionDetector extends AdaptiveInterruptionDetector_base {
+    options: InterruptionOptions;
+    private readonly _label;
+    private logger;
+    private streams;
+    constructor(options?: AdaptiveInterruptionDetectorOptions);
+    /**
+     * The model identifier for this detector.
+     */
+    get model(): string;
+    /**
+     * The provider identifier for this detector.
+     */
+    get provider(): string;
+    /**
+     * The label for this detector instance.
+     */
+    get label(): string;
+    /**
+     * The sample rate used for audio processing.
+     */
+    get sampleRate(): number;
+    /**
+     * Emit an error event from the detector.
+     */
+    emitError(error: InterruptionDetectionError): void;
+    /**
+     * Creates a new InterruptionStreamBase for internal use.
+     * The stream can receive audio frames and sentinels via pushFrame().
+     * Use this when you need direct access to the stream for pushing frames.
+     */
+    createStream(): InterruptionStreamBase;
+    /**
+     * Remove a stream from tracking (called when stream is closed).
+     */
+    removeStream(stream: InterruptionStreamBase): void;
+    /**
+     * Update options for the detector and propagate to all active streams.
+     * For WebSocket streams, this triggers a reconnection with new settings.
+     */
+    updateOptions(options: {
+        threshold?: number;
+        minInterruptionDurationInS?: number;
+    }): Promise<void>;
+}
+export {};
+//# sourceMappingURL=interruption_detector.d.ts.map

package/dist/inference/interruption/interruption_detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interruption_detector.d.ts","sourceRoot":"","sources":["../../../src/inference/interruption/interruption_detector.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAGhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAGjE,OAAO,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAE9E,KAAK,qBAAqB,GAAG;IAC3B,kBAAkB,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAC;IAC5D,iBAAiB,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,IAAI,CAAC;IAC1D,KAAK,EAAE,CAAC,KAAK,EAAE,0BAA0B,KAAK,IAAI,CAAC;CACpD,CAAC;AAEF,MAAM,MAAM,mCAAmC,GAAG,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,EAAE,UAAU,CAAC,CAAC;2DAEpB,kBAAkB,qBAAqB,CAAC;AAArH,qBAAa,4BAA6B,SAAQ,iCAAoE;IACpH,OAAO,EAAE,mBAAmB,CAAC;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,MAAM,CAAS;IAEvB,OAAO,CAAC,OAAO,CAA0C;gBAE7C,OAAO,GAAE,mCAAwC;IA6F7D;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,0BAA0B,GAAG,IAAI;IAIlD;;;;OAIG;IACH,YAAY,IAAI,sBAAsB;IAYtC;;OAEG;IACH,YAAY,CAAC,MAAM,EAAE,sBAAsB,GAAG,IAAI;IAIlD;;;OAGG;IACG,aAAa,CAAC,OAAO,EAAE;QAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,0BAA0B,CAAC,EAAE,MAAM,CAAC;KACrC,GAAG,OAAO,CAAC,IAAI,CAAC;CAgBlB"}

package/dist/inference/interruption/interruption_detector.js

@@ -0,0 +1,164 @@
+import EventEmitter from "events";
+import { log } from "../../log.js";
+import { DEFAULT_INFERENCE_URL, STAGING_INFERENCE_URL, getDefaultInferenceUrl } from "../utils.js";
+import { FRAMES_PER_SECOND, SAMPLE_RATE, interruptionOptionDefaults } from "./defaults.js";
+import { InterruptionDetectionError } from "./errors.js";
+import { InterruptionStreamBase } from "./interruption_stream.js";
+class AdaptiveInterruptionDetector extends EventEmitter {
+  options;
+  _label;
+  logger = log();
+  // Use Set instead of WeakSet to allow iteration for propagating option updates
+  streams = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    super();
+    const {
+      maxAudioDurationInS,
+      baseUrl,
+      apiKey,
+      apiSecret,
+      audioPrefixDurationInS,
+      threshold,
+      detectionIntervalInS,
+      inferenceTimeout,
+      minInterruptionDurationInS
+    } = { ...interruptionOptionDefaults, ...options };
+    if (maxAudioDurationInS > 3) {
+      throw new RangeError("maxAudioDurationInS must be less than or equal to 3.0 seconds");
+    }
+    const lkBaseUrl = baseUrl ?? process.env.LIVEKIT_REMOTE_EOT_URL ?? getDefaultInferenceUrl();
+    let lkApiKey = apiKey ?? "";
+    let lkApiSecret = apiSecret ?? "";
+    let useProxy;
+    const isInferenceUrl = lkBaseUrl === DEFAULT_INFERENCE_URL || lkBaseUrl === STAGING_INFERENCE_URL;
+    if (isInferenceUrl) {
+      lkApiKey = apiKey ?? process.env.LIVEKIT_INFERENCE_API_KEY ?? process.env.LIVEKIT_API_KEY ?? "";
+      if (!lkApiKey) {
+        throw new TypeError(
+          "apiKey is required, either as argument or set LIVEKIT_API_KEY environmental variable"
+        );
+      }
+      lkApiSecret = apiSecret ?? process.env.LIVEKIT_INFERENCE_API_SECRET ?? process.env.LIVEKIT_API_SECRET ?? "";
+      if (!lkApiSecret) {
+        throw new TypeError(
+          "apiSecret is required, either as argument or set LIVEKIT_API_SECRET environmental variable"
+        );
+      }
+      useProxy = true;
+    } else {
+      useProxy = false;
+    }
+    const transport = useProxy ? "websocket" : "http";
+    this.logger.debug(
+      {
+        baseUrl: lkBaseUrl,
+        useProxy,
+        transport
+      },
+      "=== Resolved interruption detector transport configuration"
+    );
+    this.options = {
+      sampleRate: SAMPLE_RATE,
+      threshold,
+      minFrames: Math.ceil(minInterruptionDurationInS * FRAMES_PER_SECOND),
+      maxAudioDurationInS,
+      audioPrefixDurationInS,
+      detectionIntervalInS,
+      inferenceTimeout,
+      baseUrl: lkBaseUrl,
+      apiKey: lkApiKey,
+      apiSecret: lkApiSecret,
+      useProxy,
+      minInterruptionDurationInS
+    };
+    this._label = `${this.constructor.name}`;
+    this.logger.debug(
+      {
+        baseUrl: this.options.baseUrl,
+        detectionIntervalInS: this.options.detectionIntervalInS,
+        audioPrefixDurationInS: this.options.audioPrefixDurationInS,
+        maxAudioDurationInS: this.options.maxAudioDurationInS,
+        minFrames: this.options.minFrames,
+        threshold: this.options.threshold,
+        inferenceTimeout: this.options.inferenceTimeout,
+        useProxy: this.options.useProxy,
+        transport
+      },
+      "=== Adaptive interruption detector initialized"
+    );
+  }
+  /**
+   * The model identifier for this detector.
+   */
+  get model() {
+    return "adaptive interruption";
+  }
+  /**
+   * The provider identifier for this detector.
+   */
+  get provider() {
+    return "livekit";
+  }
+  /**
+   * The label for this detector instance.
+   */
+  get label() {
+    return this._label;
+  }
+  /**
+   * The sample rate used for audio processing.
+   */
+  get sampleRate() {
+    return this.options.sampleRate;
+  }
+  /**
+   * Emit an error event from the detector.
+   */
+  emitError(error) {
+    this.emit("error", error);
+  }
+  /**
+   * Creates a new InterruptionStreamBase for internal use.
+   * The stream can receive audio frames and sentinels via pushFrame().
+   * Use this when you need direct access to the stream for pushing frames.
+   */
+  createStream() {
+    try {
+      const streamBase = new InterruptionStreamBase(this, {});
+      this.streams.add(streamBase);
+      return streamBase;
+    } catch (e) {
+      const cause = e instanceof Error ? e : new Error(String(e));
+      this.emitError(new InterruptionDetectionError(cause.message, Date.now(), this._label, false));
+      throw e;
+    }
+  }
+  /**
+   * Remove a stream from tracking (called when stream is closed).
+   */
+  removeStream(stream) {
+    this.streams.delete(stream);
+  }
+  /**
+   * Update options for the detector and propagate to all active streams.
+   * For WebSocket streams, this triggers a reconnection with new settings.
+   */
+  async updateOptions(options) {
+    if (options.threshold !== void 0) {
+      this.options.threshold = options.threshold;
+    }
+    if (options.minInterruptionDurationInS !== void 0) {
+      this.options.minInterruptionDurationInS = options.minInterruptionDurationInS;
+      this.options.minFrames = Math.ceil(options.minInterruptionDurationInS * FRAMES_PER_SECOND);
+    }
+    const updatePromises = [];
+    for (const stream of this.streams) {
+      updatePromises.push(stream.updateOptions(options));
+    }
+    await Promise.all(updatePromises);
+  }
+}
+export {
+  AdaptiveInterruptionDetector
+};
+//# sourceMappingURL=interruption_detector.js.map

package/dist/inference/interruption/interruption_detector.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/interruption_detector.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { TypedEventEmitter } from '@livekit/typed-emitter';\nimport EventEmitter from 'events';\nimport { log } from '../../log.js';\nimport type { InterruptionMetrics } from '../../metrics/base.js';\nimport { DEFAULT_INFERENCE_URL, STAGING_INFERENCE_URL, getDefaultInferenceUrl } from '../utils.js';\nimport { FRAMES_PER_SECOND, SAMPLE_RATE, interruptionOptionDefaults } from './defaults.js';\nimport { InterruptionDetectionError } from './errors.js';\nimport { InterruptionStreamBase } from './interruption_stream.js';\nimport type { InterruptionOptions, OverlappingSpeechEvent } from './types.js';\n\ntype InterruptionCallbacks = {\n  overlapping_speech: (event: OverlappingSpeechEvent) => void;\n  metrics_collected: (metrics: InterruptionMetrics) => void;\n  error: (error: InterruptionDetectionError) => void;\n};\n\nexport type AdaptiveInterruptionDetectorOptions = Omit<Partial<InterruptionOptions>, 'useProxy'>;\n\nexport class AdaptiveInterruptionDetector extends (EventEmitter as new () => TypedEventEmitter<InterruptionCallbacks>) {\n  options: InterruptionOptions;\n  private readonly _label: string;\n  private logger = log();\n  // Use Set instead of WeakSet to allow iteration for propagating option updates\n  private streams: Set<InterruptionStreamBase> = new Set();\n\n  constructor(options: AdaptiveInterruptionDetectorOptions = {}) {\n    super();\n\n    const {\n      maxAudioDurationInS,\n      baseUrl,\n      apiKey,\n      apiSecret,\n      audioPrefixDurationInS,\n      threshold,\n      detectionIntervalInS,\n      inferenceTimeout,\n      minInterruptionDurationInS,\n    } = { ...interruptionOptionDefaults, ...options };\n\n    if (maxAudioDurationInS > 3.0) {\n      throw new RangeError('maxAudioDurationInS must be less than or equal to 3.0 seconds');\n    }\n\n    const lkBaseUrl = baseUrl ?? process.env.LIVEKIT_REMOTE_EOT_URL ?? getDefaultInferenceUrl();\n    let lkApiKey = apiKey ?? '';\n    let lkApiSecret = apiSecret ?? '';\n    let useProxy: boolean;\n\n    // Use LiveKit credentials if using the inference service (production or staging)\n    const isInferenceUrl =\n      lkBaseUrl === DEFAULT_INFERENCE_URL || lkBaseUrl === STAGING_INFERENCE_URL;\n    if (isInferenceUrl) {\n      lkApiKey =\n        apiKey ?? process.env.LIVEKIT_INFERENCE_API_KEY ?? process.env.LIVEKIT_API_KEY ?? '';\n      if (!lkApiKey) {\n        throw new TypeError(\n          'apiKey is required, either as argument or set LIVEKIT_API_KEY environmental variable',\n        );\n      }\n\n      lkApiSecret =\n        apiSecret ??\n        process.env.LIVEKIT_INFERENCE_API_SECRET ??\n        process.env.LIVEKIT_API_SECRET ??\n        '';\n      if (!lkApiSecret) {\n        throw new TypeError(\n          'apiSecret is required, either as argument or set LIVEKIT_API_SECRET environmental variable',\n        );\n      }\n      useProxy = true;\n    } else {\n      useProxy = false;\n    }\n    const transport = useProxy ? 'websocket' : 'http';\n    this.logger.debug(\n      {\n        baseUrl: lkBaseUrl,\n        useProxy,\n        transport,\n      },\n      '=== Resolved interruption detector transport configuration',\n    );\n\n    this.options = {\n      sampleRate: SAMPLE_RATE,\n      threshold,\n      minFrames: Math.ceil(minInterruptionDurationInS * FRAMES_PER_SECOND),\n      maxAudioDurationInS,\n      audioPrefixDurationInS,\n      detectionIntervalInS,\n      inferenceTimeout,\n      baseUrl: lkBaseUrl,\n      apiKey: lkApiKey,\n      apiSecret: lkApiSecret,\n      useProxy,\n      minInterruptionDurationInS,\n    };\n\n    this._label = `${this.constructor.name}`;\n\n    this.logger.debug(\n      {\n        baseUrl: this.options.baseUrl,\n        detectionIntervalInS: this.options.detectionIntervalInS,\n        audioPrefixDurationInS: this.options.audioPrefixDurationInS,\n        maxAudioDurationInS: this.options.maxAudioDurationInS,\n        minFrames: this.options.minFrames,\n        threshold: this.options.threshold,\n        inferenceTimeout: this.options.inferenceTimeout,\n        useProxy: this.options.useProxy,\n        transport,\n      },\n      '=== Adaptive interruption detector initialized',\n    );\n  }\n\n  /**\n   * The model identifier for this detector.\n   */\n  get model(): string {\n    return 'adaptive interruption';\n  }\n\n  /**\n   * The provider identifier for this detector.\n   */\n  get provider(): string {\n    return 'livekit';\n  }\n\n  /**\n   * The label for this detector instance.\n   */\n  get label(): string {\n    return this._label;\n  }\n\n  /**\n   * The sample rate used for audio processing.\n   */\n  get sampleRate(): number {\n    return this.options.sampleRate;\n  }\n\n  /**\n   * Emit an error event from the detector.\n   */\n  emitError(error: InterruptionDetectionError): void {\n    this.emit('error', error);\n  }\n\n  /**\n   * Creates a new InterruptionStreamBase for internal use.\n   * The stream can receive audio frames and sentinels via pushFrame().\n   * Use this when you need direct access to the stream for pushing frames.\n   */\n  createStream(): InterruptionStreamBase {\n    try {\n      const streamBase = new InterruptionStreamBase(this, {});\n      this.streams.add(streamBase);\n      return streamBase;\n    } catch (e) {\n      const cause = e instanceof Error ? e : new Error(String(e));\n      this.emitError(new InterruptionDetectionError(cause.message, Date.now(), this._label, false));\n      throw e;\n    }\n  }\n\n  /**\n   * Remove a stream from tracking (called when stream is closed).\n   */\n  removeStream(stream: InterruptionStreamBase): void {\n    this.streams.delete(stream);\n  }\n\n  /**\n   * Update options for the detector and propagate to all active streams.\n   * For WebSocket streams, this triggers a reconnection with new settings.\n   */\n  async updateOptions(options: {\n    threshold?: number;\n    minInterruptionDurationInS?: number;\n  }): Promise<void> {\n    if (options.threshold !== undefined) {\n      this.options.threshold = options.threshold;\n    }\n    if (options.minInterruptionDurationInS !== undefined) {\n      this.options.minInterruptionDurationInS = options.minInterruptionDurationInS;\n      this.options.minFrames = Math.ceil(options.minInterruptionDurationInS * FRAMES_PER_SECOND);\n    }\n\n    // Propagate option updates to all active streams (matching Python behavior)\n    const updatePromises: Promise<void>[] = [];\n    for (const stream of this.streams) {\n      updatePromises.push(stream.updateOptions(options));\n    }\n    await Promise.all(updatePromises);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/inference/interruption/interruption_stream.cjs

@@ -0,0 +1,368 @@
+"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_stream_exports = {};
+__export(interruption_stream_exports, {
+  InterruptionStreamBase: () => InterruptionStreamBase,
+  InterruptionStreamSentinel: () => InterruptionStreamSentinel
+});
+module.exports = __toCommonJS(interruption_stream_exports);
+var import_rtc_node = require("@livekit/rtc-node");
+var import_web = require("stream/web");
+var import_log = require("../../log.cjs");
+var import_stream_channel = require("../../stream/stream_channel.cjs");
+var import_telemetry = require("../../telemetry/index.cjs");
+var import_defaults = require("./defaults.cjs");
+var import_http_transport = require("./http_transport.cjs");
+var import_interruption_cache_entry = require("./interruption_cache_entry.cjs");
+var import_types = require("./types.cjs");
+var import_utils = require("./utils.cjs");
+var import_ws_transport = require("./ws_transport.cjs");
+class InterruptionStreamSentinel {
+  static agentSpeechStarted() {
+    return { type: "agent-speech-started" };
+  }
+  static agentSpeechEnded() {
+    return { type: "agent-speech-ended" };
+  }
+  static overlapSpeechStarted(speechDuration, startedAt, userSpeakingSpan) {
+    return { type: "overlap-speech-started", speechDuration, startedAt, userSpeakingSpan };
+  }
+  static overlapSpeechEnded(endedAt) {
+    return { type: "overlap-speech-ended", endedAt };
+  }
+  static flush() {
+    return { type: "flush" };
+  }
+}
+function updateUserSpeakingSpan(span, entry) {
+  span.setAttribute(
+    import_telemetry.traceTypes.ATTR_IS_INTERRUPTION,
+    (entry.isInterruption ?? false).toString().toLowerCase()
+  );
+  span.setAttribute(import_telemetry.traceTypes.ATTR_INTERRUPTION_PROBABILITY, entry.probability);
+  span.setAttribute(import_telemetry.traceTypes.ATTR_INTERRUPTION_TOTAL_DURATION, entry.totalDurationInS);
+  span.setAttribute(import_telemetry.traceTypes.ATTR_INTERRUPTION_PREDICTION_DURATION, entry.predictionDurationInS);
+  span.setAttribute(import_telemetry.traceTypes.ATTR_INTERRUPTION_DETECTION_DELAY, entry.detectionDelayInS);
+}
+class InterruptionStreamBase {
+  inputStream;
+  eventStream;
+  resampler;
+  numRequests = 0;
+  userSpeakingSpan;
+  overlapSpeechStartedAt;
+  options;
+  apiOptions;
+  model;
+  logger = (0, import_log.log)();
+  // Store reconnect function for WebSocket transport
+  wsReconnect;
+  // Mutable transport options that can be updated via updateOptions()
+  transportOptions;
+  constructor(model, apiOptions) {
+    this.inputStream = (0, import_stream_channel.createStreamChannel)();
+    this.model = model;
+    this.options = { ...model.options };
+    this.apiOptions = { ...import_defaults.apiConnectDefaults, ...apiOptions };
+    this.transportOptions = {
+      baseUrl: this.options.baseUrl,
+      apiKey: this.options.apiKey,
+      apiSecret: this.options.apiSecret,
+      sampleRate: this.options.sampleRate,
+      threshold: this.options.threshold,
+      minFrames: this.options.minFrames,
+      timeout: this.options.inferenceTimeout,
+      maxRetries: this.apiOptions.maxRetries
+    };
+    this.eventStream = this.setupTransform();
+  }
+  /**
+   * Update stream options. For WebSocket transport, this triggers a reconnection.
+   */
+  async updateOptions(options) {
+    if (options.threshold !== void 0) {
+      this.options.threshold = options.threshold;
+      this.transportOptions.threshold = options.threshold;
+    }
+    if (options.minInterruptionDurationInS !== void 0) {
+      this.options.minInterruptionDurationInS = options.minInterruptionDurationInS;
+      this.options.minFrames = Math.ceil(options.minInterruptionDurationInS * import_defaults.FRAMES_PER_SECOND);
+      this.transportOptions.minFrames = this.options.minFrames;
+    }
+    if (this.options.useProxy && this.wsReconnect) {
+      await this.wsReconnect();
+    }
+  }
+  setupTransform() {
+    let agentSpeechStarted = false;
+    let startIdx = 0;
+    let accumulatedSamples = 0;
+    let overlapSpeechStarted = false;
+    let overlapCount = 0;
+    const cache = new import_utils.BoundedCache(10);
+    const inferenceS16Data = new Int16Array(
+      Math.ceil(this.options.maxAudioDurationInS * this.options.sampleRate)
+    ).fill(0);
+    const getState = () => ({
+      overlapSpeechStarted,
+      overlapSpeechStartedAt: this.overlapSpeechStartedAt,
+      cache,
+      overlapCount
+    });
+    const setState = (partial) => {
+      if (partial.overlapSpeechStarted !== void 0) {
+        overlapSpeechStarted = partial.overlapSpeechStarted;
+      }
+    };
+    const handleSpanUpdate = (entry) => {
+      if (this.userSpeakingSpan) {
+        updateUserSpeakingSpan(this.userSpeakingSpan, entry);
+        this.userSpeakingSpan = void 0;
+      }
+    };
+    const onRequestSent = () => {
+      this.numRequests++;
+    };
+    const getAndResetNumRequests = () => {
+      const n = this.numRequests;
+      this.numRequests = 0;
+      return n;
+    };
+    const audioTransformer = new import_web.TransformStream(
+      {
+        transform: (chunk, controller) => {
+          if (chunk instanceof import_rtc_node.AudioFrame) {
+            if (!agentSpeechStarted) {
+              return;
+            }
+            if (this.options.sampleRate !== chunk.sampleRate) {
+              controller.error("the sample rate of the input frames must be consistent");
+              this.logger.error("the sample rate of the input frames must be consistent");
+              return;
+            }
+            const result = writeToInferenceS16Data(
+              chunk,
+              startIdx,
+              inferenceS16Data,
+              this.options.maxAudioDurationInS
+            );
+            startIdx = result.startIdx;
+            accumulatedSamples += result.samplesWritten;
+            if (accumulatedSamples >= Math.floor(this.options.detectionIntervalInS * this.options.sampleRate) && overlapSpeechStarted) {
+              const audioSlice = inferenceS16Data.slice(0, startIdx);
+              accumulatedSamples = 0;
+              controller.enqueue(audioSlice);
+            }
+          } else if (chunk.type === "agent-speech-started") {
+            this.logger.debug("agent speech started");
+            agentSpeechStarted = true;
+            overlapSpeechStarted = false;
+            this.overlapSpeechStartedAt = void 0;
+            accumulatedSamples = 0;
+            overlapCount = 0;
+            startIdx = 0;
+            this.numRequests = 0;
+            cache.clear();
+          } else if (chunk.type === "agent-speech-ended") {
+            this.logger.debug("agent speech ended");
+            agentSpeechStarted = false;
+            overlapSpeechStarted = false;
+            this.overlapSpeechStartedAt = void 0;
+            accumulatedSamples = 0;
+            overlapCount = 0;
+            startIdx = 0;
+            this.numRequests = 0;
+            cache.clear();
+          } else if (chunk.type === "overlap-speech-started" && agentSpeechStarted) {
+            this.overlapSpeechStartedAt = chunk.startedAt;
+            this.userSpeakingSpan = chunk.userSpeakingSpan;
+            this.logger.debug("overlap speech started, starting interruption inference");
+            overlapSpeechStarted = true;
+            accumulatedSamples = 0;
+            overlapCount += 1;
+            if (overlapCount <= 1) {
+              const keepSize = Math.round(chunk.speechDuration / 1e3 * this.options.sampleRate) + Math.round(this.options.audioPrefixDurationInS * this.options.sampleRate);
+              const shiftCount = Math.max(0, startIdx - keepSize);
+              inferenceS16Data.copyWithin(0, shiftCount, startIdx);
+              startIdx -= shiftCount;
+            }
+            cache.clear();
+          } else if (chunk.type === "overlap-speech-ended") {
+            this.logger.debug("overlap speech ended");
+            if (overlapSpeechStarted) {
+              this.userSpeakingSpan = void 0;
+              let latestEntry = cache.pop(
+                (entry) => entry.totalDurationInS !== void 0 && entry.totalDurationInS > 0
+              );
+              if (!latestEntry) {
+                this.logger.debug("no request made for overlap speech");
+                latestEntry = import_interruption_cache_entry.InterruptionCacheEntry.default();
+              }
+              const e = latestEntry ?? import_interruption_cache_entry.InterruptionCacheEntry.default();
+              const event = {
+                type: "overlapping_speech",
+                detectedAt: chunk.endedAt,
+                isInterruption: false,
+                overlapStartedAt: this.overlapSpeechStartedAt,
+                speechInput: e.speechInput,
+                probabilities: e.probabilities,
+                totalDurationInS: e.totalDurationInS,
+                detectionDelayInS: e.detectionDelayInS,
+                predictionDurationInS: e.predictionDurationInS,
+                probability: e.probability,
+                numRequests: getAndResetNumRequests()
+              };
+              controller.enqueue(event);
+              overlapSpeechStarted = false;
+              accumulatedSamples = 0;
+            }
+            this.overlapSpeechStartedAt = void 0;
+          } else if (chunk.type === "flush") {
+          }
+        }
+      },
+      { highWaterMark: 32 },
+      { highWaterMark: 32 }
+    );
+    const transportOptions = this.transportOptions;
+    let transport;
+    if (this.options.useProxy) {
+      const wsResult = (0, import_ws_transport.createWsTransport)(
+        transportOptions,
+        getState,
+        setState,
+        handleSpanUpdate,
+        onRequestSent,
+        getAndResetNumRequests
+      );
+      transport = wsResult.transport;
+      this.wsReconnect = wsResult.reconnect;
+    } else {
+      transport = (0, import_http_transport.createHttpTransport)(
+        transportOptions,
+        getState,
+        setState,
+        handleSpanUpdate,
+        getAndResetNumRequests
+      );
+    }
+    const eventEmitter = new import_web.TransformStream({
+      transform: (chunk, controller) => {
+        this.model.emit("overlapping_speech", chunk);
+        const metrics = {
+          type: "interruption_metrics",
+          timestamp: chunk.detectedAt,
+          totalDuration: chunk.totalDurationInS * 1e3,
+          predictionDuration: chunk.predictionDurationInS * 1e3,
+          detectionDelay: chunk.detectionDelayInS * 1e3,
+          numInterruptions: chunk.isInterruption ? 1 : 0,
+          numBackchannels: chunk.isInterruption ? 0 : 1,
+          numRequests: chunk.numRequests,
+          metadata: {
+            modelProvider: this.model.provider,
+            modelName: this.model.model
+          }
+        };
+        this.model.emit("metrics_collected", metrics);
+        controller.enqueue(chunk);
+      }
+    });
+    return this.inputStream.stream().pipeThrough(audioTransformer).pipeThrough(transport).pipeThrough(eventEmitter);
+  }
+  ensureInputNotEnded() {
+    if (this.inputStream.closed) {
+      throw new Error("input stream is closed");
+    }
+  }
+  ensureStreamsNotEnded() {
+    this.ensureInputNotEnded();
+  }
+  getResamplerFor(inputSampleRate) {
+    if (!this.resampler) {
+      this.resampler = new import_rtc_node.AudioResampler(inputSampleRate, this.options.sampleRate);
+    }
+    return this.resampler;
+  }
+  stream() {
+    return this.eventStream;
+  }
+  async pushFrame(frame) {
+    this.ensureStreamsNotEnded();
+    if (!(frame instanceof import_rtc_node.AudioFrame)) {
+      return this.inputStream.write(frame);
+    } else if (this.options.sampleRate !== frame.sampleRate) {
+      const resampler = this.getResamplerFor(frame.sampleRate);
+      if (resampler.inputRate !== frame.sampleRate) {
+        throw new Error("the sample rate of the input frames must be consistent");
+      }
+      for (const resampledFrame of resampler.push(frame)) {
+        await this.inputStream.write(resampledFrame);
+      }
+    } else {
+      await this.inputStream.write(frame);
+    }
+  }
+  async flush() {
+    this.ensureStreamsNotEnded();
+    await this.inputStream.write(InterruptionStreamSentinel.flush());
+  }
+  async endInput() {
+    await this.flush();
+    await this.inputStream.close();
+  }
+  async close() {
+    if (!this.inputStream.closed) await this.inputStream.close();
+    this.model.removeStream(this);
+  }
+}
+function writeToInferenceS16Data(frame, startIdx, outData, maxAudioDuration) {
+  const maxWindowSize = Math.floor(maxAudioDuration * frame.sampleRate);
+  if (frame.samplesPerChannel > outData.length) {
+    throw new Error("frame samples are greater than the max window size");
+  }
+  const shift = startIdx + frame.samplesPerChannel - maxWindowSize;
+  if (shift > 0) {
+    outData.copyWithin(0, shift, startIdx);
+    startIdx -= shift;
+  }
+  const frameData = new Int16Array(
+    frame.data.buffer,
+    frame.data.byteOffset,
+    frame.samplesPerChannel * frame.channels
+  );
+  if (frame.channels > 1) {
+    for (let i = 0; i < frame.samplesPerChannel; i++) {
+      let sum = 0;
+      for (let ch = 0; ch < frame.channels; ch++) {
+        sum += frameData[i * frame.channels + ch] ?? 0;
+      }
+      outData[startIdx + i] = Math.floor(sum / frame.channels);
+    }
+  } else {
+    outData.set(frameData, startIdx);
+  }
+  startIdx += frame.samplesPerChannel;
+  return { startIdx, samplesWritten: frame.samplesPerChannel };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InterruptionStreamBase,
+  InterruptionStreamSentinel
+});
+//# sourceMappingURL=interruption_stream.cjs.map