@livekit/agents 1.1.0 → 1.2.1

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

@@ -0,0 +1,65 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Throws } from '@livekit/throws-transformer/throws';
+import { TransformStream } from 'stream/web';
+import { z } from 'zod';
+import { APIConnectionError, APIError, APIStatusError } from '../../_exceptions.js';
+import { InterruptionCacheEntry } from './interruption_cache_entry.js';
+import type { OverlappingSpeechEvent } from './types.js';
+import type { BoundedCache } from './utils.js';
+export interface PostOptions {
+    baseUrl: string;
+    token: string;
+    signal?: AbortSignal;
+    timeout?: number;
+    maxRetries?: number;
+}
+export interface PredictOptions {
+    threshold: number;
+    minFrames: number;
+}
+export declare const predictEndpointResponseSchema: z.ZodObject<{
+    created_at: z.ZodNumber;
+    is_bargein: z.ZodBoolean;
+    probabilities: z.ZodArray<z.ZodNumber, "many">;
+}, "strip", z.ZodTypeAny, {
+    created_at: number;
+    is_bargein: boolean;
+    probabilities: number[];
+}, {
+    created_at: number;
+    is_bargein: boolean;
+    probabilities: number[];
+}>;
+export type PredictEndpointResponse = z.infer<typeof predictEndpointResponseSchema>;
+export interface PredictResponse {
+    createdAt: number;
+    isBargein: boolean;
+    probabilities: number[];
+    predictionDurationInS: number;
+}
+export declare function predictHTTP(data: Int16Array, predictOptions: PredictOptions, options: PostOptions): Promise<Throws<PredictResponse, APIConnectionError | APIStatusError | APIError>>;
+export interface HttpTransportOptions {
+    baseUrl: string;
+    apiKey: string;
+    apiSecret: string;
+    threshold: number;
+    minFrames: number;
+    timeout: number;
+    maxRetries?: number;
+}
+export interface HttpTransportState {
+    overlapSpeechStarted: boolean;
+    overlapSpeechStartedAt: number | undefined;
+    cache: BoundedCache<number, InterruptionCacheEntry>;
+}
+/**
+ * Creates an HTTP transport TransformStream for interruption detection.
+ *
+ * This transport receives Int16Array audio slices and outputs InterruptionEvents.
+ * Each audio slice triggers an HTTP POST request.
+ *
+ * @param options - Transport options object. This is read on each request, so mutations
+ *                  to threshold/minFrames will be picked up dynamically.
+ */
+export declare function createHttpTransport(options: HttpTransportOptions, getState: () => HttpTransportState, setState: (partial: Partial<HttpTransportState>) => void, updateUserSpeakingSpan?: (entry: InterruptionCacheEntry) => void, getAndResetNumRequests?: () => number): TransformStream<Int16Array | OverlappingSpeechEvent, OverlappingSpeechEvent>;
+//# sourceMappingURL=http_transport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"http_transport.d.ts","sourceRoot":"","sources":["../../../src/inference/interruption/http_transport.ts"],"names":[],"mappings":";AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oCAAoC,CAAC;AAEjE,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,cAAc,EAAc,MAAM,sBAAsB,CAAC;AAGhG,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;EAIxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAED,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,EAChB,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC,MAAM,CAAC,eAAe,EAAE,kBAAkB,GAAG,cAAc,GAAG,QAAQ,CAAC,CAAC,CAmDlF;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,KAAK,EAAE,YAAY,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;CACrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,oBAAoB,EAC7B,QAAQ,EAAE,MAAM,kBAAkB,EAClC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,kBAAkB,CAAC,KAAK,IAAI,EACxD,sBAAsB,CAAC,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,EAChE,sBAAsB,CAAC,EAAE,MAAM,MAAM,GACpC,eAAe,CAAC,UAAU,GAAG,sBAAsB,EAAE,sBAAsB,CAAC,CA4E9E"}

package/dist/inference/interruption/http_transport.js

@@ -0,0 +1,137 @@
+import { FetchError, ofetch } from "ofetch";
+import { TransformStream } from "stream/web";
+import { z } from "zod";
+import { APIConnectionError, APIError, APIStatusError, isAPIError } from "../../_exceptions.js";
+import { log } from "../../log.js";
+import { createAccessToken } from "../utils.js";
+import { InterruptionCacheEntry } from "./interruption_cache_entry.js";
+const predictEndpointResponseSchema = z.object({
+  created_at: z.number(),
+  is_bargein: z.boolean(),
+  probabilities: z.array(z.number())
+});
+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());
+  try {
+    const response = await ofetch(url.toString(), {
+      retry: 0,
+      headers: {
+        "Content-Type": "application/octet-stream",
+        Authorization: `Bearer ${options.token}`
+      },
+      signal: options.signal,
+      timeout: options.timeout,
+      method: "POST",
+      body: data
+    });
+    const { created_at, is_bargein, probabilities } = predictEndpointResponseSchema.parse(response);
+    return {
+      createdAt: created_at,
+      isBargein: is_bargein,
+      probabilities,
+      predictionDurationInS: (performance.now() - createdAt) / 1e3
+    };
+  } catch (err) {
+    if (isAPIError(err)) throw err;
+    if (err instanceof FetchError) {
+      if (err.statusCode) {
+        throw new APIStatusError({
+          message: `error during interruption prediction: ${err.message}`,
+          options: { statusCode: err.statusCode, body: err.data }
+        });
+      }
+      if (err.cause instanceof Error && (err.cause.name === "TimeoutError" || err.cause.name === "AbortError")) {
+        throw new APIStatusError({
+          message: `interruption inference timeout: ${err.message}`,
+          options: { statusCode: 408, retryable: false }
+        });
+      }
+      throw new APIConnectionError({
+        message: `interruption inference connection error: ${err.message}`
+      });
+    }
+    throw new APIError(`error during interruption prediction: ${err}`);
+  }
+}
+function createHttpTransport(options, getState, setState, updateUserSpeakingSpan, getAndResetNumRequests) {
+  const logger = log();
+  return new TransformStream(
+    {
+      async transform(chunk, controller) {
+        if (!(chunk instanceof Int16Array)) {
+          controller.enqueue(chunk);
+          return;
+        }
+        const state = getState();
+        const overlapSpeechStartedAt = state.overlapSpeechStartedAt;
+        if (overlapSpeechStartedAt === void 0 || !state.overlapSpeechStarted) return;
+        try {
+          const resp = await predictHTTP(
+            chunk,
+            { threshold: options.threshold, minFrames: options.minFrames },
+            {
+              baseUrl: options.baseUrl,
+              timeout: options.timeout,
+              maxRetries: options.maxRetries,
+              token: await createAccessToken(options.apiKey, options.apiSecret)
+            }
+          );
+          const { createdAt, isBargein, probabilities, predictionDurationInS } = resp;
+          const entry = state.cache.setOrUpdate(
+            createdAt,
+            () => new InterruptionCacheEntry({ createdAt }),
+            {
+              probabilities,
+              isInterruption: isBargein,
+              speechInput: chunk,
+              totalDurationInS: (performance.now() - createdAt) / 1e3,
+              detectionDelayInS: (Date.now() - overlapSpeechStartedAt) / 1e3,
+              predictionDurationInS
+            }
+          );
+          if (state.overlapSpeechStarted && entry.isInterruption) {
+            if (updateUserSpeakingSpan) {
+              updateUserSpeakingSpan(entry);
+            }
+            const event = {
+              type: "overlapping_speech",
+              detectedAt: Date.now(),
+              overlapStartedAt: overlapSpeechStartedAt,
+              isInterruption: entry.isInterruption,
+              speechInput: entry.speechInput,
+              probabilities: entry.probabilities,
+              totalDurationInS: entry.totalDurationInS,
+              predictionDurationInS: entry.predictionDurationInS,
+              detectionDelayInS: entry.detectionDelayInS,
+              probability: entry.probability,
+              numRequests: (getAndResetNumRequests == null ? void 0 : getAndResetNumRequests()) ?? 0
+            };
+            logger.debug(
+              {
+                detectionDelayInS: entry.detectionDelayInS,
+                totalDurationInS: entry.totalDurationInS
+              },
+              "interruption detected"
+            );
+            setState({ overlapSpeechStarted: false });
+            controller.enqueue(event);
+          }
+        } catch (err) {
+          controller.error(err);
+        }
+      }
+    },
+    { highWaterMark: 2 },
+    { highWaterMark: 2 }
+  );
+}
+export {
+  createHttpTransport,
+  predictEndpointResponseSchema,
+  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":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { Throws } from '@livekit/throws-transformer/throws';\nimport { FetchError, ofetch } from 'ofetch';\nimport { TransformStream } from 'stream/web';\nimport { z } from 'zod';\nimport { APIConnectionError, APIError, APIStatusError, isAPIError } from '../../_exceptions.js';\nimport { log } from '../../log.js';\nimport { createAccessToken } from '../utils.js';\nimport { InterruptionCacheEntry } from './interruption_cache_entry.js';\nimport type { OverlappingSpeechEvent } from './types.js';\nimport type { BoundedCache } from './utils.js';\n\nexport interface PostOptions {\n  baseUrl: string;\n  token: string;\n  signal?: AbortSignal;\n  timeout?: number;\n  maxRetries?: number;\n}\n\nexport interface PredictOptions {\n  threshold: number;\n  minFrames: number;\n}\n\nexport const predictEndpointResponseSchema = z.object({\n  created_at: z.number(),\n  is_bargein: z.boolean(),\n  probabilities: z.array(z.number()),\n});\n\nexport type PredictEndpointResponse = z.infer<typeof predictEndpointResponseSchema>;\n\nexport interface PredictResponse {\n  createdAt: number;\n  isBargein: boolean;\n  probabilities: number[];\n  predictionDurationInS: number;\n}\n\nexport async function predictHTTP(\n  data: Int16Array,\n  predictOptions: PredictOptions,\n  options: PostOptions,\n): Promise<Throws<PredictResponse, APIConnectionError | APIStatusError | APIError>> {\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  try {\n    const response = await ofetch(url.toString(), {\n      retry: 0,\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    const { created_at, is_bargein, probabilities } = predictEndpointResponseSchema.parse(response);\n\n    return {\n      createdAt: created_at,\n      isBargein: is_bargein,\n      probabilities,\n      predictionDurationInS: (performance.now() - createdAt) / 1000,\n    };\n  } catch (err) {\n    if (isAPIError(err)) throw err;\n    if (err instanceof FetchError) {\n      if (err.statusCode) {\n        throw new APIStatusError({\n          message: `error during interruption prediction: ${err.message}`,\n          options: { statusCode: err.statusCode, body: err.data },\n        });\n      }\n      if (\n        err.cause instanceof Error &&\n        (err.cause.name === 'TimeoutError' || err.cause.name === 'AbortError')\n      ) {\n        throw new APIStatusError({\n          message: `interruption inference timeout: ${err.message}`,\n          options: { statusCode: 408, retryable: false },\n        });\n      }\n      throw new APIConnectionError({\n        message: `interruption inference connection error: ${err.message}`,\n      });\n    }\n    throw new APIError(`error during interruption prediction: ${err}`);\n  }\n}\n\nexport interface HttpTransportOptions {\n  baseUrl: string;\n  apiKey: string;\n  apiSecret: string;\n  threshold: number;\n  minFrames: number;\n  timeout: number;\n  maxRetries?: number;\n}\n\nexport interface HttpTransportState {\n  overlapSpeechStarted: boolean;\n  overlapSpeechStartedAt: number | undefined;\n  cache: BoundedCache<number, InterruptionCacheEntry>;\n}\n\n/**\n * Creates an HTTP transport TransformStream for interruption detection.\n *\n * This transport receives Int16Array audio slices and outputs InterruptionEvents.\n * Each audio slice triggers an HTTP POST request.\n *\n * @param options - Transport options object. This is read on each request, so mutations\n *                  to threshold/minFrames will be picked up dynamically.\n */\nexport function createHttpTransport(\n  options: HttpTransportOptions,\n  getState: () => HttpTransportState,\n  setState: (partial: Partial<HttpTransportState>) => void,\n  updateUserSpeakingSpan?: (entry: InterruptionCacheEntry) => void,\n  getAndResetNumRequests?: () => number,\n): TransformStream<Int16Array | OverlappingSpeechEvent, OverlappingSpeechEvent> {\n  const logger = log();\n\n  return new TransformStream<Int16Array | OverlappingSpeechEvent, OverlappingSpeechEvent>(\n    {\n      async transform(chunk, controller) {\n        if (!(chunk instanceof Int16Array)) {\n          controller.enqueue(chunk);\n          return;\n        }\n\n        const state = getState();\n        const overlapSpeechStartedAt = state.overlapSpeechStartedAt;\n        if (overlapSpeechStartedAt === undefined || !state.overlapSpeechStarted) return;\n\n        try {\n          const resp = await predictHTTP(\n            chunk,\n            { threshold: options.threshold, minFrames: options.minFrames },\n            {\n              baseUrl: options.baseUrl,\n              timeout: options.timeout,\n              maxRetries: options.maxRetries,\n              token: await createAccessToken(options.apiKey, options.apiSecret),\n            },\n          );\n\n          const { createdAt, isBargein, probabilities, predictionDurationInS } = resp;\n          const entry = state.cache.setOrUpdate(\n            createdAt,\n            () => new InterruptionCacheEntry({ createdAt }),\n            {\n              probabilities,\n              isInterruption: isBargein,\n              speechInput: chunk,\n              totalDurationInS: (performance.now() - createdAt) / 1000,\n              detectionDelayInS: (Date.now() - overlapSpeechStartedAt) / 1000,\n              predictionDurationInS,\n            },\n          );\n\n          if (state.overlapSpeechStarted && entry.isInterruption) {\n            if (updateUserSpeakingSpan) {\n              updateUserSpeakingSpan(entry);\n            }\n            const event: OverlappingSpeechEvent = {\n              type: 'overlapping_speech',\n              detectedAt: Date.now(),\n              overlapStartedAt: overlapSpeechStartedAt,\n              isInterruption: entry.isInterruption,\n              speechInput: entry.speechInput,\n              probabilities: entry.probabilities,\n              totalDurationInS: entry.totalDurationInS,\n              predictionDurationInS: entry.predictionDurationInS,\n              detectionDelayInS: entry.detectionDelayInS,\n              probability: entry.probability,\n              numRequests: getAndResetNumRequests?.() ?? 0,\n            };\n            logger.debug(\n              {\n                detectionDelayInS: entry.detectionDelayInS,\n                totalDurationInS: entry.totalDurationInS,\n              },\n              'interruption detected',\n            );\n            setState({ overlapSpeechStarted: false });\n            controller.enqueue(event);\n          }\n        } catch (err) {\n          controller.error(err);\n        }\n      },\n    },\n    { highWaterMark: 2 },\n    { highWaterMark: 2 },\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/inference/interruption/interruption_cache_entry.cjs

@@ -0,0 +1,58 @@
+"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_cache_entry_exports = {};
+__export(interruption_cache_entry_exports, {
+  InterruptionCacheEntry: () => InterruptionCacheEntry
+});
+module.exports = __toCommonJS(interruption_cache_entry_exports);
+var import_utils = require("./utils.cjs");
+class InterruptionCacheEntry {
+  createdAt;
+  requestStartedAt;
+  totalDurationInS;
+  predictionDurationInS;
+  detectionDelayInS;
+  speechInput;
+  probabilities;
+  isInterruption;
+  constructor(params) {
+    this.createdAt = params.createdAt;
+    this.requestStartedAt = params.requestStartedAt;
+    this.totalDurationInS = params.totalDurationInS ?? 0;
+    this.predictionDurationInS = params.predictionDurationInS ?? 0;
+    this.detectionDelayInS = params.detectionDelayInS ?? 0;
+    this.speechInput = params.speechInput;
+    this.probabilities = params.probabilities;
+    this.isInterruption = params.isInterruption;
+  }
+  /**
+   * The conservative estimated probability of the interruption event.
+   */
+  get probability() {
+    return this.probabilities ? (0, import_utils.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
+});
+//# sourceMappingURL=interruption_cache_entry.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/interruption_cache_entry.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { estimateProbability } from './utils.js';\n\n/**\n * Typed cache entry for interruption inference results.\n * Mutable to support setOrUpdate pattern from Python's _BoundedCache.\n */\nexport class InterruptionCacheEntry {\n  createdAt: number;\n  requestStartedAt?: number;\n  totalDurationInS: number;\n  predictionDurationInS: number;\n  detectionDelayInS: number;\n  speechInput?: Int16Array;\n  probabilities?: number[];\n  isInterruption?: boolean;\n\n  constructor(params: {\n    createdAt: number;\n    requestStartedAt?: number;\n    speechInput?: Int16Array;\n    totalDurationInS?: number;\n    predictionDurationInS?: number;\n    detectionDelayInS?: number;\n    probabilities?: number[];\n    isInterruption?: boolean;\n  }) {\n    this.createdAt = params.createdAt;\n    this.requestStartedAt = params.requestStartedAt;\n    this.totalDurationInS = params.totalDurationInS ?? 0;\n    this.predictionDurationInS = params.predictionDurationInS ?? 0;\n    this.detectionDelayInS = params.detectionDelayInS ?? 0;\n    this.speechInput = params.speechInput;\n    this.probabilities = params.probabilities;\n    this.isInterruption = params.isInterruption;\n  }\n\n  /**\n   * The conservative estimated probability of the interruption event.\n   */\n  get probability(): number {\n    return 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;AAGA,mBAAoC;AAM7B,MAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,QAST;AACD,SAAK,YAAY,OAAO;AACxB,SAAK,mBAAmB,OAAO;AAC/B,SAAK,mBAAmB,OAAO,oBAAoB;AACnD,SAAK,wBAAwB,OAAO,yBAAyB;AAC7D,SAAK,oBAAoB,OAAO,qBAAqB;AACrD,SAAK,cAAc,OAAO;AAC1B,SAAK,gBAAgB,OAAO;AAC5B,SAAK,iBAAiB,OAAO;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,cAAsB;AACxB,WAAO,KAAK,oBAAgB,kCAAoB,KAAK,aAAa,IAAI;AAAA,EACxE;AAAA,EAEA,OAAO,UAAkC;AACvC,WAAO,IAAI,uBAAuB,EAAE,WAAW,EAAE,CAAC;AAAA,EACpD;AACF;","names":[]}

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

@@ -0,0 +1,30 @@
+/**
+ * Typed cache entry for interruption inference results.
+ * Mutable to support setOrUpdate pattern from Python's _BoundedCache.
+ */
+export declare class InterruptionCacheEntry {
+    createdAt: number;
+    requestStartedAt?: number;
+    totalDurationInS: number;
+    predictionDurationInS: number;
+    detectionDelayInS: number;
+    speechInput?: Int16Array;
+    probabilities?: number[];
+    isInterruption?: boolean;
+    constructor(params: {
+        createdAt: number;
+        requestStartedAt?: number;
+        speechInput?: Int16Array;
+        totalDurationInS?: number;
+        predictionDurationInS?: number;
+        detectionDelayInS?: number;
+        probabilities?: number[];
+        isInterruption?: boolean;
+    });
+    /**
+     * The conservative estimated probability of the interruption event.
+     */
+    get probability(): number;
+    static default(): InterruptionCacheEntry;
+}
+//# sourceMappingURL=interruption_cache_entry.d.ts.map

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

@@ -0,0 +1,30 @@
+/**
+ * Typed cache entry for interruption inference results.
+ * Mutable to support setOrUpdate pattern from Python's _BoundedCache.
+ */
+export declare class InterruptionCacheEntry {
+    createdAt: number;
+    requestStartedAt?: number;
+    totalDurationInS: number;
+    predictionDurationInS: number;
+    detectionDelayInS: number;
+    speechInput?: Int16Array;
+    probabilities?: number[];
+    isInterruption?: boolean;
+    constructor(params: {
+        createdAt: number;
+        requestStartedAt?: number;
+        speechInput?: Int16Array;
+        totalDurationInS?: number;
+        predictionDurationInS?: number;
+        detectionDelayInS?: number;
+        probabilities?: number[];
+        isInterruption?: boolean;
+    });
+    /**
+     * The conservative estimated probability of the interruption event.
+     */
+    get probability(): number;
+    static default(): InterruptionCacheEntry;
+}
+//# sourceMappingURL=interruption_cache_entry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interruption_cache_entry.d.ts","sourceRoot":"","sources":["../../../src/inference/interruption/interruption_cache_entry.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,qBAAa,sBAAsB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;gBAEb,MAAM,EAAE;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,WAAW,CAAC,EAAE,UAAU,CAAC;QACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;QACzB,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B;IAWD;;OAEG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,MAAM,CAAC,OAAO,IAAI,sBAAsB;CAGzC"}

package/dist/inference/interruption/interruption_cache_entry.js

@@ -0,0 +1,34 @@
+import { estimateProbability } from "./utils.js";
+class InterruptionCacheEntry {
+  createdAt;
+  requestStartedAt;
+  totalDurationInS;
+  predictionDurationInS;
+  detectionDelayInS;
+  speechInput;
+  probabilities;
+  isInterruption;
+  constructor(params) {
+    this.createdAt = params.createdAt;
+    this.requestStartedAt = params.requestStartedAt;
+    this.totalDurationInS = params.totalDurationInS ?? 0;
+    this.predictionDurationInS = params.predictionDurationInS ?? 0;
+    this.detectionDelayInS = params.detectionDelayInS ?? 0;
+    this.speechInput = params.speechInput;
+    this.probabilities = params.probabilities;
+    this.isInterruption = params.isInterruption;
+  }
+  /**
+   * The conservative estimated probability of the interruption event.
+   */
+  get probability() {
+    return this.probabilities ? estimateProbability(this.probabilities) : 0;
+  }
+  static default() {
+    return new InterruptionCacheEntry({ createdAt: 0 });
+  }
+}
+export {
+  InterruptionCacheEntry
+};
+//# sourceMappingURL=interruption_cache_entry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/interruption_cache_entry.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { estimateProbability } from './utils.js';\n\n/**\n * Typed cache entry for interruption inference results.\n * Mutable to support setOrUpdate pattern from Python's _BoundedCache.\n */\nexport class InterruptionCacheEntry {\n  createdAt: number;\n  requestStartedAt?: number;\n  totalDurationInS: number;\n  predictionDurationInS: number;\n  detectionDelayInS: number;\n  speechInput?: Int16Array;\n  probabilities?: number[];\n  isInterruption?: boolean;\n\n  constructor(params: {\n    createdAt: number;\n    requestStartedAt?: number;\n    speechInput?: Int16Array;\n    totalDurationInS?: number;\n    predictionDurationInS?: number;\n    detectionDelayInS?: number;\n    probabilities?: number[];\n    isInterruption?: boolean;\n  }) {\n    this.createdAt = params.createdAt;\n    this.requestStartedAt = params.requestStartedAt;\n    this.totalDurationInS = params.totalDurationInS ?? 0;\n    this.predictionDurationInS = params.predictionDurationInS ?? 0;\n    this.detectionDelayInS = params.detectionDelayInS ?? 0;\n    this.speechInput = params.speechInput;\n    this.probabilities = params.probabilities;\n    this.isInterruption = params.isInterruption;\n  }\n\n  /**\n   * The conservative estimated probability of the interruption event.\n   */\n  get probability(): number {\n    return this.probabilities ? estimateProbability(this.probabilities) : 0;\n  }\n\n  static default(): InterruptionCacheEntry {\n    return new InterruptionCacheEntry({ createdAt: 0 });\n  }\n}\n"],"mappings":"AAGA,SAAS,2BAA2B;AAM7B,MAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,QAST;AACD,SAAK,YAAY,OAAO;AACxB,SAAK,mBAAmB,OAAO;AAC/B,SAAK,mBAAmB,OAAO,oBAAoB;AACnD,SAAK,wBAAwB,OAAO,yBAAyB;AAC7D,SAAK,oBAAoB,OAAO,qBAAqB;AACrD,SAAK,cAAc,OAAO;AAC1B,SAAK,gBAAgB,OAAO;AAC5B,SAAK,iBAAiB,OAAO;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,cAAsB;AACxB,WAAO,KAAK,gBAAgB,oBAAoB,KAAK,aAAa,IAAI;AAAA,EACxE;AAAA,EAEA,OAAO,UAAkC;AACvC,WAAO,IAAI,uBAAuB,EAAE,WAAW,EAAE,CAAC;AAAA,EACpD;AACF;","names":[]}

package/dist/inference/interruption/interruption_detector.cjs

@@ -0,0 +1,198 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var interruption_detector_exports = {};
+__export(interruption_detector_exports, {
+  AdaptiveInterruptionDetector: () => AdaptiveInterruptionDetector
+});
+module.exports = __toCommonJS(interruption_detector_exports);
+var import_events = __toESM(require("events"), 1);
+var import_log = require("../../log.cjs");
+var import_utils = require("../utils.cjs");
+var import_defaults = require("./defaults.cjs");
+var import_errors = require("./errors.cjs");
+var import_interruption_stream = require("./interruption_stream.cjs");
+class AdaptiveInterruptionDetector extends import_events.default {
+  options;
+  _label;
+  logger = (0, import_log.log)();
+  // Use Set instead of WeakSet to allow iteration for propagating option updates
+  streams = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    super();
+    const {
+      maxAudioDurationInS,
+      baseUrl,
+      apiKey,
+      apiSecret,
+      audioPrefixDurationInS,
+      threshold,
+      detectionIntervalInS,
+      inferenceTimeout,
+      minInterruptionDurationInS
+    } = { ...import_defaults.interruptionOptionDefaults, ...options };
+    if (maxAudioDurationInS > 3) {
+      throw new RangeError("maxAudioDurationInS must be less than or equal to 3.0 seconds");
+    }
+    const lkBaseUrl = baseUrl ?? process.env.LIVEKIT_REMOTE_EOT_URL ?? (0, import_utils.getDefaultInferenceUrl)();
+    let lkApiKey = apiKey ?? "";
+    let lkApiSecret = apiSecret ?? "";
+    let useProxy;
+    const isInferenceUrl = lkBaseUrl === import_utils.DEFAULT_INFERENCE_URL || lkBaseUrl === import_utils.STAGING_INFERENCE_URL;
+    if (isInferenceUrl) {
+      lkApiKey = apiKey ?? process.env.LIVEKIT_INFERENCE_API_KEY ?? process.env.LIVEKIT_API_KEY ?? "";
+      if (!lkApiKey) {
+        throw new TypeError(
+          "apiKey is required, either as argument or set LIVEKIT_API_KEY environmental variable"
+        );
+      }
+      lkApiSecret = apiSecret ?? process.env.LIVEKIT_INFERENCE_API_SECRET ?? process.env.LIVEKIT_API_SECRET ?? "";
+      if (!lkApiSecret) {
+        throw new TypeError(
+          "apiSecret is required, either as argument or set LIVEKIT_API_SECRET environmental variable"
+        );
+      }
+      useProxy = true;
+    } else {
+      useProxy = false;
+    }
+    const transport = useProxy ? "websocket" : "http";
+    this.logger.debug(
+      {
+        baseUrl: lkBaseUrl,
+        useProxy,
+        transport
+      },
+      "=== Resolved interruption detector transport configuration"
+    );
+    this.options = {
+      sampleRate: import_defaults.SAMPLE_RATE,
+      threshold,
+      minFrames: Math.ceil(minInterruptionDurationInS * import_defaults.FRAMES_PER_SECOND),
+      maxAudioDurationInS,
+      audioPrefixDurationInS,
+      detectionIntervalInS,
+      inferenceTimeout,
+      baseUrl: lkBaseUrl,
+      apiKey: lkApiKey,
+      apiSecret: lkApiSecret,
+      useProxy,
+      minInterruptionDurationInS
+    };
+    this._label = `${this.constructor.name}`;
+    this.logger.debug(
+      {
+        baseUrl: this.options.baseUrl,
+        detectionIntervalInS: this.options.detectionIntervalInS,
+        audioPrefixDurationInS: this.options.audioPrefixDurationInS,
+        maxAudioDurationInS: this.options.maxAudioDurationInS,
+        minFrames: this.options.minFrames,
+        threshold: this.options.threshold,
+        inferenceTimeout: this.options.inferenceTimeout,
+        useProxy: this.options.useProxy,
+        transport
+      },
+      "=== Adaptive interruption detector initialized"
+    );
+  }
+  /**
+   * The model identifier for this detector.
+   */
+  get model() {
+    return "adaptive interruption";
+  }
+  /**
+   * The provider identifier for this detector.
+   */
+  get provider() {
+    return "livekit";
+  }
+  /**
+   * The label for this detector instance.
+   */
+  get label() {
+    return this._label;
+  }
+  /**
+   * The sample rate used for audio processing.
+   */
+  get sampleRate() {
+    return this.options.sampleRate;
+  }
+  /**
+   * Emit an error event from the detector.
+   */
+  emitError(error) {
+    this.emit("error", error);
+  }
+  /**
+   * Creates a new InterruptionStreamBase for internal use.
+   * The stream can receive audio frames and sentinels via pushFrame().
+   * Use this when you need direct access to the stream for pushing frames.
+   */
+  createStream() {
+    try {
+      const streamBase = new import_interruption_stream.InterruptionStreamBase(this, {});
+      this.streams.add(streamBase);
+      return streamBase;
+    } catch (e) {
+      const cause = e instanceof Error ? e : new Error(String(e));
+      this.emitError(new import_errors.InterruptionDetectionError(cause.message, Date.now(), this._label, false));
+      throw e;
+    }
+  }
+  /**
+   * Remove a stream from tracking (called when stream is closed).
+   */
+  removeStream(stream) {
+    this.streams.delete(stream);
+  }
+  /**
+   * Update options for the detector and propagate to all active streams.
+   * For WebSocket streams, this triggers a reconnection with new settings.
+   */
+  async updateOptions(options) {
+    if (options.threshold !== void 0) {
+      this.options.threshold = options.threshold;
+    }
+    if (options.minInterruptionDurationInS !== void 0) {
+      this.options.minInterruptionDurationInS = options.minInterruptionDurationInS;
+      this.options.minFrames = Math.ceil(options.minInterruptionDurationInS * import_defaults.FRAMES_PER_SECOND);
+    }
+    const updatePromises = [];
+    for (const stream of this.streams) {
+      updatePromises.push(stream.updateOptions(options));
+    }
+    await Promise.all(updatePromises);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdaptiveInterruptionDetector
+});
+//# sourceMappingURL=interruption_detector.cjs.map

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

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