kugelaudio 0.8.0 → 0.9.0

package/dist/livekit/index.mjs

@@ -0,0 +1,746 @@
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  clampCfgScale,
+  classifyWsFrame,
+  classifyWsHandshakeError,
+  package_default
+} from "../chunk-CB3B6T7F.mjs";
+
+// src/livekit/tts.ts
+import {
+  APIConnectionError,
+  APIStatusError,
+  APITimeoutError,
+  AudioByteStream,
+  createTimedString,
+  log,
+  shortuuid,
+  tts
+} from "@livekit/agents";
+import { WebSocket } from "ws";
+
+// 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;
+}
+
+// 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 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 APITimeoutError({ message: "Timed out connecting to /ws/tts/multi" });
+  }
+  const typed = classifyWsHandshakeError(err);
+  if (typed && typed.statusCode !== void 0) {
+    return new APIStatusError({
+      message: typed.message,
+      options: { statusCode: typed.statusCode }
+    });
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return new 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 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, 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 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 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 APIConnectionError({ message: "Connection closed" }));
+    }
+    __privateGet(this, _contexts).clear();
+    if (__privateGet(this, _ws)) {
+      try {
+        if (__privateGet(this, _ws).readyState === 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 !== 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 === 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 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 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) => 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 APITimeoutError({ message: "timed out waiting for KugelAudio audio" });
+    }
+  }
+}
+var _opts2, _streams, _currentConnection, _connectionLock, _logger2;
+var TTS = class extends 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, 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 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 = 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 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 = 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;
+export {
+  ChunkedStream,
+  DEFAULT_CFG_SCALE,
+  DEFAULT_MAX_NEW_TOKENS,
+  DEFAULT_MODEL,
+  DEFAULT_SAMPLE_RATE,
+  DEFAULT_VOICE_ID,
+  SUPPORTED_LANGUAGES,
+  SUPPORTED_SAMPLE_RATES,
+  SynthesizeStream,
+  TTS,
+  validateLanguage
+};