@livekit/agents 0.0.0-20260120144724

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

@@ -0,0 +1,50 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { TypedEventEmitter } from '@livekit/typed-emitter';
+import { type ReadableStream } from 'stream/web';
+import { InterruptionStreamBase } from './InterruptionStream.js';
+import { type InterruptionDetectionError, type InterruptionEvent } from './interruption.js';
+type InterruptionCallbacks = {
+    interruptionDetected: () => void;
+    overlapSpeechDetected: () => void;
+    error: (error: InterruptionDetectionError) => void;
+};
+export interface InterruptionOptions {
+    sampleRate: number;
+    threshold: number;
+    minFrames: number;
+    maxAudioDuration: number;
+    audioPrefixDuration: number;
+    detectionInterval: number;
+    inferenceTimeout: number;
+    minInterruptionDuration: number;
+    baseUrl: string;
+    apiKey: string;
+    apiSecret: string;
+    useProxy: boolean;
+}
+export type AdaptiveInterruptionDetectorOptions = Partial<InterruptionOptions>;
+declare const AdaptiveInterruptionDetector_base: new () => TypedEventEmitter<InterruptionCallbacks>;
+export declare class AdaptiveInterruptionDetector extends AdaptiveInterruptionDetector_base {
+    options: InterruptionOptions;
+    private label;
+    private streams;
+    constructor(options?: AdaptiveInterruptionDetectorOptions);
+    /**
+     * 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;
+    /**
+     * Creates a new interruption stream and returns a ReadableStream of InterruptionEvents.
+     * This is a convenience method for consuming interruption events without needing
+     * to manage the underlying stream directly.
+     */
+    stream(): ReadableStream<InterruptionEvent>;
+    updateOptions(options: {
+        threshold?: number;
+        minInterruptionDuration?: number;
+    }): void;
+}
+export {};
+//# sourceMappingURL=AdaptiveInterruptionDetector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AdaptiveInterruptionDetector.d.ts","sourceRoot":"","sources":["../../../src/inference/interruption/AdaptiveInterruptionDetector.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,OAAO,EAAE,KAAK,cAAc,EAAmB,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAOjE,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,iBAAiB,EAEvB,MAAM,mBAAmB,CAAC;AAE3B,KAAK,qBAAqB,GAAG;IAC3B,oBAAoB,EAAE,MAAM,IAAI,CAAC;IACjC,qBAAqB,EAAE,MAAM,IAAI,CAAC;IAClC,KAAK,EAAE,CAAC,KAAK,EAAE,0BAA0B,KAAK,IAAI,CAAC;CACpD,CAAC;AAEF,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,uBAAuB,EAAE,MAAM,CAAC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,MAAM,mCAAmC,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;2DAEF,kBAAkB,qBAAqB,CAAC;AAArH,qBAAa,4BAA6B,SAAQ,iCAAoE;IACpH,OAAO,EAAE,mBAAmB,CAAC;IAC7B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,OAAO,CAAkB;gBAErB,OAAO,GAAE,mCAAwC;IAiF7D;;;;OAIG;IACH,YAAY,IAAI,sBAAsB;IAMtC;;;;OAIG;IACH,MAAM,IAAI,cAAc,CAAC,iBAAiB,CAAC;IAgB3C,aAAa,CAAC,OAAO,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,uBAAuB,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;CAQvF"}

package/dist/inference/interruption/AdaptiveInterruptionDetector.js

@@ -0,0 +1,125 @@
+import EventEmitter from "events";
+import { TransformStream } from "stream/web";
+import { InterruptionStreamBase } from "./InterruptionStream.js";
+import {
+  DEFAULT_BASE_URL,
+  FRAMES_PER_SECOND,
+  SAMPLE_RATE,
+  interruptionOptionDefaults
+} from "./defaults.js";
+import {
+  InterruptionEventType
+} from "./interruption.js";
+class AdaptiveInterruptionDetector extends EventEmitter {
+  options;
+  label;
+  streams;
+  // TODO: Union of InterruptionHttpStream | InterruptionWebSocketStream
+  constructor(options = {}) {
+    super();
+    const {
+      maxAudioDuration,
+      baseUrl,
+      apiKey,
+      apiSecret,
+      useProxy: useProxyArg,
+      audioPrefixDuration,
+      threshold,
+      detectionInterval,
+      inferenceTimeout,
+      minInterruptionDuration
+    } = { ...interruptionOptionDefaults, ...options };
+    if (maxAudioDuration > 3) {
+      throw new Error("maxAudioDuration must be less than or equal to 3.0 seconds");
+    }
+    const lkBaseUrl = baseUrl ?? process.env.LIVEKIT_REMOTE_EOT_URL ?? DEFAULT_BASE_URL;
+    let lkApiKey = apiKey ?? "";
+    let lkApiSecret = apiSecret ?? "";
+    let useProxy;
+    if (lkBaseUrl === DEFAULT_BASE_URL) {
+      lkApiKey = apiKey ?? process.env.LIVEKIT_INFERENCE_API_KEY ?? process.env.LIVEKIT_API_KEY ?? "";
+      if (!lkApiKey) {
+        throw new Error(
+          "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 Error(
+          "apiSecret is required, either as argument or set LIVEKIT_API_SECRET environmental variable"
+        );
+      }
+      useProxy = true;
+    } else {
+      useProxy = useProxyArg ?? false;
+    }
+    this.options = {
+      sampleRate: SAMPLE_RATE,
+      threshold,
+      minFrames: Math.ceil(minInterruptionDuration * FRAMES_PER_SECOND),
+      maxAudioDuration,
+      audioPrefixDuration,
+      detectionInterval,
+      inferenceTimeout,
+      baseUrl: lkBaseUrl,
+      apiKey: lkApiKey,
+      apiSecret: lkApiSecret,
+      useProxy,
+      minInterruptionDuration
+    };
+    this.label = `${this.constructor.name}`;
+    this.streams = /* @__PURE__ */ new WeakSet();
+    console.info("adaptive interruption detector initialized", {
+      baseUrl: this.options.baseUrl,
+      detectionInterval: this.options.detectionInterval,
+      audioPrefixDuration: this.options.audioPrefixDuration,
+      maxAudioDuration: this.options.maxAudioDuration,
+      minFrames: this.options.minFrames,
+      threshold: this.options.threshold,
+      inferenceTimeout: this.options.inferenceTimeout,
+      useProxy: this.options.useProxy
+    });
+  }
+  /**
+   * 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() {
+    const stream = new InterruptionStreamBase(this, {});
+    this.streams.add(stream);
+    return stream;
+  }
+  /**
+   * Creates a new interruption stream and returns a ReadableStream of InterruptionEvents.
+   * This is a convenience method for consuming interruption events without needing
+   * to manage the underlying stream directly.
+   */
+  stream() {
+    const httpStream = this.createStream();
+    const transformer = new TransformStream({
+      transform: (chunk, controller) => {
+        if (chunk.type === InterruptionEventType.INTERRUPTION) {
+          this.emit("interruptionDetected");
+        } else if (chunk.type === InterruptionEventType.OVERLAP_SPEECH_ENDED) {
+          this.emit("overlapSpeechDetected");
+        }
+        controller.enqueue(chunk);
+      }
+    });
+    const stream = httpStream.stream.pipeThrough(transformer);
+    return stream;
+  }
+  updateOptions(options) {
+    if (options.threshold !== void 0) {
+      this.options.threshold = options.threshold;
+    }
+    if (options.minInterruptionDuration !== void 0) {
+      this.options.minFrames = Math.ceil(options.minInterruptionDuration * FRAMES_PER_SECOND);
+    }
+  }
+}
+export {
+  AdaptiveInterruptionDetector
+};
+//# sourceMappingURL=AdaptiveInterruptionDetector.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/AdaptiveInterruptionDetector.ts"],"sourcesContent":["import type { TypedEventEmitter } from '@livekit/typed-emitter';\nimport EventEmitter from 'events';\nimport { type ReadableStream, TransformStream } from 'stream/web';\nimport { InterruptionStreamBase } from './InterruptionStream.js';\nimport {\n  DEFAULT_BASE_URL,\n  FRAMES_PER_SECOND,\n  SAMPLE_RATE,\n  interruptionOptionDefaults,\n} from './defaults.js';\nimport {\n  type InterruptionDetectionError,\n  type InterruptionEvent,\n  InterruptionEventType,\n} from './interruption.js';\n\ntype InterruptionCallbacks = {\n  interruptionDetected: () => void;\n  overlapSpeechDetected: () => void;\n  error: (error: InterruptionDetectionError) => void;\n};\n\nexport interface InterruptionOptions {\n  sampleRate: number;\n  threshold: number;\n  minFrames: number;\n  maxAudioDuration: number;\n  audioPrefixDuration: number;\n  detectionInterval: number;\n  inferenceTimeout: number;\n  minInterruptionDuration: number;\n  baseUrl: string;\n  apiKey: string;\n  apiSecret: string;\n  useProxy: boolean;\n}\n\nexport type AdaptiveInterruptionDetectorOptions = Partial<InterruptionOptions>;\n\nexport class AdaptiveInterruptionDetector extends (EventEmitter as new () => TypedEventEmitter<InterruptionCallbacks>) {\n  options: InterruptionOptions;\n  private label: string;\n  private streams: WeakSet<object>; // TODO: Union of InterruptionHttpStream | InterruptionWebSocketStream\n\n  constructor(options: AdaptiveInterruptionDetectorOptions = {}) {\n    super();\n\n    const {\n      maxAudioDuration,\n      baseUrl,\n      apiKey,\n      apiSecret,\n      useProxy: useProxyArg,\n      audioPrefixDuration,\n      threshold,\n      detectionInterval,\n      inferenceTimeout,\n      minInterruptionDuration,\n    } = { ...interruptionOptionDefaults, ...options };\n\n    if (maxAudioDuration > 3.0) {\n      throw new Error('maxAudioDuration must be less than or equal to 3.0 seconds');\n    }\n\n    const lkBaseUrl = baseUrl ?? process.env.LIVEKIT_REMOTE_EOT_URL ?? DEFAULT_BASE_URL;\n    let lkApiKey = apiKey ?? '';\n    let lkApiSecret = apiSecret ?? '';\n    let useProxy: boolean;\n\n    // use LiveKit credentials if using the default base URL (inference)\n    if (lkBaseUrl === DEFAULT_BASE_URL) {\n      lkApiKey =\n        apiKey ?? process.env.LIVEKIT_INFERENCE_API_KEY ?? process.env.LIVEKIT_API_KEY ?? '';\n      if (!lkApiKey) {\n        throw new Error(\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 Error(\n          'apiSecret is required, either as argument or set LIVEKIT_API_SECRET environmental variable',\n        );\n      }\n\n      useProxy = true;\n    } else {\n      useProxy = useProxyArg ?? false;\n    }\n\n    this.options = {\n      sampleRate: SAMPLE_RATE,\n      threshold,\n      minFrames: Math.ceil(minInterruptionDuration * FRAMES_PER_SECOND),\n      maxAudioDuration,\n      audioPrefixDuration,\n      detectionInterval,\n      inferenceTimeout,\n      baseUrl: lkBaseUrl,\n      apiKey: lkApiKey,\n      apiSecret: lkApiSecret,\n      useProxy,\n      minInterruptionDuration,\n    };\n\n    this.label = `${this.constructor.name}`;\n    this.streams = new WeakSet();\n\n    console.info('adaptive interruption detector initialized', {\n      baseUrl: this.options.baseUrl,\n      detectionInterval: this.options.detectionInterval,\n      audioPrefixDuration: this.options.audioPrefixDuration,\n      maxAudioDuration: this.options.maxAudioDuration,\n      minFrames: this.options.minFrames,\n      threshold: this.options.threshold,\n      inferenceTimeout: this.options.inferenceTimeout,\n      useProxy: this.options.useProxy,\n    });\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    const stream = new InterruptionStreamBase(this, {});\n    this.streams.add(stream);\n    return stream;\n  }\n\n  /**\n   * Creates a new interruption stream and returns a ReadableStream of InterruptionEvents.\n   * This is a convenience method for consuming interruption events without needing\n   * to manage the underlying stream directly.\n   */\n  stream(): ReadableStream<InterruptionEvent> {\n    const httpStream = this.createStream();\n    const transformer = new TransformStream<InterruptionEvent, InterruptionEvent>({\n      transform: (chunk, controller) => {\n        if (chunk.type === InterruptionEventType.INTERRUPTION) {\n          this.emit('interruptionDetected'); // TODO payload\n        } else if (chunk.type === InterruptionEventType.OVERLAP_SPEECH_ENDED) {\n          this.emit('overlapSpeechDetected'); // TODO payload\n        }\n        controller.enqueue(chunk);\n      },\n    });\n    const stream = httpStream.stream.pipeThrough(transformer);\n    return stream;\n  }\n\n  updateOptions(options: { threshold?: number; minInterruptionDuration?: number }): void {\n    if (options.threshold !== undefined) {\n      this.options.threshold = options.threshold;\n    }\n    if (options.minInterruptionDuration !== undefined) {\n      this.options.minFrames = Math.ceil(options.minInterruptionDuration * FRAMES_PER_SECOND);\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/inference/interruption/InterruptionStream.cjs

@@ -0,0 +1,310 @@
+"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 InterruptionStream_exports = {};
+__export(InterruptionStream_exports, {
+  InterruptionStreamBase: () => InterruptionStreamBase,
+  InterruptionStreamSentinel: () => InterruptionStreamSentinel
+});
+module.exports = __toCommonJS(InterruptionStream_exports);
+var import_rtc_node = require("@livekit/rtc-node");
+var import_telemetry = require("../../telemetry/index.cjs");
+var import_web = require("stream/web");
+var import_log = require("../../log.cjs");
+var import_stream_channel = require("../../stream/stream_channel.cjs");
+var import_utils = require("../utils.cjs");
+var import_defaults = require("./defaults.cjs");
+var import_http_transport = require("./http_transport.cjs");
+var import_interruption = require("./interruption.cjs");
+class InterruptionStreamSentinel {
+  static speechStarted() {
+    return { type: "agent-speech-started" };
+  }
+  static speechEnded() {
+    return { type: "agent-speech-ended" };
+  }
+  static overlapSpeechStarted(speechDuration, userSpeakingSpan) {
+    return { type: "overlap-speech-started", speechDuration, userSpeakingSpan };
+  }
+  static overlapSpeechEnded() {
+    return { type: "overlap-speech-ended" };
+  }
+  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.totalDuration);
+  span.setAttribute(import_telemetry.traceTypes.ATTR_INTERRUPTION_PREDICTION_DURATION, entry.predictionDuration);
+  span.setAttribute(import_telemetry.traceTypes.ATTR_INTERRUPTION_DETECTION_DELAY, entry.detectionDelay);
+}
+class InterruptionStreamBase {
+  inputStream;
+  eventStream;
+  resampler;
+  userSpeakingSpan;
+  overlapSpeechStartedAt;
+  options;
+  apiOptions;
+  model;
+  constructor(model, apiOptions) {
+    this.inputStream = (0, import_stream_channel.createStreamChannel)();
+    this.eventStream = (0, import_stream_channel.createStreamChannel)();
+    this.model = model;
+    this.options = model.options;
+    this.apiOptions = { ...import_defaults.apiConnectDefaults, ...apiOptions };
+    this.setupTransform();
+  }
+  setupTransform() {
+    let agentSpeechStarted = false;
+    let startIdx = 0;
+    let accumulatedSamples = 0;
+    let overlapSpeechStarted = false;
+    const cache = /* @__PURE__ */ new Map();
+    const inferenceS16Data = new Int16Array(
+      Math.ceil(this.options.maxAudioDuration * this.options.sampleRate)
+    ).fill(0);
+    const transformer = 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");
+              return;
+            }
+            const result = writeToInferenceS16Data(
+              chunk,
+              startIdx,
+              inferenceS16Data,
+              this.options.maxAudioDuration
+            );
+            startIdx = result.startIdx;
+            accumulatedSamples += result.samplesWritten;
+            if (accumulatedSamples >= Math.floor(this.options.detectionInterval * this.options.sampleRate) && overlapSpeechStarted) {
+              const audioSlice = inferenceS16Data.slice(0, startIdx);
+              accumulatedSamples = 0;
+              controller.enqueue(audioSlice);
+            }
+          } else if (chunk.type === "agent-speech-started") {
+            (0, import_log.log)().debug("agent speech started");
+            agentSpeechStarted = true;
+            overlapSpeechStarted = false;
+            accumulatedSamples = 0;
+            startIdx = 0;
+            cache.clear();
+          } else if (chunk.type === "agent-speech-ended") {
+            (0, import_log.log)().debug("agent speech ended");
+            agentSpeechStarted = false;
+            overlapSpeechStarted = false;
+            accumulatedSamples = 0;
+            startIdx = 0;
+            cache.clear();
+          } else if (chunk.type === "overlap-speech-started" && agentSpeechStarted) {
+            this.userSpeakingSpan = chunk.userSpeakingSpan;
+            (0, import_log.log)().debug("overlap speech started, starting interruption inference");
+            overlapSpeechStarted = true;
+            accumulatedSamples = 0;
+            const shiftSize = Math.min(
+              startIdx,
+              Math.round(chunk.speechDuration * this.options.sampleRate) + Math.round(this.options.audioPrefixDuration * this.options.sampleRate)
+            );
+            inferenceS16Data.copyWithin(0, startIdx - shiftSize, startIdx);
+            startIdx = shiftSize;
+            cache.clear();
+          } else if (chunk.type === "overlap-speech-ended") {
+            (0, import_log.log)().debug("overlap speech ended");
+            if (overlapSpeechStarted) {
+              this.userSpeakingSpan = void 0;
+              let latestEntry = Array.from(cache.values()).at(-1);
+              if (!latestEntry) {
+                (0, import_log.log)().debug("no request made for overlap speech");
+                latestEntry = import_interruption.InterruptionCacheEntry.default();
+              } else {
+                cache.delete(latestEntry.createdAt);
+              }
+              const event = {
+                type: import_interruption.InterruptionEventType.OVERLAP_SPEECH_ENDED,
+                timestamp: Date.now(),
+                isInterruption: false,
+                overlapSpeechStartedAt: this.overlapSpeechStartedAt,
+                speechInput: latestEntry.speechInput,
+                probabilities: latestEntry.probabilities,
+                totalDuration: latestEntry.totalDuration,
+                detectionDelay: latestEntry.detectionDelay,
+                predictionDuration: latestEntry.predictionDuration,
+                probability: latestEntry.probability
+              };
+              this.eventStream.write(event);
+            }
+          } else if (chunk.type === "flush") {
+            (0, import_log.log)().debug("flushing");
+          }
+        }
+      },
+      { highWaterMark: Number.MAX_SAFE_INTEGER },
+      { highWaterMark: Number.MAX_SAFE_INTEGER }
+    );
+    const httpPostWriter = new import_web.WritableStream(
+      {
+        // Implement the sink
+        write: async (chunk) => {
+          if (!this.overlapSpeechStartedAt) {
+            return;
+          }
+          const resp = await (0, import_http_transport.predictHTTP)(
+            chunk,
+            { threshold: this.options.threshold, minFrames: this.options.minFrames },
+            {
+              baseUrl: this.options.baseUrl,
+              timeout: this.options.inferenceTimeout,
+              token: await (0, import_utils.createAccessToken)(this.options.apiKey, this.options.apiSecret)
+            }
+          );
+          console.log("received inference response", resp);
+          const { createdAt, isBargein, probabilities, predictionDuration } = resp;
+          const entry = new import_interruption.InterruptionCacheEntry({
+            createdAt,
+            probabilities,
+            isInterruption: isBargein,
+            speechInput: chunk,
+            totalDuration: (performance.now() - createdAt) / 1e9,
+            detectionDelay: Date.now() - this.overlapSpeechStartedAt,
+            predictionDuration
+          });
+          cache.set(createdAt, entry);
+          if (overlapSpeechStarted && entry.isInterruption) {
+            if (this.userSpeakingSpan) {
+              updateUserSpeakingSpan(this.userSpeakingSpan, entry);
+            }
+            const event = {
+              type: import_interruption.InterruptionEventType.INTERRUPTION,
+              timestamp: Date.now(),
+              overlapSpeechStartedAt: this.overlapSpeechStartedAt,
+              isInterruption: entry.isInterruption,
+              speechInput: entry.speechInput,
+              probabilities: entry.probabilities,
+              totalDuration: entry.totalDuration,
+              predictionDuration: entry.predictionDuration,
+              detectionDelay: entry.detectionDelay,
+              probability: entry.probability
+            };
+            this.eventStream.write(event);
+          }
+        },
+        close() {
+          console.log("closing http writer");
+        },
+        abort(err) {
+          console.log("Sink error:", err);
+        }
+      },
+      { highWaterMark: Number.MAX_SAFE_INTEGER }
+    );
+    this.inputStream.stream().pipeThrough(transformer).pipeTo(httpPostWriter);
+  }
+  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;
+  }
+  get stream() {
+    return this.eventStream.stream();
+  }
+  async pushFrame(frame) {
+    this.ensureStreamsNotEnded();
+    if (!(frame instanceof import_rtc_node.AudioFrame)) {
+      if (frame.type === "overlap-speech-started") {
+        this.overlapSpeechStartedAt = Date.now() - frame.speechDuration;
+      }
+      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();
+    this.inputStream.write(InterruptionStreamSentinel.flush());
+  }
+  async endInput() {
+    await this.flush();
+    await this.inputStream.close();
+  }
+  async close() {
+    if (!this.inputStream.closed) await this.inputStream.close();
+  }
+}
+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=InterruptionStream.cjs.map

package/dist/inference/interruption/InterruptionStream.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/InterruptionStream.ts"],"sourcesContent":["import { AudioFrame, AudioResampler } from '@livekit/rtc-node';\nimport type { Span } from '@opentelemetry/api';\nimport { traceTypes } from '../../telemetry/index.js';\nimport { type ReadableStream, TransformStream, WritableStream } from 'stream/web';\nimport { log } from '../../log.js';\nimport { type StreamChannel, createStreamChannel } from '../../stream/stream_channel.js';\nimport { createAccessToken } from '../utils.js';\nimport type {\n  AdaptiveInterruptionDetector,\n  InterruptionOptions,\n} from './AdaptiveInterruptionDetector.js';\nimport { apiConnectDefaults } from './defaults.js';\nimport { predictHTTP } from './http_transport.js';\nimport {\n  InterruptionCacheEntry,\n  type InterruptionDetectionError,\n  type InterruptionEvent,\n  InterruptionEventType,\n} from './interruption.js';\n\nexport interface AgentSpeechStarted {\n  type: 'agent-speech-started';\n}\n\nexport interface AgentSpeechEnded {\n  type: 'agent-speech-ended';\n}\n\nexport interface OverlapSpeechStarted {\n  type: 'overlap-speech-started';\n  speechDuration: number;\n  userSpeakingSpan: Span;\n}\n\nexport interface OverlapSpeechEnded {\n  type: 'overlap-speech-ended';\n}\n\nexport interface Flush {\n  type: 'flush';\n}\n\nexport type InterruptionSentinel =\n  | AgentSpeechStarted\n  | AgentSpeechEnded\n  | OverlapSpeechStarted\n  | OverlapSpeechEnded\n  | Flush;\n\nexport class InterruptionStreamSentinel {\n  static speechStarted(): AgentSpeechStarted {\n    return { type: 'agent-speech-started' };\n  }\n\n  static speechEnded(): AgentSpeechEnded {\n    return { type: 'agent-speech-ended' };\n  }\n\n  static overlapSpeechStarted(\n    speechDuration: number,\n    userSpeakingSpan: Span,\n  ): OverlapSpeechStarted {\n    return { type: 'overlap-speech-started', speechDuration, userSpeakingSpan };\n  }\n\n  static overlapSpeechEnded(): OverlapSpeechEnded {\n    return { type: 'overlap-speech-ended' };\n  }\n\n  static flush(): Flush {\n    return { type: 'flush' };\n  }\n}\n\nexport interface ApiConnectOptions {\n  maxRetries: number;\n  retryInterval: number;\n  timeout: number;\n}\n\nfunction updateUserSpeakingSpan(span: Span, entry: InterruptionCacheEntry) {\n  span.setAttribute(\n    traceTypes.ATTR_IS_INTERRUPTION,\n    (entry.isInterruption ?? false).toString().toLowerCase(),\n  );\n  span.setAttribute(traceTypes.ATTR_INTERRUPTION_PROBABILITY, entry.probability);\n  span.setAttribute(traceTypes.ATTR_INTERRUPTION_TOTAL_DURATION, entry.totalDuration);\n  span.setAttribute(traceTypes.ATTR_INTERRUPTION_PREDICTION_DURATION, entry.predictionDuration);\n  span.setAttribute(traceTypes.ATTR_INTERRUPTION_DETECTION_DELAY, entry.detectionDelay);\n}\n\nexport class InterruptionStreamBase {\n  private inputStream: StreamChannel<InterruptionSentinel | AudioFrame, InterruptionDetectionError>;\n\n  private eventStream: StreamChannel<InterruptionEvent, InterruptionDetectionError>;\n\n  private resampler?: AudioResampler;\n\n  private userSpeakingSpan: Span | undefined;\n\n  private overlapSpeechStartedAt: number | undefined;\n\n  private options: InterruptionOptions;\n\n  private apiOptions: ApiConnectOptions;\n\n  private model: AdaptiveInterruptionDetector;\n\n  constructor(model: AdaptiveInterruptionDetector, apiOptions: Partial<ApiConnectOptions>) {\n    this.inputStream = createStreamChannel<\n      InterruptionSentinel | AudioFrame,\n      InterruptionDetectionError\n    >();\n\n    this.eventStream = createStreamChannel<InterruptionEvent, InterruptionDetectionError>();\n\n    this.model = model;\n    this.options = model.options;\n    this.apiOptions = { ...apiConnectDefaults, ...apiOptions };\n\n    this.setupTransform();\n  }\n\n  private setupTransform() {\n    let agentSpeechStarted = false;\n    let startIdx = 0;\n    let accumulatedSamples = 0;\n    let overlapSpeechStarted = false;\n    const cache = new Map<number, InterruptionCacheEntry>(); // TODO limit cache size\n    const inferenceS16Data = new Int16Array(\n      Math.ceil(this.options.maxAudioDuration * this.options.sampleRate),\n    ).fill(0);\n\n    const transformer = new TransformStream<InterruptionSentinel | AudioFrame, Int16Array>(\n      {\n        transform: (chunk, controller) => {\n          if (chunk instanceof AudioFrame) {\n            if (!agentSpeechStarted) {\n              return;\n            }\n            if (this.options.sampleRate !== chunk.sampleRate) {\n              controller.error('the sample rate of the input frames must be consistent');\n              return;\n            }\n            const result = writeToInferenceS16Data(\n              chunk,\n              startIdx,\n              inferenceS16Data,\n              this.options.maxAudioDuration,\n            );\n            startIdx = result.startIdx;\n            accumulatedSamples += result.samplesWritten;\n\n            // Send data for inference when enough samples accumulated during overlap\n            if (\n              accumulatedSamples >=\n                Math.floor(this.options.detectionInterval * this.options.sampleRate) &&\n              overlapSpeechStarted\n            ) {\n              // Send a copy of the audio data up to startIdx for inference\n              const audioSlice = inferenceS16Data.slice(0, startIdx);\n              // TODO: send to data channel - dataChan.send(audioSlice);\n              accumulatedSamples = 0;\n              controller.enqueue(audioSlice);\n            }\n          } else if (chunk.type === 'agent-speech-started') {\n            log().debug('agent speech started');\n\n            agentSpeechStarted = true;\n            overlapSpeechStarted = false;\n            accumulatedSamples = 0;\n            startIdx = 0;\n            cache.clear();\n          } else if (chunk.type === 'agent-speech-ended') {\n            log().debug('agent speech ended');\n\n            agentSpeechStarted = false;\n            overlapSpeechStarted = false;\n            accumulatedSamples = 0;\n            startIdx = 0;\n            cache.clear();\n          } else if (chunk.type === 'overlap-speech-started' && agentSpeechStarted) {\n            this.userSpeakingSpan = chunk.userSpeakingSpan;\n            log().debug('overlap speech started, starting interruption inference');\n            overlapSpeechStarted = true;\n            accumulatedSamples = 0;\n            // Include both speech duration and audio prefix duration for context\n            const shiftSize = Math.min(\n              startIdx,\n              Math.round(chunk.speechDuration * this.options.sampleRate) +\n                Math.round(this.options.audioPrefixDuration * this.options.sampleRate),\n            );\n            // Shift the buffer: copy the last `shiftSize` samples before startIdx\n            // to the beginning of the buffer. This preserves recent audio context\n            // (the user's speech that occurred just before overlap was detected).\n            inferenceS16Data.copyWithin(0, startIdx - shiftSize, startIdx);\n            startIdx = shiftSize;\n            cache.clear();\n          } else if (chunk.type === 'overlap-speech-ended') {\n            log().debug('overlap speech ended');\n\n            if (overlapSpeechStarted) {\n              this.userSpeakingSpan = undefined;\n              let latestEntry = Array.from(cache.values()).at(-1);\n              if (!latestEntry) {\n                log().debug('no request made for overlap speech');\n                latestEntry = InterruptionCacheEntry.default();\n              } else {\n                cache.delete(latestEntry.createdAt);\n              }\n              const event: InterruptionEvent = {\n                type: InterruptionEventType.OVERLAP_SPEECH_ENDED,\n                timestamp: Date.now(),\n                isInterruption: false,\n                overlapSpeechStartedAt: this.overlapSpeechStartedAt,\n                speechInput: latestEntry.speechInput,\n                probabilities: latestEntry.probabilities,\n                totalDuration: latestEntry.totalDuration,\n                detectionDelay: latestEntry.detectionDelay,\n                predictionDuration: latestEntry.predictionDuration,\n                probability: latestEntry.probability,\n              };\n              this.eventStream.write(event);\n            }\n          } else if (chunk.type === 'flush') {\n            log().debug('flushing');\n            // do nothing\n          }\n        },\n      },\n      { highWaterMark: Number.MAX_SAFE_INTEGER },\n      { highWaterMark: Number.MAX_SAFE_INTEGER },\n    );\n\n    const httpPostWriter = new WritableStream<Int16Array>(\n      {\n        // Implement the sink\n        write: async (chunk) => {\n          if (!this.overlapSpeechStartedAt) {\n            return;\n          }\n          const resp = await predictHTTP(\n            chunk,\n            { threshold: this.options.threshold, minFrames: this.options.minFrames },\n            {\n              baseUrl: this.options.baseUrl,\n              timeout: this.options.inferenceTimeout,\n              token: await createAccessToken(this.options.apiKey, this.options.apiSecret),\n            },\n          );\n          console.log('received inference response', resp);\n          const { createdAt, isBargein, probabilities, predictionDuration } = resp;\n          const entry = new InterruptionCacheEntry({\n            createdAt,\n            probabilities,\n            isInterruption: isBargein,\n            speechInput: chunk,\n            totalDuration: (performance.now() - createdAt) / 1e9,\n            detectionDelay: Date.now() - this.overlapSpeechStartedAt,\n            predictionDuration,\n          });\n          cache.set(createdAt, entry);\n          if (overlapSpeechStarted && entry.isInterruption) {\n            if (this.userSpeakingSpan) {\n              updateUserSpeakingSpan(this.userSpeakingSpan, entry);\n            }\n            const event: InterruptionEvent = {\n              type: InterruptionEventType.INTERRUPTION,\n              timestamp: Date.now(),\n              overlapSpeechStartedAt: this.overlapSpeechStartedAt,\n              isInterruption: entry.isInterruption,\n              speechInput: entry.speechInput,\n              probabilities: entry.probabilities,\n              totalDuration: entry.totalDuration,\n              predictionDuration: entry.predictionDuration,\n              detectionDelay: entry.detectionDelay,\n              probability: entry.probability,\n            };\n            this.eventStream.write(event);\n          }\n        },\n        close() {\n          console.log('closing http writer');\n        },\n        abort(err) {\n          console.log('Sink error:', err);\n        },\n      },\n      { highWaterMark: Number.MAX_SAFE_INTEGER },\n    );\n\n    this.inputStream.stream().pipeThrough(transformer).pipeTo(httpPostWriter);\n  }\n\n  private ensureInputNotEnded() {\n    if (this.inputStream.closed) {\n      throw new Error('input stream is closed');\n    }\n  }\n\n  private ensureStreamsNotEnded() {\n    this.ensureInputNotEnded();\n  }\n\n  private getResamplerFor(inputSampleRate: number): AudioResampler {\n    if (!this.resampler) {\n      this.resampler = new AudioResampler(inputSampleRate, this.options.sampleRate);\n    }\n    return this.resampler;\n  }\n\n  get stream(): ReadableStream<InterruptionEvent> {\n    return this.eventStream.stream();\n  }\n\n  async pushFrame(frame: InterruptionSentinel | AudioFrame): Promise<void> {\n    this.ensureStreamsNotEnded();\n    if (!(frame instanceof AudioFrame)) {\n      if (frame.type === 'overlap-speech-started') {\n        this.overlapSpeechStartedAt = Date.now() - frame.speechDuration;\n      }\n      return this.inputStream.write(frame);\n    } else if (this.options.sampleRate !== frame.sampleRate) {\n      const resampler = this.getResamplerFor(frame.sampleRate);\n      if (resampler.inputRate !== frame.sampleRate) {\n        throw new Error('the sample rate of the input frames must be consistent');\n      }\n      for (const resampledFrame of resampler.push(frame)) {\n        await this.inputStream.write(resampledFrame);\n      }\n    } else {\n      await this.inputStream.write(frame);\n    }\n  }\n\n  async flush(): Promise<void> {\n    this.ensureStreamsNotEnded();\n    this.inputStream.write(InterruptionStreamSentinel.flush());\n  }\n\n  async endInput(): Promise<void> {\n    await this.flush();\n    await this.inputStream.close();\n  }\n\n  async close(): Promise<void> {\n    if (!this.inputStream.closed) await this.inputStream.close();\n  }\n}\n\n/**\n * Write the audio frame to the output data array and return the new start index\n * and the number of samples written.\n */\nfunction writeToInferenceS16Data(\n  frame: AudioFrame,\n  startIdx: number,\n  outData: Int16Array,\n  maxAudioDuration: number,\n): { startIdx: number; samplesWritten: number } {\n  const maxWindowSize = Math.floor(maxAudioDuration * frame.sampleRate);\n\n  if (frame.samplesPerChannel > outData.length) {\n    throw new Error('frame samples are greater than the max window size');\n  }\n\n  // Shift the data to the left if the window would overflow\n  const shift = startIdx + frame.samplesPerChannel - maxWindowSize;\n  if (shift > 0) {\n    outData.copyWithin(0, shift, startIdx);\n    startIdx -= shift;\n  }\n\n  // Get the frame data as Int16Array\n  const frameData = new Int16Array(\n    frame.data.buffer,\n    frame.data.byteOffset,\n    frame.samplesPerChannel * frame.channels,\n  );\n\n  if (frame.channels > 1) {\n    // Mix down multiple channels to mono by averaging\n    for (let i = 0; i < frame.samplesPerChannel; i++) {\n      let sum = 0;\n      for (let ch = 0; ch < frame.channels; ch++) {\n        sum += frameData[i * frame.channels + ch] ?? 0;\n      }\n      outData[startIdx + i] = Math.floor(sum / frame.channels);\n    }\n  } else {\n    // Single channel - copy directly\n    outData.set(frameData, startIdx);\n  }\n\n  startIdx += frame.samplesPerChannel;\n  return { startIdx, samplesWritten: frame.samplesPerChannel };\n}\n"],"mappings":"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","names":[]}

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

@@ -0,0 +1,57 @@
+/// <reference types="node" resolution-mode="require"/>
+import { AudioFrame } from '@livekit/rtc-node';
+import type { Span } from '@opentelemetry/api';
+import { type ReadableStream } from 'stream/web';
+import type { AdaptiveInterruptionDetector } from './AdaptiveInterruptionDetector.js';
+import { type InterruptionEvent } from './interruption.js';
+export interface AgentSpeechStarted {
+    type: 'agent-speech-started';
+}
+export interface AgentSpeechEnded {
+    type: 'agent-speech-ended';
+}
+export interface OverlapSpeechStarted {
+    type: 'overlap-speech-started';
+    speechDuration: number;
+    userSpeakingSpan: Span;
+}
+export interface OverlapSpeechEnded {
+    type: 'overlap-speech-ended';
+}
+export interface Flush {
+    type: 'flush';
+}
+export type InterruptionSentinel = AgentSpeechStarted | AgentSpeechEnded | OverlapSpeechStarted | OverlapSpeechEnded | Flush;
+export declare class InterruptionStreamSentinel {
+    static speechStarted(): AgentSpeechStarted;
+    static speechEnded(): AgentSpeechEnded;
+    static overlapSpeechStarted(speechDuration: number, userSpeakingSpan: Span): OverlapSpeechStarted;
+    static overlapSpeechEnded(): OverlapSpeechEnded;
+    static flush(): Flush;
+}
+export interface ApiConnectOptions {
+    maxRetries: number;
+    retryInterval: number;
+    timeout: number;
+}
+export declare class InterruptionStreamBase {
+    private inputStream;
+    private eventStream;
+    private resampler?;
+    private userSpeakingSpan;
+    private overlapSpeechStartedAt;
+    private options;
+    private apiOptions;
+    private model;
+    constructor(model: AdaptiveInterruptionDetector, apiOptions: Partial<ApiConnectOptions>);
+    private setupTransform;
+    private ensureInputNotEnded;
+    private ensureStreamsNotEnded;
+    private getResamplerFor;
+    get stream(): ReadableStream<InterruptionEvent>;
+    pushFrame(frame: InterruptionSentinel | AudioFrame): Promise<void>;
+    flush(): Promise<void>;
+    endInput(): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=InterruptionStream.d.ts.map

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

@@ -0,0 +1,57 @@
+/// <reference types="node" resolution-mode="require"/>
+import { AudioFrame } from '@livekit/rtc-node';
+import type { Span } from '@opentelemetry/api';
+import { type ReadableStream } from 'stream/web';
+import type { AdaptiveInterruptionDetector } from './AdaptiveInterruptionDetector.js';
+import { type InterruptionEvent } from './interruption.js';
+export interface AgentSpeechStarted {
+    type: 'agent-speech-started';
+}
+export interface AgentSpeechEnded {
+    type: 'agent-speech-ended';
+}
+export interface OverlapSpeechStarted {
+    type: 'overlap-speech-started';
+    speechDuration: number;
+    userSpeakingSpan: Span;
+}
+export interface OverlapSpeechEnded {
+    type: 'overlap-speech-ended';
+}
+export interface Flush {
+    type: 'flush';
+}
+export type InterruptionSentinel = AgentSpeechStarted | AgentSpeechEnded | OverlapSpeechStarted | OverlapSpeechEnded | Flush;
+export declare class InterruptionStreamSentinel {
+    static speechStarted(): AgentSpeechStarted;
+    static speechEnded(): AgentSpeechEnded;
+    static overlapSpeechStarted(speechDuration: number, userSpeakingSpan: Span): OverlapSpeechStarted;
+    static overlapSpeechEnded(): OverlapSpeechEnded;
+    static flush(): Flush;
+}
+export interface ApiConnectOptions {
+    maxRetries: number;
+    retryInterval: number;
+    timeout: number;
+}
+export declare class InterruptionStreamBase {
+    private inputStream;
+    private eventStream;
+    private resampler?;
+    private userSpeakingSpan;
+    private overlapSpeechStartedAt;
+    private options;
+    private apiOptions;
+    private model;
+    constructor(model: AdaptiveInterruptionDetector, apiOptions: Partial<ApiConnectOptions>);
+    private setupTransform;
+    private ensureInputNotEnded;
+    private ensureStreamsNotEnded;
+    private getResamplerFor;
+    get stream(): ReadableStream<InterruptionEvent>;
+    pushFrame(frame: InterruptionSentinel | AudioFrame): Promise<void>;
+    flush(): Promise<void>;
+    endInput(): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=InterruptionStream.d.ts.map