kugelaudio 0.8.0 → 0.9.0

package/dist/livekit/index.js

@@ -0,0 +1,994 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/livekit/index.ts
+var livekit_exports = {};
+__export(livekit_exports, {
+  ChunkedStream: () => ChunkedStream,
+  DEFAULT_CFG_SCALE: () => DEFAULT_CFG_SCALE,
+  DEFAULT_MAX_NEW_TOKENS: () => DEFAULT_MAX_NEW_TOKENS,
+  DEFAULT_MODEL: () => DEFAULT_MODEL,
+  DEFAULT_SAMPLE_RATE: () => DEFAULT_SAMPLE_RATE,
+  DEFAULT_VOICE_ID: () => DEFAULT_VOICE_ID,
+  SUPPORTED_LANGUAGES: () => SUPPORTED_LANGUAGES,
+  SUPPORTED_SAMPLE_RATES: () => SUPPORTED_SAMPLE_RATES,
+  SynthesizeStream: () => SynthesizeStream,
+  TTS: () => TTS,
+  validateLanguage: () => validateLanguage
+});
+module.exports = __toCommonJS(livekit_exports);
+
+// src/livekit/tts.ts
+var import_agents = require("@livekit/agents");
+var import_ws = require("ws");
+
+// src/errors.ts
+var ErrorCodes = {
+  UNAUTHORIZED: "UNAUTHORIZED",
+  RATE_LIMITED: "RATE_LIMITED",
+  INSUFFICIENT_CREDITS: "INSUFFICIENT_CREDITS",
+  MODEL_UNAVAILABLE: "MODEL_UNAVAILABLE",
+  EMPTY_AUDIO: "EMPTY_AUDIO",
+  VALIDATION: "VALIDATION_ERROR",
+  INTERNAL: "INTERNAL_ERROR",
+  NOT_FOUND: "NOT_FOUND",
+  MISSING_VOICE_ID: "MISSING_VOICE_ID",
+  TOO_MANY_CONTEXTS: "TOO_MANY_CONTEXTS"
+};
+var API_KEYS_URL = "https://app.kugelaudio.com/settings/api-keys";
+var BILLING_URL = "https://app.kugelaudio.com/billing";
+var KugelAudioError = class _KugelAudioError extends Error {
+  constructor(message, options = {}) {
+    super(options.requestId ? `${message} (request_id: ${options.requestId})` : message);
+    this.name = "KugelAudioError";
+    this.statusCode = options.statusCode;
+    this.errorCode = options.errorCode;
+    this.requestId = options.requestId;
+    this.retryAfter = options.retryAfter;
+    Object.setPrototypeOf(this, _KugelAudioError.prototype);
+  }
+};
+var AuthenticationError = class _AuthenticationError extends KugelAudioError {
+  constructor(message, options = {}) {
+    super(
+      message ?? `KugelAudio rejected the API key. Check it is current at ${API_KEYS_URL}.`,
+      { statusCode: 401, errorCode: ErrorCodes.UNAUTHORIZED, ...options }
+    );
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends KugelAudioError {
+  constructor(message, options = {}) {
+    const msg = message ?? (options.retryAfter ? `KugelAudio rate limit hit; retry after ${options.retryAfter}s.` : "KugelAudio rate limit hit; retry shortly.");
+    super(msg, { statusCode: 429, errorCode: ErrorCodes.RATE_LIMITED, ...options });
+    this.name = "RateLimitError";
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var InsufficientCreditsError = class _InsufficientCreditsError extends KugelAudioError {
+  constructor(message, options = {}) {
+    super(
+      message ?? `Your KugelAudio account is out of credits. Top up at ${BILLING_URL}.`,
+      { statusCode: 402, errorCode: ErrorCodes.INSUFFICIENT_CREDITS, ...options }
+    );
+    this.name = "InsufficientCreditsError";
+    Object.setPrototypeOf(this, _InsufficientCreditsError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends KugelAudioError {
+  constructor(message, options = {}) {
+    super(message, { statusCode: 400, errorCode: ErrorCodes.VALIDATION, ...options });
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var ConnectionError = class _ConnectionError extends KugelAudioError {
+  constructor(message, options = {}) {
+    super(message, { statusCode: 503, ...options });
+    this.name = "ConnectionError";
+    Object.setPrototypeOf(this, _ConnectionError.prototype);
+  }
+};
+var NotFoundError = class _NotFoundError extends KugelAudioError {
+  constructor(message, options = {}) {
+    super(message ?? "Not found.", {
+      statusCode: 404,
+      errorCode: ErrorCodes.NOT_FOUND,
+      ...options
+    });
+    this.name = "NotFoundError";
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+function build(status, errorCode, message, opts = {}) {
+  const common = { ...opts };
+  if (status !== void 0) common.statusCode = status;
+  if (errorCode !== void 0) common.errorCode = errorCode;
+  if (errorCode === ErrorCodes.UNAUTHORIZED || status === 401) {
+    return new AuthenticationError(message || void 0, common);
+  }
+  if (errorCode === ErrorCodes.INSUFFICIENT_CREDITS || status === 402) {
+    return new InsufficientCreditsError(message || void 0, common);
+  }
+  if (errorCode === ErrorCodes.RATE_LIMITED || errorCode === ErrorCodes.TOO_MANY_CONTEXTS || status === 429) {
+    return new RateLimitError(message || void 0, common);
+  }
+  if (errorCode === ErrorCodes.VALIDATION || errorCode === ErrorCodes.MISSING_VOICE_ID || status === 400) {
+    return new ValidationError(message || "Request validation failed.", common);
+  }
+  if (errorCode === ErrorCodes.MODEL_UNAVAILABLE || status === 503) {
+    const detail = message || "service temporarily unavailable";
+    return new ConnectionError(
+      `KugelAudio is temporarily unavailable: ${detail}. Retry shortly.`,
+      common
+    );
+  }
+  if (errorCode === ErrorCodes.NOT_FOUND || status === 404) {
+    return new NotFoundError(message || void 0, common);
+  }
+  return new KugelAudioError(message || `HTTP ${status}`, common);
+}
+function classifyWsFrame(data) {
+  const errorCode = data.error_code;
+  const message = data.error ?? "Server reported an error.";
+  const status = typeof data.code === "number" ? data.code : void 0;
+  const retryAfter = typeof data.retry_after === "number" ? data.retry_after : void 0;
+  return build(status, errorCode, message, { retryAfter });
+}
+function classifyWsHandshakeError(err) {
+  if (!err || typeof err !== "object") return null;
+  const e = err;
+  let status;
+  if (typeof e.statusCode === "number") {
+    status = e.statusCode;
+  }
+  if (status === void 0 && typeof e.message === "string") {
+    const m = e.message.match(/Unexpected server response:\s*(\d{3})/i);
+    if (m) status = Number(m[1]);
+  }
+  if (status === void 0) return null;
+  if (status === 403) {
+    return new AuthenticationError();
+  }
+  return build(status, void 0, typeof e.message === "string" ? e.message : "");
+}
+
+// src/utils.ts
+var MIN_CFG_SCALE = 1.2;
+var MAX_CFG_SCALE = 2.5;
+function clampCfgScale(cfgScale) {
+  if (cfgScale === void 0) return void 0;
+  return Math.min(MAX_CFG_SCALE, Math.max(MIN_CFG_SCALE, cfgScale));
+}
+
+// src/livekit/models.ts
+var DEFAULT_MODEL = "kugel-3";
+var SUPPORTED_SAMPLE_RATES = [24e3, 22050, 16e3, 8e3];
+var DEFAULT_SAMPLE_RATE = 24e3;
+var DEFAULT_VOICE_ID = null;
+var DEFAULT_CFG_SCALE = 2;
+var DEFAULT_MAX_NEW_TOKENS = 2048;
+var SUPPORTED_LANGUAGES = /* @__PURE__ */ new Set([
+  // Germanic
+  "de",
+  "en",
+  "nl",
+  "sv",
+  "da",
+  "no",
+  // Romance
+  "fr",
+  "es",
+  "it",
+  "pt",
+  "ro",
+  // Slavic
+  "pl",
+  "cs",
+  "uk",
+  "bg",
+  "sk",
+  "sl",
+  "hr",
+  "sr",
+  // Uralic
+  "fi",
+  "hu",
+  // Other European
+  "el",
+  "tr",
+  "ru",
+  // CJK + SEA
+  "zh",
+  "ja",
+  "ko",
+  "vi",
+  "yue",
+  "th",
+  "id",
+  "ms",
+  // Semitic + Indic + Other
+  "ar",
+  "hi",
+  "he",
+  "fa",
+  "ur",
+  "bn",
+  "ta"
+]);
+function validateLanguage(language) {
+  if (language === null || language === void 0) return void 0;
+  if (!SUPPORTED_LANGUAGES.has(language)) {
+    const supported = [...SUPPORTED_LANGUAGES].sort().join(", ");
+    throw new Error(
+      `language must be a supported ISO 639-1 code (${supported}), got '${language}'. Note: BCP 47 tags like 'de-DE' are not accepted \u2014 use 'de' instead.`
+    );
+  }
+  return language;
+}
+
+// package.json
+var package_default = {
+  name: "kugelaudio",
+  version: "0.9.0",
+  description: "Official JavaScript/TypeScript SDK for KugelAudio TTS API",
+  main: "dist/index.js",
+  module: "dist/index.mjs",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    },
+    "./livekit": {
+      types: "./dist/livekit/index.d.ts",
+      import: "./dist/livekit/index.mjs",
+      require: "./dist/livekit/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "src",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  scripts: {
+    build: "tsup src/index.ts src/livekit/index.ts --format cjs,esm --dts",
+    dev: "tsup src/index.ts src/livekit/index.ts --format cjs,esm --dts --watch",
+    lint: "eslint src/",
+    test: "vitest run",
+    "test:watch": "vitest",
+    prepublishOnly: "npm run build"
+  },
+  keywords: [
+    "tts",
+    "text-to-speech",
+    "audio",
+    "streaming",
+    "websocket",
+    "kugelaudio"
+  ],
+  author: "KugelAudio <hello@kugelaudio.com>",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/Kugelaudio/KugelAudio",
+    directory: "sdks/js"
+  },
+  homepage: "https://kugelaudio.com",
+  bugs: {
+    url: "https://github.com/Kugelaudio/KugelAudio/issues"
+  },
+  devDependencies: {
+    "@livekit/agents": "^1.4.11",
+    "@livekit/rtc-node": "^0.13.30",
+    "@types/node": "^25.3.2",
+    "@types/ws": "^8.18.1",
+    tsup: "^8.0.0",
+    typescript: "^6.0.2",
+    vitest: "^4.0.18"
+  },
+  peerDependencies: {
+    "@livekit/agents": ">=1.0.0",
+    "@livekit/rtc-node": ">=0.13.0"
+  },
+  peerDependenciesMeta: {
+    "@livekit/agents": {
+      optional: true
+    },
+    "@livekit/rtc-node": {
+      optional: true
+    }
+  },
+  engines: {
+    node: ">=18.0.0"
+  },
+  dependencies: {
+    tsx: "^4.21.0",
+    ws: "^8.18.0"
+  }
+};
+
+// src/livekit/wire.ts
+var SDK_NAME = "js";
+var SDK_VERSION = package_default.version;
+function appendSdkQuery(url) {
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}sdk=${encodeURIComponent(SDK_NAME)}&sdk_version=${encodeURIComponent(SDK_VERSION)}`;
+}
+function buildMultiWsUrl(baseUrl, apiKey) {
+  const wsBase = baseUrl.replace("https://", "wss://").replace("http://", "ws://");
+  return appendSdkQuery(`${wsBase}/ws/tts/multi?api_key=${apiKey}`);
+}
+function buildTextPayload(contextId, text, opts, { flush = false, includeConfig = false } = {}) {
+  const msg = { text, context_id: contextId };
+  if (flush) msg.flush = true;
+  if (includeConfig) {
+    msg.model_id = opts.model;
+    msg.sample_rate = opts.sampleRate;
+    msg.word_timestamps = opts.wordTimestamps;
+    msg.normalize = opts.normalize;
+    if (opts.language !== void 0) msg.language = opts.language;
+    const voiceSettings = {};
+    if (opts.voiceId !== null && opts.voiceId !== void 0) {
+      voiceSettings.voice_id = opts.voiceId;
+    }
+    if (opts.cfgScale !== 2) voiceSettings.cfg_scale = opts.cfgScale;
+    if (opts.maxNewTokens !== 2048) voiceSettings.max_new_tokens = opts.maxNewTokens;
+    if (Object.keys(voiceSettings).length > 0) msg.voice_settings = voiceSettings;
+  }
+  return msg;
+}
+function buildClosePayload(contextId, immediate = false) {
+  const msg = {
+    close_context: true,
+    context_id: contextId
+  };
+  if (immediate) msg.immediate = true;
+  return msg;
+}
+function wordTimestampsToTimed(timestamps) {
+  return timestamps.map((ts) => ({
+    text: ts.word,
+    startTime: ts.start_ms / 1e3,
+    endTime: ts.end_ms / 1e3
+  }));
+}
+
+// src/livekit/tts.ts
+var NUM_CHANNELS = 1;
+var DEFAULT_BASE_URL = "https://api.kugelaudio.com";
+var EU_BASE_URL = "https://api.eu.kugelaudio.com";
+function parseApiKey(apiKey) {
+  for (const prefix of ["eu-", "us-", "global-"]) {
+    if (apiKey.startsWith(prefix)) {
+      return { cleanKey: apiKey.slice(prefix.length), region: prefix.slice(0, -1) };
+    }
+  }
+  return { cleanKey: apiKey };
+}
+function apiStatusErrorFromFrame(data, requestId) {
+  const err = classifyWsFrame(data);
+  const statusCode = err.statusCode ?? (typeof data.code === "number" ? data.code : 500);
+  return new import_agents.APIStatusError({
+    message: err.message,
+    options: { statusCode, requestId, body: data }
+  });
+}
+function toLiveKitConnError(err) {
+  if (err instanceof Error && /handshake has timed out/i.test(err.message)) {
+    return new import_agents.APITimeoutError({ message: "Timed out connecting to /ws/tts/multi" });
+  }
+  const typed = classifyWsHandshakeError(err);
+  if (typed && typed.statusCode !== void 0) {
+    return new import_agents.APIStatusError({
+      message: typed.message,
+      options: { statusCode: typed.statusCode }
+    });
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return new import_agents.APIConnectionError({ message: `Failed to connect to /ws/tts/multi: ${message}` });
+}
+function bufferToArrayBuffer(buf) {
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+function deferred() {
+  const d = { settled: false };
+  d.promise = new Promise((resolve, reject) => {
+    d.resolve = () => {
+      if (d.settled) return;
+      d.settled = true;
+      resolve();
+    };
+    d.reject = (err) => {
+      if (d.settled) return;
+      d.settled = true;
+      reject(err);
+    };
+  });
+  d.promise.catch(() => {
+  });
+  return d;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var _tail;
+var Mutex = class {
+  constructor() {
+    __privateAdd(this, _tail, Promise.resolve());
+  }
+  async lock() {
+    let release;
+    const next = new Promise((resolve) => {
+      release = resolve;
+    });
+    const prev = __privateGet(this, _tail);
+    __privateSet(this, _tail, __privateGet(this, _tail).then(() => next));
+    await prev;
+    return release;
+  }
+};
+_tail = new WeakMap();
+var _bstream, _lastFrame, _pendingTimed, _ended, _AudioSink_instances, emit_fn;
+var AudioSink = class {
+  constructor(sampleRate, put, requestId, segmentId) {
+    this.put = put;
+    this.requestId = requestId;
+    this.segmentId = segmentId;
+    __privateAdd(this, _AudioSink_instances);
+    __privateAdd(this, _bstream);
+    __privateAdd(this, _lastFrame);
+    __privateAdd(this, _pendingTimed, []);
+    __privateAdd(this, _ended, false);
+    __privateSet(this, _bstream, new import_agents.AudioByteStream(sampleRate, NUM_CHANNELS));
+  }
+  pushAudio(bytes) {
+    if (__privateGet(this, _ended)) return;
+    for (const frame of __privateGet(this, _bstream).write(bufferToArrayBuffer(bytes))) {
+      __privateMethod(this, _AudioSink_instances, emit_fn).call(this, false);
+      __privateSet(this, _lastFrame, frame);
+    }
+  }
+  pushTimed(words) {
+    if (__privateGet(this, _ended)) return;
+    __privateGet(this, _pendingTimed).push(...words);
+  }
+  /** Flush any buffered audio and emit the terminal (`final`) frame. */
+  end() {
+    if (__privateGet(this, _ended)) return;
+    __privateSet(this, _ended, true);
+    for (const frame of __privateGet(this, _bstream).flush()) {
+      __privateMethod(this, _AudioSink_instances, emit_fn).call(this, false);
+      __privateSet(this, _lastFrame, frame);
+    }
+    __privateMethod(this, _AudioSink_instances, emit_fn).call(this, true);
+  }
+};
+_bstream = new WeakMap();
+_lastFrame = new WeakMap();
+_pendingTimed = new WeakMap();
+_ended = new WeakMap();
+_AudioSink_instances = new WeakSet();
+emit_fn = function(final) {
+  if (!__privateGet(this, _lastFrame)) return;
+  this.put({
+    requestId: this.requestId,
+    segmentId: this.segmentId,
+    frame: __privateGet(this, _lastFrame),
+    final,
+    timedTranscripts: __privateGet(this, _pendingTimed).length > 0 ? __privateGet(this, _pendingTimed) : void 0
+  });
+  __privateSet(this, _lastFrame, void 0);
+  __privateSet(this, _pendingTimed, []);
+};
+var _opts, _ws, _isCurrent, _closed, _activeContexts, _contexts, _inputQueue, _inputResolver, _sendTask, _recvTask, _logger, _Connection_instances, enqueue_fn, sendLoop_fn, recvLoop_fn, handleMessage_fn;
+var Connection = class {
+  constructor(opts) {
+    __privateAdd(this, _Connection_instances);
+    __privateAdd(this, _opts);
+    __privateAdd(this, _ws, null);
+    __privateAdd(this, _isCurrent, true);
+    __privateAdd(this, _closed, false);
+    __privateAdd(this, _activeContexts, /* @__PURE__ */ new Set());
+    __privateAdd(this, _contexts, /* @__PURE__ */ new Map());
+    __privateAdd(this, _inputQueue, []);
+    __privateAdd(this, _inputResolver, null);
+    __privateAdd(this, _sendTask, null);
+    __privateAdd(this, _recvTask, null);
+    __privateAdd(this, _logger, (0, import_agents.log)());
+    __privateSet(this, _opts, opts);
+  }
+  get isCurrent() {
+    return __privateGet(this, _isCurrent);
+  }
+  get closed() {
+    return __privateGet(this, _closed);
+  }
+  markNonCurrent() {
+    __privateSet(this, _isCurrent, false);
+  }
+  async connect(timeoutMs = 1e4) {
+    const url = buildMultiWsUrl(__privateGet(this, _opts).baseURL, __privateGet(this, _opts).apiKey);
+    await new Promise((resolve, reject) => {
+      let opened = false;
+      const ws = new import_ws.WebSocket(url, { handshakeTimeout: timeoutMs });
+      __privateSet(this, _ws, ws);
+      ws.on("open", () => {
+        opened = true;
+        __privateSet(this, _sendTask, __privateMethod(this, _Connection_instances, sendLoop_fn).call(this));
+        __privateSet(this, _recvTask, __privateMethod(this, _Connection_instances, recvLoop_fn).call(this));
+        resolve();
+      });
+      ws.on("unexpected-response", (_req, res) => {
+        if (!opened) {
+          reject(toLiveKitConnError({ statusCode: res.statusCode, message: res.statusMessage }));
+        }
+      });
+      ws.on("error", (err) => {
+        if (!opened) reject(toLiveKitConnError(err));
+      });
+    });
+  }
+  registerContext(contextId, sink, waiter, isStreaming) {
+    if (__privateGet(this, _closed)) {
+      waiter.reject(
+        new import_agents.APIConnectionError({ message: "Connection closed before request started" })
+      );
+      return null;
+    }
+    const ctx = {
+      sink,
+      waiter,
+      isStreaming,
+      lastActivityAt: Date.now()
+    };
+    __privateGet(this, _contexts).set(contextId, ctx);
+    return ctx;
+  }
+  sendText(contextId, text, flush) {
+    const includeConfig = !__privateGet(this, _activeContexts).has(contextId);
+    if (includeConfig) __privateGet(this, _activeContexts).add(contextId);
+    __privateMethod(this, _Connection_instances, enqueue_fn).call(this, buildTextPayload(contextId, text, __privateGet(this, _opts), { flush, includeConfig }));
+  }
+  closeContext(contextId, immediate) {
+    __privateMethod(this, _Connection_instances, enqueue_fn).call(this, buildClosePayload(contextId, immediate));
+  }
+  cleanupContext(contextId) {
+    __privateGet(this, _contexts).delete(contextId);
+    __privateGet(this, _activeContexts).delete(contextId);
+  }
+  async close() {
+    var _a;
+    if (__privateGet(this, _closed)) return;
+    __privateSet(this, _closed, true);
+    (_a = __privateGet(this, _inputResolver)) == null ? void 0 : _a.call(this);
+    for (const ctx of __privateGet(this, _contexts).values()) {
+      ctx.waiter.reject(new import_agents.APIConnectionError({ message: "Connection closed" }));
+    }
+    __privateGet(this, _contexts).clear();
+    if (__privateGet(this, _ws)) {
+      try {
+        if (__privateGet(this, _ws).readyState === import_ws.WebSocket.OPEN) {
+          __privateGet(this, _ws).send(JSON.stringify({ close_socket: true }));
+        }
+        __privateGet(this, _ws).close();
+      } catch {
+      }
+      __privateSet(this, _ws, null);
+    }
+    await __privateGet(this, _sendTask)?.catch(() => {
+    });
+    await __privateGet(this, _recvTask)?.catch(() => {
+    });
+  }
+};
+_opts = new WeakMap();
+_ws = new WeakMap();
+_isCurrent = new WeakMap();
+_closed = new WeakMap();
+_activeContexts = new WeakMap();
+_contexts = new WeakMap();
+_inputQueue = new WeakMap();
+_inputResolver = new WeakMap();
+_sendTask = new WeakMap();
+_recvTask = new WeakMap();
+_logger = new WeakMap();
+_Connection_instances = new WeakSet();
+enqueue_fn = function(payload) {
+  var _a;
+  if (__privateGet(this, _closed)) return;
+  __privateGet(this, _inputQueue).push(payload);
+  (_a = __privateGet(this, _inputResolver)) == null ? void 0 : _a.call(this);
+};
+sendLoop_fn = async function() {
+  try {
+    while (!__privateGet(this, _closed)) {
+      if (__privateGet(this, _inputQueue).length === 0) {
+        await new Promise((resolve) => {
+          __privateSet(this, _inputResolver, resolve);
+        });
+        __privateSet(this, _inputResolver, null);
+      }
+      if (__privateGet(this, _closed)) break;
+      const payload = __privateGet(this, _inputQueue).shift();
+      if (!payload) continue;
+      if (!__privateGet(this, _ws) || __privateGet(this, _ws).readyState !== import_ws.WebSocket.OPEN) break;
+      __privateGet(this, _ws).send(JSON.stringify(payload));
+    }
+  } catch (err) {
+    __privateGet(this, _logger).warn({ error: err }, "kugelaudio livekit send loop error");
+    __privateSet(this, _isCurrent, false);
+    if (__privateGet(this, _ws) && __privateGet(this, _ws).readyState === import_ws.WebSocket.OPEN) __privateGet(this, _ws).close();
+  }
+};
+recvLoop_fn = async function() {
+  const ws = __privateGet(this, _ws);
+  if (!ws) return;
+  try {
+    await new Promise((resolve) => {
+      const onMessage = (raw) => {
+        const text = typeof raw === "string" ? raw : Array.isArray(raw) ? Buffer.concat(raw).toString() : raw instanceof ArrayBuffer ? Buffer.from(raw).toString() : raw.toString();
+        try {
+          __privateMethod(this, _Connection_instances, handleMessage_fn).call(this, JSON.parse(text));
+        } catch (err) {
+          __privateGet(this, _logger).warn({ error: err }, "failed to parse /ws/tts/multi message");
+        }
+      };
+      const finish = () => {
+        ws.off("message", onMessage);
+        ws.off("close", finish);
+        ws.off("error", finish);
+        resolve();
+      };
+      ws.on("message", onMessage);
+      ws.on("close", finish);
+      ws.on("error", finish);
+    });
+  } finally {
+    __privateSet(this, _isCurrent, false);
+    for (const ctx of __privateGet(this, _contexts).values()) {
+      ctx.waiter.reject(
+        new import_agents.APIConnectionError({ message: "WebSocket connection closed unexpectedly" })
+      );
+    }
+  }
+};
+handleMessage_fn = function(data) {
+  if (data.session_closed) {
+    __privateSet(this, _isCurrent, false);
+    return;
+  }
+  const contextId = typeof data.context_id === "string" ? data.context_id : void 0;
+  if (data.error) {
+    if (contextId) {
+      const ctx2 = __privateGet(this, _contexts).get(contextId);
+      ctx2?.waiter.reject(apiStatusErrorFromFrame(data, contextId));
+      this.cleanupContext(contextId);
+    }
+    return;
+  }
+  const ctx = contextId ? __privateGet(this, _contexts).get(contextId) : void 0;
+  if (!ctx) return;
+  ctx.lastActivityAt = Date.now();
+  if (data.context_timeout) {
+    ctx.waiter.reject(new import_agents.APITimeoutError({ message: "context timed out" }));
+    this.cleanupContext(contextId);
+    return;
+  }
+  if (typeof data.audio === "string") {
+    ctx.sink.pushAudio(Buffer.from(data.audio, "base64"));
+  }
+  if (Array.isArray(data.word_timestamps)) {
+    ctx.sink.pushTimed(
+      wordTimestampsToTimed(data.word_timestamps).map((w) => (0, import_agents.createTimedString)(w))
+    );
+  }
+  if (data.chunk_complete && !ctx.isStreaming) {
+    this.closeContext(contextId, false);
+  }
+  if (data.context_closed) {
+    ctx.sink.end();
+    ctx.waiter.resolve();
+    this.cleanupContext(contextId);
+  }
+};
+async function waitForContextIdle(ctx, idleThresholdMs) {
+  const tick = Math.min(1e3, Math.max(100, idleThresholdMs / 4));
+  for (; ; ) {
+    const result = await Promise.race([
+      ctx.waiter.promise.then(() => "done"),
+      delay(tick).then(() => "tick")
+    ]);
+    if (result === "done") return;
+    if (Date.now() - ctx.lastActivityAt >= idleThresholdMs) {
+      throw new import_agents.APITimeoutError({ message: "timed out waiting for KugelAudio audio" });
+    }
+  }
+}
+var _opts2, _streams, _currentConnection, _connectionLock, _logger2;
+var TTS = class extends import_agents.tts.TTS {
+  constructor(opts = {}) {
+    const sampleRate = opts.sampleRate ?? DEFAULT_SAMPLE_RATE;
+    const wordTimestamps = opts.wordTimestamps ?? false;
+    super(sampleRate, NUM_CHANNELS, {
+      streaming: true,
+      alignedTranscript: wordTimestamps
+    });
+    __privateAdd(this, _opts2);
+    __privateAdd(this, _streams, /* @__PURE__ */ new Set());
+    __privateAdd(this, _currentConnection, null);
+    __privateAdd(this, _connectionLock, new Mutex());
+    __privateAdd(this, _logger2, (0, import_agents.log)());
+    this.label = "kugelaudio.TTS";
+    const apiKey = opts.apiKey ?? process.env.KUGELAUDIO_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "KUGELAUDIO_API_KEY must be set or apiKey must be provided to the TTS constructor."
+      );
+    }
+    const { cleanKey } = parseApiKey(apiKey);
+    const language = validateLanguage(opts.language);
+    let baseURL;
+    if (opts.baseURL) {
+      baseURL = opts.baseURL.replace(/\/$/, "");
+    } else {
+      const { region } = parseApiKey(apiKey);
+      baseURL = region === "eu" ? EU_BASE_URL : DEFAULT_BASE_URL;
+    }
+    __privateSet(this, _opts2, {
+      apiKey: cleanKey,
+      baseURL,
+      model: opts.model ?? DEFAULT_MODEL,
+      voiceId: opts.voiceId ?? DEFAULT_VOICE_ID,
+      sampleRate,
+      cfgScale: clampCfgScale(opts.cfgScale ?? DEFAULT_CFG_SCALE) ?? DEFAULT_CFG_SCALE,
+      maxNewTokens: opts.maxNewTokens ?? DEFAULT_MAX_NEW_TOKENS,
+      wordTimestamps,
+      normalize: opts.normalize ?? true,
+      language
+    });
+  }
+  get model() {
+    return __privateGet(this, _opts2).model;
+  }
+  get provider() {
+    return "KugelAudio";
+  }
+  /** Get or create the persistent `/ws/tts/multi` connection. */
+  async currentConnection(timeoutMs = 1e4) {
+    const unlock = await __privateGet(this, _connectionLock).lock();
+    try {
+      if (__privateGet(this, _currentConnection) && __privateGet(this, _currentConnection).isCurrent && !__privateGet(this, _currentConnection).closed) {
+        return __privateGet(this, _currentConnection);
+      }
+      const conn = new Connection({ ...__privateGet(this, _opts2) });
+      await conn.connect(timeoutMs);
+      __privateSet(this, _currentConnection, conn);
+      return conn;
+    } finally {
+      unlock();
+    }
+  }
+  /**
+   * Eagerly establish the WebSocket connection to remove handshake latency
+   * from the first synthesis. Errors are logged and retried on first use.
+   */
+  prewarm() {
+    this.currentConnection().then(() => __privateGet(this, _logger2).info("KugelAudio TTS connection pre-warmed")).catch(
+      (err) => __privateGet(this, _logger2).warn(
+        { error: err },
+        "Failed to prewarm KugelAudio connection; will retry on first synthesis"
+      )
+    );
+  }
+  /**
+   * Update TTS options at runtime. Changing any option marks the current
+   * connection non-current so the next synthesis opens a fresh one.
+   */
+  updateOptions(opts) {
+    let changed = false;
+    const set = (key, value) => {
+      if (__privateGet(this, _opts2)[key] !== value) {
+        __privateGet(this, _opts2)[key] = value;
+        changed = true;
+      }
+    };
+    if (opts.model !== void 0) set("model", opts.model);
+    if (opts.voiceId !== void 0) set("voiceId", opts.voiceId);
+    if (opts.cfgScale !== void 0) {
+      set("cfgScale", clampCfgScale(opts.cfgScale) ?? DEFAULT_CFG_SCALE);
+    }
+    if (opts.maxNewTokens !== void 0) set("maxNewTokens", opts.maxNewTokens);
+    if (opts.normalize !== void 0) set("normalize", opts.normalize);
+    if (opts.wordTimestamps !== void 0) set("wordTimestamps", opts.wordTimestamps);
+    if (opts.language !== void 0) set("language", validateLanguage(opts.language));
+    if (changed && __privateGet(this, _currentConnection)) {
+      const old = __privateGet(this, _currentConnection);
+      old.markNonCurrent();
+      __privateSet(this, _currentConnection, null);
+      old.close().catch(() => {
+      });
+    }
+  }
+  synthesize(text, connOptions, abortSignal) {
+    return new ChunkedStream(this, text, { ...__privateGet(this, _opts2) }, connOptions, abortSignal);
+  }
+  stream(options) {
+    const stream = new SynthesizeStream(this, { ...__privateGet(this, _opts2) }, options?.connOptions);
+    __privateGet(this, _streams).add(stream);
+    stream.abortSignal.addEventListener("abort", () => __privateGet(this, _streams).delete(stream), {
+      once: true
+    });
+    return stream;
+  }
+  async close() {
+    for (const stream of __privateGet(this, _streams)) stream.close();
+    __privateGet(this, _streams).clear();
+    if (__privateGet(this, _currentConnection)) {
+      await __privateGet(this, _currentConnection).close();
+      __privateSet(this, _currentConnection, null);
+    }
+  }
+};
+_opts2 = new WeakMap();
+_streams = new WeakMap();
+_currentConnection = new WeakMap();
+_connectionLock = new WeakMap();
+_logger2 = new WeakMap();
+var _tts, _opts3, _connOptions;
+var ChunkedStream = class extends import_agents.tts.ChunkedStream {
+  constructor(ttsInstance, text, opts, connOptions, abortSignal) {
+    super(text, ttsInstance, connOptions, abortSignal);
+    __privateAdd(this, _tts);
+    __privateAdd(this, _opts3);
+    __privateAdd(this, _connOptions);
+    this.label = "kugelaudio.ChunkedStream";
+    __privateSet(this, _tts, ttsInstance);
+    __privateSet(this, _opts3, opts);
+    __privateSet(this, _connOptions, connOptions ?? { maxRetry: 3, retryIntervalMs: 2e3, timeoutMs: 1e4 });
+  }
+  async run() {
+    const contextId = (0, import_agents.shortuuid)();
+    const connection = await __privateGet(this, _tts).currentConnection(__privateGet(this, _connOptions).timeoutMs);
+    const sink = new AudioSink(__privateGet(this, _opts3).sampleRate, (a) => this.queue.put(a), contextId, contextId);
+    const waiter = deferred();
+    const ctx = connection.registerContext(contextId, sink, waiter, false);
+    if (!ctx) {
+      await waiter.promise;
+      return;
+    }
+    const onAbort = () => waiter.reject(new Error("aborted"));
+    this.abortController.signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      connection.sendText(contextId, this.inputText, true);
+      await waitForContextIdle(ctx, __privateGet(this, _connOptions).timeoutMs);
+    } catch (err) {
+      connection.closeContext(contextId, true);
+      connection.cleanupContext(contextId);
+      if (this.abortController.signal.aborted) return;
+      throw err;
+    } finally {
+      this.abortController.signal.removeEventListener("abort", onAbort);
+    }
+  }
+};
+_tts = new WeakMap();
+_opts3 = new WeakMap();
+_connOptions = new WeakMap();
+var _tts2, _opts4, _contextId;
+var _SynthesizeStream = class _SynthesizeStream extends import_agents.tts.SynthesizeStream {
+  constructor(ttsInstance, opts, connOptions) {
+    super(ttsInstance, connOptions);
+    __privateAdd(this, _tts2);
+    __privateAdd(this, _opts4);
+    __privateAdd(this, _contextId);
+    this.label = "kugelaudio.SynthesizeStream";
+    __privateSet(this, _tts2, ttsInstance);
+    __privateSet(this, _opts4, opts);
+  }
+  /** The server-side context id of the current (latest) run attempt. */
+  get contextId() {
+    return __privateGet(this, _contextId);
+  }
+  async run() {
+    const contextId = (0, import_agents.shortuuid)();
+    __privateSet(this, _contextId, contextId);
+    const timeoutMs = this.connOptions.timeoutMs;
+    const connection = await __privateGet(this, _tts2).currentConnection(timeoutMs);
+    const sink = new AudioSink(__privateGet(this, _opts4).sampleRate, (a) => this.queue.put(a), contextId, contextId);
+    const waiter = deferred();
+    const ctx = connection.registerContext(contextId, sink, waiter, true);
+    if (!ctx) {
+      await waiter.promise;
+      return;
+    }
+    const onAbort = () => waiter.reject(new Error("aborted"));
+    this.abortController.signal.addEventListener("abort", onAbort, { once: true });
+    const STOP = /* @__PURE__ */ Symbol("stop");
+    const stopInput = deferred();
+    let failed = false;
+    const inputTask = async () => {
+      for (; ; ) {
+        const result = await Promise.race([
+          this.input.next(),
+          stopInput.promise.then(() => STOP)
+        ]);
+        if (typeof result === "symbol") return;
+        if (result.done) break;
+        if (this.abortController.signal.aborted || failed) return;
+        const data = result.value;
+        if (data === _SynthesizeStream.FLUSH_SENTINEL) {
+          connection.sendText(contextId, "", true);
+          continue;
+        }
+        if (!data) continue;
+        connection.sendText(contextId, data, false);
+      }
+      if (!this.abortController.signal.aborted && !failed) {
+        connection.sendText(contextId, "", true);
+        connection.closeContext(contextId, false);
+      }
+    };
+    const input = inputTask();
+    input.catch((err) => waiter.reject(err instanceof Error ? err : new Error(String(err))));
+    try {
+      await waitForContextIdle(ctx, timeoutMs);
+    } catch (err) {
+      failed = true;
+      connection.closeContext(contextId, true);
+      connection.cleanupContext(contextId);
+      if (this.abortController.signal.aborted) return;
+      throw err;
+    } finally {
+      this.abortController.signal.removeEventListener("abort", onAbort);
+      stopInput.resolve();
+      await input.catch(() => {
+      });
+    }
+  }
+};
+_tts2 = new WeakMap();
+_opts4 = new WeakMap();
+_contextId = new WeakMap();
+var SynthesizeStream = _SynthesizeStream;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChunkedStream,
+  DEFAULT_CFG_SCALE,
+  DEFAULT_MAX_NEW_TOKENS,
+  DEFAULT_MODEL,
+  DEFAULT_SAMPLE_RATE,
+  DEFAULT_VOICE_ID,
+  SUPPORTED_LANGUAGES,
+  SUPPORTED_SAMPLE_RATES,
+  SynthesizeStream,
+  TTS,
+  validateLanguage
+});