@livekit/agents 1.0.35 → 1.0.36-dev.0

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"InterruptionStream.d.ts","sourceRoot":"","sources":["../../../src/inference/interruption/InterruptionStream.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAkB,MAAM,mBAAmB,CAAC;AAC/D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAE,KAAK,cAAc,EAAmC,MAAM,YAAY,CAAC;AAIlF,OAAO,KAAK,EACV,4BAA4B,EAE7B,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EAGL,KAAK,iBAAiB,EAEvB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,sBAAsB,CAAC;CAC9B;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,oBAAoB,CAAC;CAC5B;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,wBAAwB,CAAC;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,sBAAsB,CAAC;CAC9B;AAED,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,MAAM,oBAAoB,GAC5B,kBAAkB,GAClB,gBAAgB,GAChB,oBAAoB,GACpB,kBAAkB,GAClB,KAAK,CAAC;AAEV,qBAAa,0BAA0B;IACrC,MAAM,CAAC,aAAa,IAAI,kBAAkB;IAI1C,MAAM,CAAC,WAAW,IAAI,gBAAgB;IAItC,MAAM,CAAC,oBAAoB,CACzB,cAAc,EAAE,MAAM,EACtB,gBAAgB,EAAE,IAAI,GACrB,oBAAoB;IAIvB,MAAM,CAAC,kBAAkB,IAAI,kBAAkB;IAI/C,MAAM,CAAC,KAAK,IAAI,KAAK;CAGtB;AAED,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB;AAaD,qBAAa,sBAAsB;IACjC,OAAO,CAAC,WAAW,CAA+E;IAElG,OAAO,CAAC,WAAW,CAA+D;IAElF,OAAO,CAAC,SAAS,CAAC,CAAiB;IAEnC,OAAO,CAAC,gBAAgB,CAAmB;IAE3C,OAAO,CAAC,sBAAsB,CAAqB;IAEnD,OAAO,CAAC,OAAO,CAAsB;IAErC,OAAO,CAAC,UAAU,CAAoB;IAEtC,OAAO,CAAC,KAAK,CAA+B;gBAEhC,KAAK,EAAE,4BAA4B,EAAE,UAAU,EAAE,OAAO,CAAC,iBAAiB,CAAC;IAevF,OAAO,CAAC,cAAc;IA2KtB,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,qBAAqB;IAI7B,OAAO,CAAC,eAAe;IAOvB,IAAI,MAAM,IAAI,cAAc,CAAC,iBAAiB,CAAC,CAE9C;IAEK,SAAS,CAAC,KAAK,EAAE,oBAAoB,GAAG,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAoBlE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAKzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}