@livekit/agents 0.0.0-20260120144724

package/dist/inference/api_protos.d.ts

@@ -0,0 +1,222 @@
+import { z } from 'zod';
+export declare const ttsSessionCreateEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"session.create">;
+    sample_rate: z.ZodString;
+    encoding: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    voice: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    extra: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    transcript: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "session.create";
+    extra: Record<string, unknown>;
+    sample_rate: string;
+    encoding: string;
+    language?: string | undefined;
+    model?: string | undefined;
+    transcript?: string | undefined;
+    voice?: string | undefined;
+}, {
+    type: "session.create";
+    extra: Record<string, unknown>;
+    sample_rate: string;
+    encoding: string;
+    language?: string | undefined;
+    model?: string | undefined;
+    transcript?: string | undefined;
+    voice?: string | undefined;
+}>;
+export declare const ttsInputTranscriptEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"input_transcript">;
+    transcript: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "input_transcript";
+    transcript: string;
+}, {
+    type: "input_transcript";
+    transcript: string;
+}>;
+export declare const ttsSessionFlushEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"session.flush">;
+}, "strip", z.ZodTypeAny, {
+    type: "session.flush";
+}, {
+    type: "session.flush";
+}>;
+export declare const ttsSessionCloseEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"session.close">;
+}, "strip", z.ZodTypeAny, {
+    type: "session.close";
+}, {
+    type: "session.close";
+}>;
+export declare const ttsSessionCreatedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"session.created">;
+    session_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "session.created";
+    session_id: string;
+}, {
+    type: "session.created";
+    session_id: string;
+}>;
+export declare const ttsOutputAudioEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"output_audio">;
+    audio: z.ZodString;
+    session_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "output_audio";
+    audio: string;
+    session_id: string;
+}, {
+    type: "output_audio";
+    audio: string;
+    session_id: string;
+}>;
+export declare const ttsDoneEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"done">;
+    session_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "done";
+    session_id: string;
+}, {
+    type: "done";
+    session_id: string;
+}>;
+export declare const ttsSessionClosedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"session.closed">;
+    session_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "session.closed";
+    session_id: string;
+}, {
+    type: "session.closed";
+    session_id: string;
+}>;
+export declare const ttsErrorEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    message: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "error";
+    message?: string | undefined;
+    session_id?: string | undefined;
+}, {
+    type: "error";
+    message?: string | undefined;
+    session_id?: string | undefined;
+}>;
+export declare const ttsClientEventSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"session.create">;
+    sample_rate: z.ZodString;
+    encoding: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    voice: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    extra: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    transcript: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "session.create";
+    extra: Record<string, unknown>;
+    sample_rate: string;
+    encoding: string;
+    language?: string | undefined;
+    model?: string | undefined;
+    transcript?: string | undefined;
+    voice?: string | undefined;
+}, {
+    type: "session.create";
+    extra: Record<string, unknown>;
+    sample_rate: string;
+    encoding: string;
+    language?: string | undefined;
+    model?: string | undefined;
+    transcript?: string | undefined;
+    voice?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"input_transcript">;
+    transcript: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "input_transcript";
+    transcript: string;
+}, {
+    type: "input_transcript";
+    transcript: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"session.flush">;
+}, "strip", z.ZodTypeAny, {
+    type: "session.flush";
+}, {
+    type: "session.flush";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"session.close">;
+}, "strip", z.ZodTypeAny, {
+    type: "session.close";
+}, {
+    type: "session.close";
+}>]>;
+export declare const ttsServerEventSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"session.created">;
+    session_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "session.created";
+    session_id: string;
+}, {
+    type: "session.created";
+    session_id: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"output_audio">;
+    audio: z.ZodString;
+    session_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "output_audio";
+    audio: string;
+    session_id: string;
+}, {
+    type: "output_audio";
+    audio: string;
+    session_id: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"done">;
+    session_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "done";
+    session_id: string;
+}, {
+    type: "done";
+    session_id: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"session.closed">;
+    session_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "session.closed";
+    session_id: string;
+}, {
+    type: "session.closed";
+    session_id: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    message: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "error";
+    message?: string | undefined;
+    session_id?: string | undefined;
+}, {
+    type: "error";
+    message?: string | undefined;
+    session_id?: string | undefined;
+}>]>;
+export type TtsSessionCreateEvent = z.infer<typeof ttsSessionCreateEventSchema>;
+export type TtsInputTranscriptEvent = z.infer<typeof ttsInputTranscriptEventSchema>;
+export type TtsSessionFlushEvent = z.infer<typeof ttsSessionFlushEventSchema>;
+export type TtsSessionCloseEvent = z.infer<typeof ttsSessionCloseEventSchema>;
+export type TtsSessionCreatedEvent = z.infer<typeof ttsSessionCreatedEventSchema>;
+export type TtsOutputAudioEvent = z.infer<typeof ttsOutputAudioEventSchema>;
+export type TtsDoneEvent = z.infer<typeof ttsDoneEventSchema>;
+export type TtsSessionClosedEvent = z.infer<typeof ttsSessionClosedEventSchema>;
+export type TtsErrorEvent = z.infer<typeof ttsErrorEventSchema>;
+export type TtsClientEvent = z.infer<typeof ttsClientEventSchema>;
+export type TtsServerEvent = z.infer<typeof ttsServerEventSchema>;
+//# sourceMappingURL=api_protos.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api_protos.d.ts","sourceRoot":"","sources":["../../src/inference/api_protos.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;EAStC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;EAGxC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;EAErC,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;;;EAErC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;EAGvC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;EAIpC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;EAG7B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;EAGtC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAI9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAK/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAM/B,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/inference/api_protos.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+const ttsSessionCreateEventSchema = z.object({
+  type: z.literal("session.create"),
+  sample_rate: z.string(),
+  encoding: z.string(),
+  model: z.string().optional(),
+  voice: z.string().optional(),
+  language: z.string().optional(),
+  extra: z.record(z.string(), z.unknown()),
+  transcript: z.string().optional()
+});
+const ttsInputTranscriptEventSchema = z.object({
+  type: z.literal("input_transcript"),
+  transcript: z.string()
+});
+const ttsSessionFlushEventSchema = z.object({
+  type: z.literal("session.flush")
+});
+const ttsSessionCloseEventSchema = z.object({
+  type: z.literal("session.close")
+});
+const ttsSessionCreatedEventSchema = z.object({
+  type: z.literal("session.created"),
+  session_id: z.string()
+});
+const ttsOutputAudioEventSchema = z.object({
+  type: z.literal("output_audio"),
+  audio: z.string(),
+  session_id: z.string()
+});
+const ttsDoneEventSchema = z.object({
+  type: z.literal("done"),
+  session_id: z.string()
+});
+const ttsSessionClosedEventSchema = z.object({
+  type: z.literal("session.closed"),
+  session_id: z.string()
+});
+const ttsErrorEventSchema = z.object({
+  type: z.literal("error"),
+  message: z.string().optional(),
+  session_id: z.string().optional()
+});
+const ttsClientEventSchema = z.discriminatedUnion("type", [
+  ttsSessionCreateEventSchema,
+  ttsInputTranscriptEventSchema,
+  ttsSessionFlushEventSchema,
+  ttsSessionCloseEventSchema
+]);
+const ttsServerEventSchema = z.discriminatedUnion("type", [
+  ttsSessionCreatedEventSchema,
+  ttsOutputAudioEventSchema,
+  ttsDoneEventSchema,
+  ttsSessionClosedEventSchema,
+  ttsErrorEventSchema
+]);
+export {
+  ttsClientEventSchema,
+  ttsDoneEventSchema,
+  ttsErrorEventSchema,
+  ttsInputTranscriptEventSchema,
+  ttsOutputAudioEventSchema,
+  ttsServerEventSchema,
+  ttsSessionCloseEventSchema,
+  ttsSessionClosedEventSchema,
+  ttsSessionCreateEventSchema,
+  ttsSessionCreatedEventSchema,
+  ttsSessionFlushEventSchema
+};
+//# sourceMappingURL=api_protos.js.map

package/dist/inference/api_protos.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/inference/api_protos.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2025 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport { z } from 'zod';\n\nexport const ttsSessionCreateEventSchema = z.object({\n  type: z.literal('session.create'),\n  sample_rate: z.string(),\n  encoding: z.string(),\n  model: z.string().optional(),\n  voice: z.string().optional(),\n  language: z.string().optional(),\n  extra: z.record(z.string(), z.unknown()),\n  transcript: z.string().optional(),\n});\n\nexport const ttsInputTranscriptEventSchema = z.object({\n  type: z.literal('input_transcript'),\n  transcript: z.string(),\n});\n\nexport const ttsSessionFlushEventSchema = z.object({\n  type: z.literal('session.flush'),\n});\n\nexport const ttsSessionCloseEventSchema = z.object({\n  type: z.literal('session.close'),\n});\n\nexport const ttsSessionCreatedEventSchema = z.object({\n  type: z.literal('session.created'),\n  session_id: z.string(),\n});\n\nexport const ttsOutputAudioEventSchema = z.object({\n  type: z.literal('output_audio'),\n  audio: z.string(),\n  session_id: z.string(),\n});\n\nexport const ttsDoneEventSchema = z.object({\n  type: z.literal('done'),\n  session_id: z.string(),\n});\n\nexport const ttsSessionClosedEventSchema = z.object({\n  type: z.literal('session.closed'),\n  session_id: z.string(),\n});\n\nexport const ttsErrorEventSchema = z.object({\n  type: z.literal('error'),\n  message: z.string().optional(),\n  session_id: z.string().optional(),\n});\n\nexport const ttsClientEventSchema = z.discriminatedUnion('type', [\n  ttsSessionCreateEventSchema,\n  ttsInputTranscriptEventSchema,\n  ttsSessionFlushEventSchema,\n  ttsSessionCloseEventSchema,\n]);\n\nexport const ttsServerEventSchema = z.discriminatedUnion('type', [\n  ttsSessionCreatedEventSchema,\n  ttsOutputAudioEventSchema,\n  ttsDoneEventSchema,\n  ttsSessionClosedEventSchema,\n  ttsErrorEventSchema,\n]);\n\nexport type TtsSessionCreateEvent = z.infer<typeof ttsSessionCreateEventSchema>;\nexport type TtsInputTranscriptEvent = z.infer<typeof ttsInputTranscriptEventSchema>;\nexport type TtsSessionFlushEvent = z.infer<typeof ttsSessionFlushEventSchema>;\nexport type TtsSessionCloseEvent = z.infer<typeof ttsSessionCloseEventSchema>;\nexport type TtsSessionCreatedEvent = z.infer<typeof ttsSessionCreatedEventSchema>;\nexport type TtsOutputAudioEvent = z.infer<typeof ttsOutputAudioEventSchema>;\nexport type TtsDoneEvent = z.infer<typeof ttsDoneEventSchema>;\nexport type TtsSessionClosedEvent = z.infer<typeof ttsSessionClosedEventSchema>;\nexport type TtsErrorEvent = z.infer<typeof ttsErrorEventSchema>;\nexport type TtsClientEvent = z.infer<typeof ttsClientEventSchema>;\nexport type TtsServerEvent = z.infer<typeof ttsServerEventSchema>;\n"],"mappings":"AAGA,SAAS,SAAS;AAEX,MAAM,8BAA8B,EAAE,OAAO;AAAA,EAClD,MAAM,EAAE,QAAQ,gBAAgB;AAAA,EAChC,aAAa,EAAE,OAAO;AAAA,EACtB,UAAU,EAAE,OAAO;AAAA,EACnB,OAAO,EAAE,OAAO,EAAE,SAAS;AAAA,EAC3B,OAAO,EAAE,OAAO,EAAE,SAAS;AAAA,EAC3B,UAAU,EAAE,OAAO,EAAE,SAAS;AAAA,EAC9B,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC;AAAA,EACvC,YAAY,EAAE,OAAO,EAAE,SAAS;AAClC,CAAC;AAEM,MAAM,gCAAgC,EAAE,OAAO;AAAA,EACpD,MAAM,EAAE,QAAQ,kBAAkB;AAAA,EAClC,YAAY,EAAE,OAAO;AACvB,CAAC;AAEM,MAAM,6BAA6B,EAAE,OAAO;AAAA,EACjD,MAAM,EAAE,QAAQ,eAAe;AACjC,CAAC;AAEM,MAAM,6BAA6B,EAAE,OAAO;AAAA,EACjD,MAAM,EAAE,QAAQ,eAAe;AACjC,CAAC;AAEM,MAAM,+BAA+B,EAAE,OAAO;AAAA,EACnD,MAAM,EAAE,QAAQ,iBAAiB;AAAA,EACjC,YAAY,EAAE,OAAO;AACvB,CAAC;AAEM,MAAM,4BAA4B,EAAE,OAAO;AAAA,EAChD,MAAM,EAAE,QAAQ,cAAc;AAAA,EAC9B,OAAO,EAAE,OAAO;AAAA,EAChB,YAAY,EAAE,OAAO;AACvB,CAAC;AAEM,MAAM,qBAAqB,EAAE,OAAO;AAAA,EACzC,MAAM,EAAE,QAAQ,MAAM;AAAA,EACtB,YAAY,EAAE,OAAO;AACvB,CAAC;AAEM,MAAM,8BAA8B,EAAE,OAAO;AAAA,EAClD,MAAM,EAAE,QAAQ,gBAAgB;AAAA,EAChC,YAAY,EAAE,OAAO;AACvB,CAAC;AAEM,MAAM,sBAAsB,EAAE,OAAO;AAAA,EAC1C,MAAM,EAAE,QAAQ,OAAO;AAAA,EACvB,SAAS,EAAE,OAAO,EAAE,SAAS;AAAA,EAC7B,YAAY,EAAE,OAAO,EAAE,SAAS;AAClC,CAAC;AAEM,MAAM,uBAAuB,EAAE,mBAAmB,QAAQ;AAAA,EAC/D;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAEM,MAAM,uBAAuB,EAAE,mBAAmB,QAAQ;AAAA,EAC/D;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;","names":[]}

package/dist/inference/index.cjs

@@ -0,0 +1,56 @@
+"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 inference_exports = {};
+__export(inference_exports, {
+  LLM: () => import_llm.LLM,
+  LLMStream: () => import_llm.LLMStream,
+  STT: () => import_stt.STT,
+  TTS: () => import_tts.TTS,
+  llm: () => llm,
+  stt: () => stt,
+  tts: () => tts
+});
+module.exports = __toCommonJS(inference_exports);
+var llm = __toESM(require("./llm.cjs"), 1);
+var stt = __toESM(require("./stt.cjs"), 1);
+var tts = __toESM(require("./tts.cjs"), 1);
+var import_llm = require("./llm.cjs");
+var import_stt = require("./stt.cjs");
+var import_tts = require("./tts.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LLM,
+  LLMStream,
+  STT,
+  TTS,
+  llm,
+  stt,
+  tts
+});
+//# sourceMappingURL=index.cjs.map

package/dist/inference/index.cjs.map

@@ -0,0 +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 {\n  LLM,\n  LLMStream,\n  type ChatCompletionOptions,\n  type GatewayOptions,\n  type InferenceLLMOptions,\n  type LLMModels,\n} from './llm.js';\n\nexport {\n  STT,\n  type STTLanguages,\n  type STTModels,\n  type ModelWithLanguage as STTModelString,\n  type STTOptions,\n} from './stt.js';\n\nexport {\n  TTS,\n  type TTSModels,\n  type ModelWithVoice as TTSModelString,\n  type TTSOptions,\n} from './tts.js';\n\nexport { llm, stt, tts };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,UAAqB;AACrB,UAAqB;AACrB,UAAqB;AAErB,iBAOO;AAEP,iBAMO;AAEP,iBAKO;","names":[]}

package/dist/inference/index.d.cts

@@ -0,0 +1,8 @@
+import * as llm from './llm.js';
+import * as stt from './stt.js';
+import * as tts from './tts.js';
+export { LLM, LLMStream, type ChatCompletionOptions, type GatewayOptions, type InferenceLLMOptions, type LLMModels, } from './llm.js';
+export { STT, type STTLanguages, type STTModels, type ModelWithLanguage as STTModelString, type STTOptions, } from './stt.js';
+export { TTS, type TTSModels, type ModelWithVoice as TTSModelString, type TTSOptions, } from './tts.js';
+export { llm, stt, tts };
+//# sourceMappingURL=index.d.ts.map

package/dist/inference/index.d.ts

@@ -0,0 +1,8 @@
+import * as llm from './llm.js';
+import * as stt from './stt.js';
+import * as tts from './tts.js';
+export { LLM, LLMStream, type ChatCompletionOptions, type GatewayOptions, type InferenceLLMOptions, type LLMModels, } from './llm.js';
+export { STT, type STTLanguages, type STTModels, type ModelWithLanguage as STTModelString, type STTOptions, } from './stt.js';
+export { TTS, type TTSModels, type ModelWithVoice as TTSModelString, type TTSOptions, } from './tts.js';
+export { llm, stt, tts };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/inference/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAChC,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAChC,OAAO,KAAK,GAAG,MAAM,UAAU,CAAC;AAEhC,OAAO,EACL,GAAG,EACH,SAAS,EACT,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,SAAS,GACf,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,GAAG,EACH,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,iBAAiB,IAAI,cAAc,EACxC,KAAK,UAAU,GAChB,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,GAAG,EACH,KAAK,SAAS,EACd,KAAK,cAAc,IAAI,cAAc,EACrC,KAAK,UAAU,GAChB,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC"}

package/dist/inference/index.js

@@ -0,0 +1,23 @@
+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";
+export {
+  LLM,
+  LLMStream,
+  STT,
+  TTS,
+  llm,
+  stt,
+  tts
+};
+//# sourceMappingURL=index.js.map

package/dist/inference/index.js.map

@@ -0,0 +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 {\n  LLM,\n  LLMStream,\n  type ChatCompletionOptions,\n  type GatewayOptions,\n  type InferenceLLMOptions,\n  type LLMModels,\n} from './llm.js';\n\nexport {\n  STT,\n  type STTLanguages,\n  type STTModels,\n  type ModelWithLanguage as STTModelString,\n  type STTOptions,\n} from './stt.js';\n\nexport {\n  TTS,\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,OAKK;AAEP;AAAA,EACE;AAAA,OAIK;","names":[]}

package/dist/inference/interruption/AdaptiveInterruptionDetector.cjs

@@ -0,0 +1,152 @@
+"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 AdaptiveInterruptionDetector_exports = {};
+__export(AdaptiveInterruptionDetector_exports, {
+  AdaptiveInterruptionDetector: () => AdaptiveInterruptionDetector
+});
+module.exports = __toCommonJS(AdaptiveInterruptionDetector_exports);
+var import_events = __toESM(require("events"), 1);
+var import_web = require("stream/web");
+var import_InterruptionStream = require("./InterruptionStream.cjs");
+var import_defaults = require("./defaults.cjs");
+var import_interruption = require("./interruption.cjs");
+class AdaptiveInterruptionDetector extends import_events.default {
+  options;
+  label;
+  streams;
+  // TODO: Union of InterruptionHttpStream | InterruptionWebSocketStream
+  constructor(options = {}) {
+    super();
+    const {
+      maxAudioDuration,
+      baseUrl,
+      apiKey,
+      apiSecret,
+      useProxy: useProxyArg,
+      audioPrefixDuration,
+      threshold,
+      detectionInterval,
+      inferenceTimeout,
+      minInterruptionDuration
+    } = { ...import_defaults.interruptionOptionDefaults, ...options };
+    if (maxAudioDuration > 3) {
+      throw new Error("maxAudioDuration must be less than or equal to 3.0 seconds");
+    }
+    const lkBaseUrl = baseUrl ?? process.env.LIVEKIT_REMOTE_EOT_URL ?? import_defaults.DEFAULT_BASE_URL;
+    let lkApiKey = apiKey ?? "";
+    let lkApiSecret = apiSecret ?? "";
+    let useProxy;
+    if (lkBaseUrl === import_defaults.DEFAULT_BASE_URL) {
+      lkApiKey = apiKey ?? process.env.LIVEKIT_INFERENCE_API_KEY ?? process.env.LIVEKIT_API_KEY ?? "";
+      if (!lkApiKey) {
+        throw new Error(
+          "apiKey is required, either as argument or set LIVEKIT_API_KEY environmental variable"
+        );
+      }
+      lkApiSecret = apiSecret ?? process.env.LIVEKIT_INFERENCE_API_SECRET ?? process.env.LIVEKIT_API_SECRET ?? "";
+      if (!lkApiSecret) {
+        throw new Error(
+          "apiSecret is required, either as argument or set LIVEKIT_API_SECRET environmental variable"
+        );
+      }
+      useProxy = true;
+    } else {
+      useProxy = useProxyArg ?? false;
+    }
+    this.options = {
+      sampleRate: import_defaults.SAMPLE_RATE,
+      threshold,
+      minFrames: Math.ceil(minInterruptionDuration * import_defaults.FRAMES_PER_SECOND),
+      maxAudioDuration,
+      audioPrefixDuration,
+      detectionInterval,
+      inferenceTimeout,
+      baseUrl: lkBaseUrl,
+      apiKey: lkApiKey,
+      apiSecret: lkApiSecret,
+      useProxy,
+      minInterruptionDuration
+    };
+    this.label = `${this.constructor.name}`;
+    this.streams = /* @__PURE__ */ new WeakSet();
+    console.info("adaptive interruption detector initialized", {
+      baseUrl: this.options.baseUrl,
+      detectionInterval: this.options.detectionInterval,
+      audioPrefixDuration: this.options.audioPrefixDuration,
+      maxAudioDuration: this.options.maxAudioDuration,
+      minFrames: this.options.minFrames,
+      threshold: this.options.threshold,
+      inferenceTimeout: this.options.inferenceTimeout,
+      useProxy: this.options.useProxy
+    });
+  }
+  /**
+   * Creates a new InterruptionStreamBase for internal use.
+   * The stream can receive audio frames and sentinels via pushFrame().
+   * Use this when you need direct access to the stream for pushing frames.
+   */
+  createStream() {
+    const stream = new import_InterruptionStream.InterruptionStreamBase(this, {});
+    this.streams.add(stream);
+    return stream;
+  }
+  /**
+   * Creates a new interruption stream and returns a ReadableStream of InterruptionEvents.
+   * This is a convenience method for consuming interruption events without needing
+   * to manage the underlying stream directly.
+   */
+  stream() {
+    const httpStream = this.createStream();
+    const transformer = new import_web.TransformStream({
+      transform: (chunk, controller) => {
+        if (chunk.type === import_interruption.InterruptionEventType.INTERRUPTION) {
+          this.emit("interruptionDetected");
+        } else if (chunk.type === import_interruption.InterruptionEventType.OVERLAP_SPEECH_ENDED) {
+          this.emit("overlapSpeechDetected");
+        }
+        controller.enqueue(chunk);
+      }
+    });
+    const stream = httpStream.stream.pipeThrough(transformer);
+    return stream;
+  }
+  updateOptions(options) {
+    if (options.threshold !== void 0) {
+      this.options.threshold = options.threshold;
+    }
+    if (options.minInterruptionDuration !== void 0) {
+      this.options.minFrames = Math.ceil(options.minInterruptionDuration * import_defaults.FRAMES_PER_SECOND);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdaptiveInterruptionDetector
+});
+//# sourceMappingURL=AdaptiveInterruptionDetector.cjs.map

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

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

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

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