@livekit/agents 1.1.0 → 1.2.0

package/dist/inference/index.js

@@ -1,15 +1,30 @@
 import * as llm from "./llm.js";
 import * as stt from "./stt.js";
 import * as tts from "./tts.js";
-import { LLM, LLMStream } from "./llm.js";
-import { STT } from "./stt.js";
-import { TTS } from "./tts.js";
+import {
+  LLM,
+  LLMStream
+} from "./llm.js";
+import {
+  normalizeSTTFallback,
+  parseSTTModelString,
+  STT
+} from "./stt.js";
+import {
+  normalizeTTSFallback,
+  parseTTSModelString,
+  TTS
+} from "./tts.js";
 export {
   LLM,
   LLMStream,
   STT,
   TTS,
   llm,
+  normalizeSTTFallback,
+  normalizeTTSFallback,
+  parseSTTModelString,
+  parseTTSModelString,
   stt,
   tts
 };

package/dist/inference/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/inference/index.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2025 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport * as llm from './llm.js';\nimport * as stt from './stt.js';\nimport * as tts from './tts.js';\n\nexport { LLM, LLMStream, type AzureModels, type LLMModels, type LLMOptions } from './llm.js';\nexport type { GatewayOptions, InferenceLLMOptions } from './llm.js';\nexport { STT, type STTLanguages, type STTModels, type STTOptions } from './stt.js';\nexport { TTS, type TTSModels, type TTSOptions } from './tts.js';\nexport { llm, stt, tts };\n"],"mappings":"AAGA,YAAY,SAAS;AACrB,YAAY,SAAS;AACrB,YAAY,SAAS;AAErB,SAAS,KAAK,iBAAoE;AAElF,SAAS,WAA+D;AACxE,SAAS,WAA4C;","names":[]}
+{"version":3,"sources":["../../src/inference/index.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2025 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport * as llm from './llm.js';\nimport * as stt from './stt.js';\nimport * as tts from './tts.js';\n\nexport {\n  LLM,\n  LLMStream,\n  type ChatCompletionOptions,\n  type GatewayOptions,\n  type InferenceLLMOptions,\n  type LLMModels,\n} from './llm.js';\n\nexport {\n  normalizeSTTFallback,\n  parseSTTModelString,\n  STT,\n  type STTFallbackModel,\n  type STTFallbackModelType,\n  type STTLanguages,\n  type STTModels,\n  type ModelWithLanguage as STTModelString,\n  type STTOptions,\n} from './stt.js';\n\nexport {\n  normalizeTTSFallback,\n  parseTTSModelString,\n  TTS,\n  type TTSFallbackModel,\n  type TTSFallbackModelType,\n  type TTSModels,\n  type ModelWithVoice as TTSModelString,\n  type TTSOptions,\n} from './tts.js';\n\nexport { llm, stt, tts };\n"],"mappings":"AAGA,YAAY,SAAS;AACrB,YAAY,SAAS;AACrB,YAAY,SAAS;AAErB;AAAA,EACE;AAAA,EACA;AAAA,OAKK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAOK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAMK;","names":[]}

package/dist/inference/interruption/defaults.cjs

@@ -0,0 +1,81 @@
+"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 defaults_exports = {};
+__export(defaults_exports, {
+  AUDIO_PREFIX_DURATION_IN_S: () => AUDIO_PREFIX_DURATION_IN_S,
+  DETECTION_INTERVAL_IN_S: () => DETECTION_INTERVAL_IN_S,
+  FRAMES_PER_SECOND: () => FRAMES_PER_SECOND,
+  FRAME_DURATION_IN_S: () => FRAME_DURATION_IN_S,
+  MAX_AUDIO_DURATION_IN_S: () => MAX_AUDIO_DURATION_IN_S,
+  MIN_INTERRUPTION_DURATION_IN_S: () => MIN_INTERRUPTION_DURATION_IN_S,
+  REMOTE_INFERENCE_TIMEOUT_IN_S: () => REMOTE_INFERENCE_TIMEOUT_IN_S,
+  SAMPLE_RATE: () => SAMPLE_RATE,
+  THRESHOLD: () => THRESHOLD,
+  apiConnectDefaults: () => apiConnectDefaults,
+  interruptionOptionDefaults: () => interruptionOptionDefaults,
+  intervalForRetry: () => intervalForRetry
+});
+module.exports = __toCommonJS(defaults_exports);
+const MIN_INTERRUPTION_DURATION_IN_S = 0.025 * 2;
+const THRESHOLD = 0.5;
+const MAX_AUDIO_DURATION_IN_S = 3;
+const AUDIO_PREFIX_DURATION_IN_S = 0.5;
+const DETECTION_INTERVAL_IN_S = 0.1;
+const REMOTE_INFERENCE_TIMEOUT_IN_S = 0.7;
+const SAMPLE_RATE = 16e3;
+const FRAMES_PER_SECOND = 40;
+const FRAME_DURATION_IN_S = 0.025;
+const apiConnectDefaults = {
+  maxRetries: 3,
+  retryInterval: 2e3,
+  timeout: 1e4
+};
+function intervalForRetry(attempt, baseInterval = apiConnectDefaults.retryInterval) {
+  const exponentialDelay = baseInterval * Math.pow(2, attempt);
+  const jitter = exponentialDelay * Math.random() * 0.25;
+  return exponentialDelay + jitter;
+}
+const interruptionOptionDefaults = {
+  sampleRate: SAMPLE_RATE,
+  threshold: THRESHOLD,
+  minFrames: Math.ceil(MIN_INTERRUPTION_DURATION_IN_S * FRAMES_PER_SECOND),
+  maxAudioDurationInS: MAX_AUDIO_DURATION_IN_S,
+  audioPrefixDurationInS: AUDIO_PREFIX_DURATION_IN_S,
+  detectionIntervalInS: DETECTION_INTERVAL_IN_S,
+  inferenceTimeout: REMOTE_INFERENCE_TIMEOUT_IN_S * 1e3,
+  apiKey: process.env.LIVEKIT_API_KEY || "",
+  apiSecret: process.env.LIVEKIT_API_SECRET || "",
+  minInterruptionDurationInS: MIN_INTERRUPTION_DURATION_IN_S
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUDIO_PREFIX_DURATION_IN_S,
+  DETECTION_INTERVAL_IN_S,
+  FRAMES_PER_SECOND,
+  FRAME_DURATION_IN_S,
+  MAX_AUDIO_DURATION_IN_S,
+  MIN_INTERRUPTION_DURATION_IN_S,
+  REMOTE_INFERENCE_TIMEOUT_IN_S,
+  SAMPLE_RATE,
+  THRESHOLD,
+  apiConnectDefaults,
+  interruptionOptionDefaults,
+  intervalForRetry
+});
+//# sourceMappingURL=defaults.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/defaults.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { ApiConnectOptions } from './interruption_stream.js';\nimport type { InterruptionOptions } from './types.js';\n\nexport const MIN_INTERRUPTION_DURATION_IN_S = 0.025 * 2; // 25ms per frame, 2 consecutive frames\nexport const THRESHOLD = 0.5;\nexport const MAX_AUDIO_DURATION_IN_S = 3.0;\nexport const AUDIO_PREFIX_DURATION_IN_S = 0.5;\nexport const DETECTION_INTERVAL_IN_S = 0.1;\nexport const REMOTE_INFERENCE_TIMEOUT_IN_S = 0.7;\nexport const SAMPLE_RATE = 16000;\nexport const FRAMES_PER_SECOND = 40;\nexport const FRAME_DURATION_IN_S = 0.025; // 25ms per frame\n\nexport const apiConnectDefaults: ApiConnectOptions = {\n  maxRetries: 3,\n  retryInterval: 2_000,\n  timeout: 10_000,\n} as const;\n\n/**\n * Calculate the retry interval using exponential backoff with jitter.\n * Matches the Python implementation's _interval_for_retry behavior.\n */\nexport function intervalForRetry(\n  attempt: number,\n  baseInterval: number = apiConnectDefaults.retryInterval,\n): number {\n  // Exponential backoff: baseInterval * 2^attempt with some jitter\n  const exponentialDelay = baseInterval * Math.pow(2, attempt);\n  // Add jitter (0-25% of the delay)\n  const jitter = exponentialDelay * Math.random() * 0.25;\n  return exponentialDelay + jitter;\n}\n\n// baseUrl and useProxy are resolved dynamically in the constructor\n// to respect LIVEKIT_REMOTE_EOT_URL environment variable\nexport const interruptionOptionDefaults: Omit<InterruptionOptions, 'baseUrl' | 'useProxy'> = {\n  sampleRate: SAMPLE_RATE,\n  threshold: THRESHOLD,\n  minFrames: Math.ceil(MIN_INTERRUPTION_DURATION_IN_S * FRAMES_PER_SECOND),\n  maxAudioDurationInS: MAX_AUDIO_DURATION_IN_S,\n  audioPrefixDurationInS: AUDIO_PREFIX_DURATION_IN_S,\n  detectionIntervalInS: DETECTION_INTERVAL_IN_S,\n  inferenceTimeout: REMOTE_INFERENCE_TIMEOUT_IN_S * 1_000,\n  apiKey: process.env.LIVEKIT_API_KEY || '',\n  apiSecret: process.env.LIVEKIT_API_SECRET || '',\n  minInterruptionDurationInS: MIN_INTERRUPTION_DURATION_IN_S,\n} as const;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMO,MAAM,iCAAiC,QAAQ;AAC/C,MAAM,YAAY;AAClB,MAAM,0BAA0B;AAChC,MAAM,6BAA6B;AACnC,MAAM,0BAA0B;AAChC,MAAM,gCAAgC;AACtC,MAAM,cAAc;AACpB,MAAM,oBAAoB;AAC1B,MAAM,sBAAsB;AAE5B,MAAM,qBAAwC;AAAA,EACnD,YAAY;AAAA,EACZ,eAAe;AAAA,EACf,SAAS;AACX;AAMO,SAAS,iBACd,SACA,eAAuB,mBAAmB,eAClC;AAER,QAAM,mBAAmB,eAAe,KAAK,IAAI,GAAG,OAAO;AAE3D,QAAM,SAAS,mBAAmB,KAAK,OAAO,IAAI;AAClD,SAAO,mBAAmB;AAC5B;AAIO,MAAM,6BAAgF;AAAA,EAC3F,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,WAAW,KAAK,KAAK,iCAAiC,iBAAiB;AAAA,EACvE,qBAAqB;AAAA,EACrB,wBAAwB;AAAA,EACxB,sBAAsB;AAAA,EACtB,kBAAkB,gCAAgC;AAAA,EAClD,QAAQ,QAAQ,IAAI,mBAAmB;AAAA,EACvC,WAAW,QAAQ,IAAI,sBAAsB;AAAA,EAC7C,4BAA4B;AAC9B;","names":[]}

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

@@ -0,0 +1,19 @@
+import type { ApiConnectOptions } from './interruption_stream.js';
+import type { InterruptionOptions } from './types.js';
+export declare const MIN_INTERRUPTION_DURATION_IN_S: number;
+export declare const THRESHOLD = 0.5;
+export declare const MAX_AUDIO_DURATION_IN_S = 3;
+export declare const AUDIO_PREFIX_DURATION_IN_S = 0.5;
+export declare const DETECTION_INTERVAL_IN_S = 0.1;
+export declare const REMOTE_INFERENCE_TIMEOUT_IN_S = 0.7;
+export declare const SAMPLE_RATE = 16000;
+export declare const FRAMES_PER_SECOND = 40;
+export declare const FRAME_DURATION_IN_S = 0.025;
+export declare const apiConnectDefaults: ApiConnectOptions;
+/**
+ * Calculate the retry interval using exponential backoff with jitter.
+ * Matches the Python implementation's _interval_for_retry behavior.
+ */
+export declare function intervalForRetry(attempt: number, baseInterval?: number): number;
+export declare const interruptionOptionDefaults: Omit<InterruptionOptions, 'baseUrl' | 'useProxy'>;
+//# sourceMappingURL=defaults.d.ts.map

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

@@ -0,0 +1,19 @@
+import type { ApiConnectOptions } from './interruption_stream.js';
+import type { InterruptionOptions } from './types.js';
+export declare const MIN_INTERRUPTION_DURATION_IN_S: number;
+export declare const THRESHOLD = 0.5;
+export declare const MAX_AUDIO_DURATION_IN_S = 3;
+export declare const AUDIO_PREFIX_DURATION_IN_S = 0.5;
+export declare const DETECTION_INTERVAL_IN_S = 0.1;
+export declare const REMOTE_INFERENCE_TIMEOUT_IN_S = 0.7;
+export declare const SAMPLE_RATE = 16000;
+export declare const FRAMES_PER_SECOND = 40;
+export declare const FRAME_DURATION_IN_S = 0.025;
+export declare const apiConnectDefaults: ApiConnectOptions;
+/**
+ * Calculate the retry interval using exponential backoff with jitter.
+ * Matches the Python implementation's _interval_for_retry behavior.
+ */
+export declare function intervalForRetry(attempt: number, baseInterval?: number): number;
+export declare const interruptionOptionDefaults: Omit<InterruptionOptions, 'baseUrl' | 'useProxy'>;
+//# sourceMappingURL=defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/inference/interruption/defaults.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,eAAO,MAAM,8BAA8B,QAAY,CAAC;AACxD,eAAO,MAAM,SAAS,MAAM,CAAC;AAC7B,eAAO,MAAM,uBAAuB,IAAM,CAAC;AAC3C,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAC3C,eAAO,MAAM,6BAA6B,MAAM,CAAC;AACjD,eAAO,MAAM,WAAW,QAAQ,CAAC;AACjC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,mBAAmB,QAAQ,CAAC;AAEzC,eAAO,MAAM,kBAAkB,EAAE,iBAIvB,CAAC;AAEX;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,YAAY,GAAE,MAAyC,GACtD,MAAM,CAMR;AAID,eAAO,MAAM,0BAA0B,EAAE,IAAI,CAAC,mBAAmB,EAAE,SAAS,GAAG,UAAU,CAW/E,CAAC"}

package/dist/inference/interruption/defaults.js

@@ -0,0 +1,46 @@
+const MIN_INTERRUPTION_DURATION_IN_S = 0.025 * 2;
+const THRESHOLD = 0.5;
+const MAX_AUDIO_DURATION_IN_S = 3;
+const AUDIO_PREFIX_DURATION_IN_S = 0.5;
+const DETECTION_INTERVAL_IN_S = 0.1;
+const REMOTE_INFERENCE_TIMEOUT_IN_S = 0.7;
+const SAMPLE_RATE = 16e3;
+const FRAMES_PER_SECOND = 40;
+const FRAME_DURATION_IN_S = 0.025;
+const apiConnectDefaults = {
+  maxRetries: 3,
+  retryInterval: 2e3,
+  timeout: 1e4
+};
+function intervalForRetry(attempt, baseInterval = apiConnectDefaults.retryInterval) {
+  const exponentialDelay = baseInterval * Math.pow(2, attempt);
+  const jitter = exponentialDelay * Math.random() * 0.25;
+  return exponentialDelay + jitter;
+}
+const interruptionOptionDefaults = {
+  sampleRate: SAMPLE_RATE,
+  threshold: THRESHOLD,
+  minFrames: Math.ceil(MIN_INTERRUPTION_DURATION_IN_S * FRAMES_PER_SECOND),
+  maxAudioDurationInS: MAX_AUDIO_DURATION_IN_S,
+  audioPrefixDurationInS: AUDIO_PREFIX_DURATION_IN_S,
+  detectionIntervalInS: DETECTION_INTERVAL_IN_S,
+  inferenceTimeout: REMOTE_INFERENCE_TIMEOUT_IN_S * 1e3,
+  apiKey: process.env.LIVEKIT_API_KEY || "",
+  apiSecret: process.env.LIVEKIT_API_SECRET || "",
+  minInterruptionDurationInS: MIN_INTERRUPTION_DURATION_IN_S
+};
+export {
+  AUDIO_PREFIX_DURATION_IN_S,
+  DETECTION_INTERVAL_IN_S,
+  FRAMES_PER_SECOND,
+  FRAME_DURATION_IN_S,
+  MAX_AUDIO_DURATION_IN_S,
+  MIN_INTERRUPTION_DURATION_IN_S,
+  REMOTE_INFERENCE_TIMEOUT_IN_S,
+  SAMPLE_RATE,
+  THRESHOLD,
+  apiConnectDefaults,
+  interruptionOptionDefaults,
+  intervalForRetry
+};
+//# sourceMappingURL=defaults.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/defaults.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { ApiConnectOptions } from './interruption_stream.js';\nimport type { InterruptionOptions } from './types.js';\n\nexport const MIN_INTERRUPTION_DURATION_IN_S = 0.025 * 2; // 25ms per frame, 2 consecutive frames\nexport const THRESHOLD = 0.5;\nexport const MAX_AUDIO_DURATION_IN_S = 3.0;\nexport const AUDIO_PREFIX_DURATION_IN_S = 0.5;\nexport const DETECTION_INTERVAL_IN_S = 0.1;\nexport const REMOTE_INFERENCE_TIMEOUT_IN_S = 0.7;\nexport const SAMPLE_RATE = 16000;\nexport const FRAMES_PER_SECOND = 40;\nexport const FRAME_DURATION_IN_S = 0.025; // 25ms per frame\n\nexport const apiConnectDefaults: ApiConnectOptions = {\n  maxRetries: 3,\n  retryInterval: 2_000,\n  timeout: 10_000,\n} as const;\n\n/**\n * Calculate the retry interval using exponential backoff with jitter.\n * Matches the Python implementation's _interval_for_retry behavior.\n */\nexport function intervalForRetry(\n  attempt: number,\n  baseInterval: number = apiConnectDefaults.retryInterval,\n): number {\n  // Exponential backoff: baseInterval * 2^attempt with some jitter\n  const exponentialDelay = baseInterval * Math.pow(2, attempt);\n  // Add jitter (0-25% of the delay)\n  const jitter = exponentialDelay * Math.random() * 0.25;\n  return exponentialDelay + jitter;\n}\n\n// baseUrl and useProxy are resolved dynamically in the constructor\n// to respect LIVEKIT_REMOTE_EOT_URL environment variable\nexport const interruptionOptionDefaults: Omit<InterruptionOptions, 'baseUrl' | 'useProxy'> = {\n  sampleRate: SAMPLE_RATE,\n  threshold: THRESHOLD,\n  minFrames: Math.ceil(MIN_INTERRUPTION_DURATION_IN_S * FRAMES_PER_SECOND),\n  maxAudioDurationInS: MAX_AUDIO_DURATION_IN_S,\n  audioPrefixDurationInS: AUDIO_PREFIX_DURATION_IN_S,\n  detectionIntervalInS: DETECTION_INTERVAL_IN_S,\n  inferenceTimeout: REMOTE_INFERENCE_TIMEOUT_IN_S * 1_000,\n  apiKey: process.env.LIVEKIT_API_KEY || '',\n  apiSecret: process.env.LIVEKIT_API_SECRET || '',\n  minInterruptionDurationInS: MIN_INTERRUPTION_DURATION_IN_S,\n} as const;\n"],"mappings":"AAMO,MAAM,iCAAiC,QAAQ;AAC/C,MAAM,YAAY;AAClB,MAAM,0BAA0B;AAChC,MAAM,6BAA6B;AACnC,MAAM,0BAA0B;AAChC,MAAM,gCAAgC;AACtC,MAAM,cAAc;AACpB,MAAM,oBAAoB;AAC1B,MAAM,sBAAsB;AAE5B,MAAM,qBAAwC;AAAA,EACnD,YAAY;AAAA,EACZ,eAAe;AAAA,EACf,SAAS;AACX;AAMO,SAAS,iBACd,SACA,eAAuB,mBAAmB,eAClC;AAER,QAAM,mBAAmB,eAAe,KAAK,IAAI,GAAG,OAAO;AAE3D,QAAM,SAAS,mBAAmB,KAAK,OAAO,IAAI;AAClD,SAAO,mBAAmB;AAC5B;AAIO,MAAM,6BAAgF;AAAA,EAC3F,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,WAAW,KAAK,KAAK,iCAAiC,iBAAiB;AAAA,EACvE,qBAAqB;AAAA,EACrB,wBAAwB;AAAA,EACxB,sBAAsB;AAAA,EACtB,kBAAkB,gCAAgC;AAAA,EAClD,QAAQ,QAAQ,IAAI,mBAAmB;AAAA,EACvC,WAAW,QAAQ,IAAI,sBAAsB;AAAA,EAC7C,4BAA4B;AAC9B;","names":[]}

package/dist/inference/interruption/errors.cjs

@@ -0,0 +1,44 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  InterruptionDetectionError: () => InterruptionDetectionError
+});
+module.exports = __toCommonJS(errors_exports);
+class InterruptionDetectionError extends Error {
+  type = "interruption_detection_error";
+  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})`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InterruptionDetectionError
+});
+//# sourceMappingURL=errors.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/errors.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\n/**\n * Error thrown during interruption detection.\n */\nexport class InterruptionDetectionError extends Error {\n  readonly type = 'interruption_detection_error' as const;\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"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMO,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;","names":[]}

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

@@ -0,0 +1,12 @@
+/**
+ * Error thrown during interruption detection.
+ */
+export declare class InterruptionDetectionError extends Error {
+    readonly type: "interruption_detection_error";
+    readonly timestamp: number;
+    readonly label: string;
+    readonly recoverable: boolean;
+    constructor(message: string, timestamp: number, label: string, recoverable: boolean);
+    toString(): string;
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,12 @@
+/**
+ * Error thrown during interruption detection.
+ */
+export declare class InterruptionDetectionError extends Error {
+    readonly type: "interruption_detection_error";
+    readonly timestamp: number;
+    readonly label: string;
+    readonly recoverable: boolean;
+    constructor(message: string, timestamp: number, label: string, recoverable: boolean);
+    toString(): string;
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/inference/interruption/errors.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;IACnD,QAAQ,CAAC,IAAI,iCAA2C;IAExD,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"}

package/dist/inference/interruption/errors.js

@@ -0,0 +1,20 @@
+class InterruptionDetectionError extends Error {
+  type = "interruption_detection_error";
+  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})`;
+  }
+}
+export {
+  InterruptionDetectionError
+};
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/inference/interruption/errors.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2026 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\n/**\n * Error thrown during interruption detection.\n */\nexport class InterruptionDetectionError extends Error {\n  readonly type = 'interruption_detection_error' as const;\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"],"mappings":"AAMO,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;","names":[]}

package/dist/inference/interruption/http_transport.cjs

@@ -0,0 +1,163 @@
+"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 http_transport_exports = {};
+__export(http_transport_exports, {
+  createHttpTransport: () => createHttpTransport,
+  predictEndpointResponseSchema: () => predictEndpointResponseSchema,
+  predictHTTP: () => predictHTTP
+});
+module.exports = __toCommonJS(http_transport_exports);
+var import_ofetch = require("ofetch");
+var import_web = require("stream/web");
+var import_zod = require("zod");
+var import_exceptions = require("../../_exceptions.cjs");
+var import_log = require("../../log.cjs");
+var import_utils = require("../utils.cjs");
+var import_interruption_cache_entry = require("./interruption_cache_entry.cjs");
+const predictEndpointResponseSchema = import_zod.z.object({
+  created_at: import_zod.z.number(),
+  is_bargein: import_zod.z.boolean(),
+  probabilities: import_zod.z.array(import_zod.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 (0, import_ofetch.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 ((0, import_exceptions.isAPIError)(err)) throw err;
+    if (err instanceof import_ofetch.FetchError) {
+      if (err.statusCode) {
+        throw new import_exceptions.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 import_exceptions.APIStatusError({
+          message: `interruption inference timeout: ${err.message}`,
+          options: { statusCode: 408, retryable: false }
+        });
+      }
+      throw new import_exceptions.APIConnectionError({
+        message: `interruption inference connection error: ${err.message}`
+      });
+    }
+    throw new import_exceptions.APIError(`error during interruption prediction: ${err}`);
+  }
+}
+function createHttpTransport(options, getState, setState, updateUserSpeakingSpan, getAndResetNumRequests) {
+  const logger = (0, import_log.log)();
+  return new import_web.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 (0, import_utils.createAccessToken)(options.apiKey, options.apiSecret)
+            }
+          );
+          const { createdAt, isBargein, probabilities, predictionDurationInS } = resp;
+          const entry = state.cache.setOrUpdate(
+            createdAt,
+            () => new import_interruption_cache_entry.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 }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createHttpTransport,
+  predictEndpointResponseSchema,
+  predictHTTP
+});
+//# sourceMappingURL=http_transport.cjs.map

package/dist/inference/interruption/http_transport.cjs.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 { 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<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  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/http_transport.d.cts

@@ -0,0 +1,63 @@
+/// <reference types="node" resolution-mode="require"/>
+import { TransformStream } from 'stream/web';
+import { z } from 'zod';
+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<PredictResponse>;
+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

@@ -0,0 +1,63 @@
+/// <reference types="node" resolution-mode="require"/>
+import { TransformStream } from 'stream/web';
+import { z } from 'zod';
+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<PredictResponse>;
+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