@livekit/agents 0.0.0-20260120144724

package/dist/inference/interruption/http_transport.js

@@ -0,0 +1,33 @@
+import { ofetch } from "ofetch";
+async function predictHTTP(data, predictOptions, options) {
+  const createdAt = performance.now();
+  const url = new URL(`/bargein`, options.baseUrl);
+  url.searchParams.append("threshold", predictOptions.threshold.toString());
+  url.searchParams.append("min_frames", predictOptions.minFrames.toFixed());
+  url.searchParams.append("created_at", createdAt.toFixed());
+  const { created_at, is_bargein, probabilities } = await ofetch(
+    url.toString(),
+    {
+      retry: 1,
+      retryDelay: 100,
+      headers: {
+        "Content-Type": "application/octet-stream",
+        Authorization: `Bearer ${options.token}`
+      },
+      signal: options.signal,
+      timeout: options.timeout,
+      method: "POST",
+      body: data
+    }
+  );
+  return {
+    createdAt: created_at,
+    isBargein: is_bargein,
+    probabilities: new Float32Array(probabilities),
+    predictionDuration: (performance.now() - createdAt) / 1e9
+  };
+}
+export {
+  predictHTTP
+};
+//# sourceMappingURL=http_transport.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/http_transport.ts"],"sourcesContent":["import { ofetch } from 'ofetch';\n\nexport interface PostOptions {\n  baseUrl: string;\n  token: string;\n  signal?: AbortSignal;\n  timeout?: number;\n}\n\nexport interface PredictOptions {\n  threshold: number;\n  minFrames: number;\n}\n\nexport interface PredictEndpointResponse {\n  created_at: number;\n  is_bargein: boolean;\n  probabilities: number[];\n}\n\nexport interface PredictResponse {\n  createdAt: number;\n  isBargein: boolean;\n  probabilities: Float32Array;\n  predictionDuration: number;\n}\n\nexport async function predictHTTP(\n  data: Int16Array,\n  predictOptions: PredictOptions,\n  options: PostOptions,\n): Promise<PredictResponse> {\n  const createdAt = performance.now();\n  const url = new URL(`/bargein`, options.baseUrl);\n  url.searchParams.append('threshold', predictOptions.threshold.toString());\n  url.searchParams.append('min_frames', predictOptions.minFrames.toFixed());\n  url.searchParams.append('created_at', createdAt.toFixed());\n\n  const { created_at, is_bargein, probabilities } = await ofetch<PredictEndpointResponse>(\n    url.toString(),\n    {\n      retry: 1,\n      retryDelay: 100,\n      headers: {\n        'Content-Type': 'application/octet-stream',\n        Authorization: `Bearer ${options.token}`,\n      },\n      signal: options.signal,\n      timeout: options.timeout,\n      method: 'POST',\n      body: data,\n    },\n  );\n\n  return {\n    createdAt: created_at,\n    isBargein: is_bargein,\n    probabilities: new Float32Array(probabilities),\n    predictionDuration: (performance.now() - createdAt) / 1e9,\n  };\n}\n"],"mappings":"AAAA,SAAS,cAAc;AA2BvB,eAAsB,YACpB,MACA,gBACA,SAC0B;AAC1B,QAAM,YAAY,YAAY,IAAI;AAClC,QAAM,MAAM,IAAI,IAAI,YAAY,QAAQ,OAAO;AAC/C,MAAI,aAAa,OAAO,aAAa,eAAe,UAAU,SAAS,CAAC;AACxE,MAAI,aAAa,OAAO,cAAc,eAAe,UAAU,QAAQ,CAAC;AACxE,MAAI,aAAa,OAAO,cAAc,UAAU,QAAQ,CAAC;AAEzD,QAAM,EAAE,YAAY,YAAY,cAAc,IAAI,MAAM;AAAA,IACtD,IAAI,SAAS;AAAA,IACb;AAAA,MACE,OAAO;AAAA,MACP,YAAY;AAAA,MACZ,SAAS;AAAA,QACP,gBAAgB;AAAA,QAChB,eAAe,UAAU,QAAQ,KAAK;AAAA,MACxC;AAAA,MACA,QAAQ,QAAQ;AAAA,MAChB,SAAS,QAAQ;AAAA,MACjB,QAAQ;AAAA,MACR,MAAM;AAAA,IACR;AAAA,EACF;AAEA,SAAO;AAAA,IACL,WAAW;AAAA,IACX,WAAW;AAAA,IACX,eAAe,IAAI,aAAa,aAAa;AAAA,IAC7C,qBAAqB,YAAY,IAAI,IAAI,aAAa;AAAA,EACxD;AACF;","names":[]}

package/dist/inference/interruption/index.cjs

@@ -0,0 +1,34 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var interruption_exports = {};
+__export(interruption_exports, {
+  InterruptionStreamSentinel: () => import_InterruptionStream.InterruptionStreamSentinel
+});
+module.exports = __toCommonJS(interruption_exports);
+__reExport(interruption_exports, require("./AdaptiveInterruptionDetector.cjs"), module.exports);
+__reExport(interruption_exports, require("./interruption.cjs"), module.exports);
+var import_InterruptionStream = require("./InterruptionStream.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InterruptionStreamSentinel,
+  ...require("./AdaptiveInterruptionDetector.cjs"),
+  ...require("./interruption.cjs")
+});
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/index.ts"],"sourcesContent":["export * from './AdaptiveInterruptionDetector.js';\nexport * from './interruption.js';\nexport { InterruptionStreamSentinel } from './InterruptionStream.js';\nexport type { InterruptionSentinel } from './InterruptionStream.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iCAAc,8CAAd;AACA,iCAAc,8BADd;AAEA,gCAA2C;","names":[]}

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

@@ -0,0 +1,5 @@
+export * from './AdaptiveInterruptionDetector.js';
+export * from './interruption.js';
+export { InterruptionStreamSentinel } from './InterruptionStream.js';
+export type { InterruptionSentinel } from './InterruptionStream.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,5 @@
+export * from './AdaptiveInterruptionDetector.js';
+export * from './interruption.js';
+export { InterruptionStreamSentinel } from './InterruptionStream.js';
+export type { InterruptionSentinel } from './InterruptionStream.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/inference/interruption/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AACrE,YAAY,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/inference/interruption/index.js

@@ -0,0 +1,7 @@
+export * from "./AdaptiveInterruptionDetector.js";
+export * from "./interruption.js";
+import { InterruptionStreamSentinel } from "./InterruptionStream.js";
+export {
+  InterruptionStreamSentinel
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/index.ts"],"sourcesContent":["export * from './AdaptiveInterruptionDetector.js';\nexport * from './interruption.js';\nexport { InterruptionStreamSentinel } from './InterruptionStream.js';\nexport type { InterruptionSentinel } from './InterruptionStream.js';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;AACd,SAAS,kCAAkC;","names":[]}

package/dist/inference/interruption/interruption.cjs

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var interruption_exports = {};
+__export(interruption_exports, {
+  InterruptionCacheEntry: () => InterruptionCacheEntry,
+  InterruptionDetectionError: () => InterruptionDetectionError,
+  InterruptionEventType: () => InterruptionEventType
+});
+module.exports = __toCommonJS(interruption_exports);
+var import_utils = require("../utils.cjs");
+var import_defaults = require("./defaults.cjs");
+var InterruptionEventType = /* @__PURE__ */ ((InterruptionEventType2) => {
+  InterruptionEventType2["INTERRUPTION"] = "interruption";
+  InterruptionEventType2["OVERLAP_SPEECH_ENDED"] = "overlap_speech_ended";
+  return InterruptionEventType2;
+})(InterruptionEventType || {});
+class InterruptionDetectionError extends Error {
+  type = "InterruptionDetectionError";
+  timestamp;
+  label;
+  recoverable;
+  constructor(message, timestamp, label, recoverable) {
+    super(message);
+    this.name = "InterruptionDetectionError";
+    this.timestamp = timestamp;
+    this.label = label;
+    this.recoverable = recoverable;
+  }
+  toString() {
+    return `${this.name}: ${this.message} (label=${this.label}, timestamp=${this.timestamp}, recoverable=${this.recoverable})`;
+  }
+}
+function estimateProbability(probabilities, windowSize = import_defaults.MIN_INTERRUPTION_DURATION) {
+  const minWindow = Math.ceil(windowSize / 0.025);
+  if (probabilities.length < minWindow) {
+    return 0;
+  }
+  return (0, import_utils.slidingWindowMinMax)(probabilities, windowSize);
+}
+class InterruptionCacheEntry {
+  createdAt;
+  totalDuration;
+  predictionDuration;
+  detectionDelay;
+  speechInput;
+  probabilities;
+  isInterruption;
+  probability;
+  constructor(params) {
+    this.createdAt = params.createdAt;
+    this.totalDuration = params.totalDuration ?? 0;
+    this.predictionDuration = params.predictionDuration ?? 0;
+    this.detectionDelay = params.detectionDelay ?? 0;
+    this.speechInput = params.speechInput;
+    this.probabilities = params.probabilities;
+    this.isInterruption = params.isInterruption;
+    this.probability = this.probabilities ? estimateProbability(this.probabilities) : 0;
+  }
+  static default() {
+    return new InterruptionCacheEntry({ createdAt: 0 });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InterruptionCacheEntry,
+  InterruptionDetectionError,
+  InterruptionEventType
+});
+//# sourceMappingURL=interruption.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/interruption.ts"],"sourcesContent":["import { slidingWindowMinMax } from '../utils.js';\nimport { MIN_INTERRUPTION_DURATION } from './defaults.js';\n\nexport enum InterruptionEventType {\n  INTERRUPTION = 'interruption',\n  OVERLAP_SPEECH_ENDED = 'overlap_speech_ended',\n}\nexport interface InterruptionEvent {\n  type: InterruptionEventType;\n  timestamp: number;\n  isInterruption: boolean;\n  totalDuration: number;\n  predictionDuration: number;\n  detectionDelay: number;\n  overlapSpeechStartedAt?: number;\n  speechInput?: Int16Array;\n  probabilities?: Float32Array;\n  probability: number;\n}\n\nexport class InterruptionDetectionError extends Error {\n  readonly type = 'InterruptionDetectionError';\n\n  readonly timestamp: number;\n  readonly label: string;\n  readonly recoverable: boolean;\n\n  constructor(message: string, timestamp: number, label: string, recoverable: boolean) {\n    super(message);\n    this.name = 'InterruptionDetectionError';\n    this.timestamp = timestamp;\n    this.label = label;\n    this.recoverable = recoverable;\n  }\n\n  toString(): string {\n    return `${this.name}: ${this.message} (label=${this.label}, timestamp=${this.timestamp}, recoverable=${this.recoverable})`;\n  }\n}\n\nfunction estimateProbability(\n  probabilities: Float32Array,\n  windowSize: number = MIN_INTERRUPTION_DURATION,\n): number {\n  const minWindow = Math.ceil(windowSize / 0.025); // 25ms per frame\n  if (probabilities.length < minWindow) {\n    return 0;\n  }\n\n  return slidingWindowMinMax(probabilities, windowSize);\n}\n\n/**\n * Typed cache entry for interruption inference results.\n */\nexport class InterruptionCacheEntry {\n  readonly createdAt: number;\n  readonly totalDuration: number;\n  readonly predictionDuration: number;\n  readonly detectionDelay: number;\n  readonly speechInput?: Int16Array;\n  readonly probabilities?: Float32Array;\n  readonly isInterruption?: boolean;\n  readonly probability: number;\n\n  constructor(params: {\n    createdAt: number;\n    speechInput?: Int16Array;\n    totalDuration?: number;\n    predictionDuration?: number;\n    detectionDelay?: number;\n    probabilities?: Float32Array;\n    isInterruption?: boolean;\n  }) {\n    this.createdAt = params.createdAt;\n    this.totalDuration = params.totalDuration ?? 0;\n    this.predictionDuration = params.predictionDuration ?? 0;\n    this.detectionDelay = params.detectionDelay ?? 0;\n    this.speechInput = params.speechInput;\n    this.probabilities = params.probabilities;\n    this.isInterruption = params.isInterruption;\n    this.probability = this.probabilities ? estimateProbability(this.probabilities) : 0;\n  }\n\n  static default(): InterruptionCacheEntry {\n    return new InterruptionCacheEntry({ createdAt: 0 });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAoC;AACpC,sBAA0C;AAEnC,IAAK,wBAAL,kBAAKA,2BAAL;AACL,EAAAA,uBAAA,kBAAe;AACf,EAAAA,uBAAA,0BAAuB;AAFb,SAAAA;AAAA,GAAA;AAiBL,MAAM,mCAAmC,MAAM;AAAA,EAC3C,OAAO;AAAA,EAEP;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,SAAiB,WAAmB,OAAe,aAAsB;AACnF,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,YAAY;AACjB,SAAK,QAAQ;AACb,SAAK,cAAc;AAAA,EACrB;AAAA,EAEA,WAAmB;AACjB,WAAO,GAAG,KAAK,IAAI,KAAK,KAAK,OAAO,WAAW,KAAK,KAAK,eAAe,KAAK,SAAS,iBAAiB,KAAK,WAAW;AAAA,EACzH;AACF;AAEA,SAAS,oBACP,eACA,aAAqB,2CACb;AACR,QAAM,YAAY,KAAK,KAAK,aAAa,KAAK;AAC9C,MAAI,cAAc,SAAS,WAAW;AACpC,WAAO;AAAA,EACT;AAEA,aAAO,kCAAoB,eAAe,UAAU;AACtD;AAKO,MAAM,uBAAuB;AAAA,EACzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,QAQT;AACD,SAAK,YAAY,OAAO;AACxB,SAAK,gBAAgB,OAAO,iBAAiB;AAC7C,SAAK,qBAAqB,OAAO,sBAAsB;AACvD,SAAK,iBAAiB,OAAO,kBAAkB;AAC/C,SAAK,cAAc,OAAO;AAC1B,SAAK,gBAAgB,OAAO;AAC5B,SAAK,iBAAiB,OAAO;AAC7B,SAAK,cAAc,KAAK,gBAAgB,oBAAoB,KAAK,aAAa,IAAI;AAAA,EACpF;AAAA,EAEA,OAAO,UAAkC;AACvC,WAAO,IAAI,uBAAuB,EAAE,WAAW,EAAE,CAAC;AAAA,EACpD;AACF;","names":["InterruptionEventType"]}

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

@@ -0,0 +1,48 @@
+export declare enum InterruptionEventType {
+    INTERRUPTION = "interruption",
+    OVERLAP_SPEECH_ENDED = "overlap_speech_ended"
+}
+export interface InterruptionEvent {
+    type: InterruptionEventType;
+    timestamp: number;
+    isInterruption: boolean;
+    totalDuration: number;
+    predictionDuration: number;
+    detectionDelay: number;
+    overlapSpeechStartedAt?: number;
+    speechInput?: Int16Array;
+    probabilities?: Float32Array;
+    probability: number;
+}
+export declare class InterruptionDetectionError extends Error {
+    readonly type = "InterruptionDetectionError";
+    readonly timestamp: number;
+    readonly label: string;
+    readonly recoverable: boolean;
+    constructor(message: string, timestamp: number, label: string, recoverable: boolean);
+    toString(): string;
+}
+/**
+ * Typed cache entry for interruption inference results.
+ */
+export declare class InterruptionCacheEntry {
+    readonly createdAt: number;
+    readonly totalDuration: number;
+    readonly predictionDuration: number;
+    readonly detectionDelay: number;
+    readonly speechInput?: Int16Array;
+    readonly probabilities?: Float32Array;
+    readonly isInterruption?: boolean;
+    readonly probability: number;
+    constructor(params: {
+        createdAt: number;
+        speechInput?: Int16Array;
+        totalDuration?: number;
+        predictionDuration?: number;
+        detectionDelay?: number;
+        probabilities?: Float32Array;
+        isInterruption?: boolean;
+    });
+    static default(): InterruptionCacheEntry;
+}
+//# sourceMappingURL=interruption.d.ts.map

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

@@ -0,0 +1,48 @@
+export declare enum InterruptionEventType {
+    INTERRUPTION = "interruption",
+    OVERLAP_SPEECH_ENDED = "overlap_speech_ended"
+}
+export interface InterruptionEvent {
+    type: InterruptionEventType;
+    timestamp: number;
+    isInterruption: boolean;
+    totalDuration: number;
+    predictionDuration: number;
+    detectionDelay: number;
+    overlapSpeechStartedAt?: number;
+    speechInput?: Int16Array;
+    probabilities?: Float32Array;
+    probability: number;
+}
+export declare class InterruptionDetectionError extends Error {
+    readonly type = "InterruptionDetectionError";
+    readonly timestamp: number;
+    readonly label: string;
+    readonly recoverable: boolean;
+    constructor(message: string, timestamp: number, label: string, recoverable: boolean);
+    toString(): string;
+}
+/**
+ * Typed cache entry for interruption inference results.
+ */
+export declare class InterruptionCacheEntry {
+    readonly createdAt: number;
+    readonly totalDuration: number;
+    readonly predictionDuration: number;
+    readonly detectionDelay: number;
+    readonly speechInput?: Int16Array;
+    readonly probabilities?: Float32Array;
+    readonly isInterruption?: boolean;
+    readonly probability: number;
+    constructor(params: {
+        createdAt: number;
+        speechInput?: Int16Array;
+        totalDuration?: number;
+        predictionDuration?: number;
+        detectionDelay?: number;
+        probabilities?: Float32Array;
+        isInterruption?: boolean;
+    });
+    static default(): InterruptionCacheEntry;
+}
+//# sourceMappingURL=interruption.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interruption.d.ts","sourceRoot":"","sources":["../../../src/inference/interruption/interruption.ts"],"names":[],"mappings":"AAGA,oBAAY,qBAAqB;IAC/B,YAAY,iBAAiB;IAC7B,oBAAoB,yBAAyB;CAC9C;AACD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,qBAAqB,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,aAAa,CAAC,EAAE,YAAY,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,0BAA2B,SAAQ,KAAK;IACnD,QAAQ,CAAC,IAAI,gCAAgC;IAE7C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;gBAElB,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO;IAQnF,QAAQ,IAAI,MAAM;CAGnB;AAcD;;GAEG;AACH,qBAAa,sBAAsB;IACjC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,UAAU,CAAC;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,YAAY,CAAC;IACtC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;gBAEjB,MAAM,EAAE;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,CAAC,EAAE,UAAU,CAAC;QACzB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,aAAa,CAAC,EAAE,YAAY,CAAC;QAC7B,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B;IAWD,MAAM,CAAC,OAAO,IAAI,sBAAsB;CAGzC"}

package/dist/inference/interruption/interruption.js

@@ -0,0 +1,59 @@
+import { slidingWindowMinMax } from "../utils.js";
+import { MIN_INTERRUPTION_DURATION } from "./defaults.js";
+var InterruptionEventType = /* @__PURE__ */ ((InterruptionEventType2) => {
+  InterruptionEventType2["INTERRUPTION"] = "interruption";
+  InterruptionEventType2["OVERLAP_SPEECH_ENDED"] = "overlap_speech_ended";
+  return InterruptionEventType2;
+})(InterruptionEventType || {});
+class InterruptionDetectionError extends Error {
+  type = "InterruptionDetectionError";
+  timestamp;
+  label;
+  recoverable;
+  constructor(message, timestamp, label, recoverable) {
+    super(message);
+    this.name = "InterruptionDetectionError";
+    this.timestamp = timestamp;
+    this.label = label;
+    this.recoverable = recoverable;
+  }
+  toString() {
+    return `${this.name}: ${this.message} (label=${this.label}, timestamp=${this.timestamp}, recoverable=${this.recoverable})`;
+  }
+}
+function estimateProbability(probabilities, windowSize = MIN_INTERRUPTION_DURATION) {
+  const minWindow = Math.ceil(windowSize / 0.025);
+  if (probabilities.length < minWindow) {
+    return 0;
+  }
+  return slidingWindowMinMax(probabilities, windowSize);
+}
+class InterruptionCacheEntry {
+  createdAt;
+  totalDuration;
+  predictionDuration;
+  detectionDelay;
+  speechInput;
+  probabilities;
+  isInterruption;
+  probability;
+  constructor(params) {
+    this.createdAt = params.createdAt;
+    this.totalDuration = params.totalDuration ?? 0;
+    this.predictionDuration = params.predictionDuration ?? 0;
+    this.detectionDelay = params.detectionDelay ?? 0;
+    this.speechInput = params.speechInput;
+    this.probabilities = params.probabilities;
+    this.isInterruption = params.isInterruption;
+    this.probability = this.probabilities ? estimateProbability(this.probabilities) : 0;
+  }
+  static default() {
+    return new InterruptionCacheEntry({ createdAt: 0 });
+  }
+}
+export {
+  InterruptionCacheEntry,
+  InterruptionDetectionError,
+  InterruptionEventType
+};
+//# sourceMappingURL=interruption.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/interruption.ts"],"sourcesContent":["import { slidingWindowMinMax } from '../utils.js';\nimport { MIN_INTERRUPTION_DURATION } from './defaults.js';\n\nexport enum InterruptionEventType {\n  INTERRUPTION = 'interruption',\n  OVERLAP_SPEECH_ENDED = 'overlap_speech_ended',\n}\nexport interface InterruptionEvent {\n  type: InterruptionEventType;\n  timestamp: number;\n  isInterruption: boolean;\n  totalDuration: number;\n  predictionDuration: number;\n  detectionDelay: number;\n  overlapSpeechStartedAt?: number;\n  speechInput?: Int16Array;\n  probabilities?: Float32Array;\n  probability: number;\n}\n\nexport class InterruptionDetectionError extends Error {\n  readonly type = 'InterruptionDetectionError';\n\n  readonly timestamp: number;\n  readonly label: string;\n  readonly recoverable: boolean;\n\n  constructor(message: string, timestamp: number, label: string, recoverable: boolean) {\n    super(message);\n    this.name = 'InterruptionDetectionError';\n    this.timestamp = timestamp;\n    this.label = label;\n    this.recoverable = recoverable;\n  }\n\n  toString(): string {\n    return `${this.name}: ${this.message} (label=${this.label}, timestamp=${this.timestamp}, recoverable=${this.recoverable})`;\n  }\n}\n\nfunction estimateProbability(\n  probabilities: Float32Array,\n  windowSize: number = MIN_INTERRUPTION_DURATION,\n): number {\n  const minWindow = Math.ceil(windowSize / 0.025); // 25ms per frame\n  if (probabilities.length < minWindow) {\n    return 0;\n  }\n\n  return slidingWindowMinMax(probabilities, windowSize);\n}\n\n/**\n * Typed cache entry for interruption inference results.\n */\nexport class InterruptionCacheEntry {\n  readonly createdAt: number;\n  readonly totalDuration: number;\n  readonly predictionDuration: number;\n  readonly detectionDelay: number;\n  readonly speechInput?: Int16Array;\n  readonly probabilities?: Float32Array;\n  readonly isInterruption?: boolean;\n  readonly probability: number;\n\n  constructor(params: {\n    createdAt: number;\n    speechInput?: Int16Array;\n    totalDuration?: number;\n    predictionDuration?: number;\n    detectionDelay?: number;\n    probabilities?: Float32Array;\n    isInterruption?: boolean;\n  }) {\n    this.createdAt = params.createdAt;\n    this.totalDuration = params.totalDuration ?? 0;\n    this.predictionDuration = params.predictionDuration ?? 0;\n    this.detectionDelay = params.detectionDelay ?? 0;\n    this.speechInput = params.speechInput;\n    this.probabilities = params.probabilities;\n    this.isInterruption = params.isInterruption;\n    this.probability = this.probabilities ? estimateProbability(this.probabilities) : 0;\n  }\n\n  static default(): InterruptionCacheEntry {\n    return new InterruptionCacheEntry({ createdAt: 0 });\n  }\n}\n"],"mappings":"AAAA,SAAS,2BAA2B;AACpC,SAAS,iCAAiC;AAEnC,IAAK,wBAAL,kBAAKA,2BAAL;AACL,EAAAA,uBAAA,kBAAe;AACf,EAAAA,uBAAA,0BAAuB;AAFb,SAAAA;AAAA,GAAA;AAiBL,MAAM,mCAAmC,MAAM;AAAA,EAC3C,OAAO;AAAA,EAEP;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,SAAiB,WAAmB,OAAe,aAAsB;AACnF,UAAM,OAAO;AACb,SAAK,OAAO;AACZ,SAAK,YAAY;AACjB,SAAK,QAAQ;AACb,SAAK,cAAc;AAAA,EACrB;AAAA,EAEA,WAAmB;AACjB,WAAO,GAAG,KAAK,IAAI,KAAK,KAAK,OAAO,WAAW,KAAK,KAAK,eAAe,KAAK,SAAS,iBAAiB,KAAK,WAAW;AAAA,EACzH;AACF;AAEA,SAAS,oBACP,eACA,aAAqB,2BACb;AACR,QAAM,YAAY,KAAK,KAAK,aAAa,KAAK;AAC9C,MAAI,cAAc,SAAS,WAAW;AACpC,WAAO;AAAA,EACT;AAEA,SAAO,oBAAoB,eAAe,UAAU;AACtD;AAKO,MAAM,uBAAuB;AAAA,EACzB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,QAQT;AACD,SAAK,YAAY,OAAO;AACxB,SAAK,gBAAgB,OAAO,iBAAiB;AAC7C,SAAK,qBAAqB,OAAO,sBAAsB;AACvD,SAAK,iBAAiB,OAAO,kBAAkB;AAC/C,SAAK,cAAc,OAAO;AAC1B,SAAK,gBAAgB,OAAO;AAC5B,SAAK,iBAAiB,OAAO;AAC7B,SAAK,cAAc,KAAK,gBAAgB,oBAAoB,KAAK,aAAa,IAAI;AAAA,EACpF;AAAA,EAEA,OAAO,UAAkC;AACvC,WAAO,IAAI,uBAAuB,EAAE,WAAW,EAAE,CAAC;AAAA,EACpD;AACF;","names":["InterruptionEventType"]}