kugelaudio 0.8.0 → 0.9.0

package/dist/chunk-D57AKD2S.mjs

@@ -0,0 +1,391 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+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/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 WsCloseCodes = {
+  UNAUTHORIZED: 4001,
+  INSUFFICIENT_CREDITS: 4003,
+  RATE_LIMITED: 4029,
+  MODEL_UNAVAILABLE: 4500
+};
+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 readHeader(headers, name) {
+  if (headers && typeof headers.get === "function") {
+    return headers.get(name) ?? void 0;
+  }
+  const rec = headers;
+  return rec[name] ?? rec[name.toLowerCase()] ?? void 0;
+}
+function classifyHttpError(status, bodyText, headers) {
+  let errorCode;
+  let message = "";
+  let retryAfter;
+  if (bodyText) {
+    try {
+      const body = JSON.parse(bodyText);
+      if (body && typeof body === "object") {
+        errorCode = typeof body.error_code === "string" ? body.error_code : void 0;
+        const msg = body.error ?? body.detail;
+        if (Array.isArray(msg)) {
+          message = msg.map((m) => String(m)).join("; ");
+        } else if (typeof msg === "string") {
+          message = msg;
+        }
+        if (typeof body.retry_after === "number") {
+          retryAfter = body.retry_after;
+        }
+      }
+    } catch {
+    }
+  }
+  if (retryAfter === void 0) {
+    const header = readHeader(headers, "Retry-After") ?? readHeader(headers, "retry-after");
+    if (header) {
+      const n = Number(header);
+      if (Number.isFinite(n)) retryAfter = n;
+    }
+  }
+  const requestId = readHeader(headers, "x-request-id") ?? readHeader(headers, "X-Request-Id");
+  if (!message) {
+    message = (bodyText || "").trim();
+  }
+  return build(status, errorCode, message, { requestId, retryAfter });
+}
+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 classifyWsClose(code, reason) {
+  const reasonTxt = (reason ?? "").trim();
+  if (code === WsCloseCodes.UNAUTHORIZED) {
+    let msg = `KugelAudio rejected the API key. Check it is current at ${API_KEYS_URL}.`;
+    if (reasonTxt) msg = `${msg} (${reasonTxt})`;
+    return new AuthenticationError(msg);
+  }
+  if (code === WsCloseCodes.INSUFFICIENT_CREDITS) {
+    return new InsufficientCreditsError();
+  }
+  if (code === WsCloseCodes.RATE_LIMITED) {
+    return new RateLimitError();
+  }
+  if (code === WsCloseCodes.MODEL_UNAVAILABLE) {
+    const suffix = reasonTxt ? ` (${reasonTxt})` : "";
+    return new ConnectionError(
+      `KugelAudio model is temporarily unavailable. Retry shortly.${suffix}`
+    );
+  }
+  const detail = reasonTxt || "no reason given";
+  const codeStr = code !== void 0 ? ` (code ${code})` : "";
+  return new ConnectionError(
+    `KugelAudio WebSocket closed by server: ${detail}${codeStr}.`
+  );
+}
+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));
+}
+function base64ToArrayBuffer(base64) {
+  if (typeof atob === "function") {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes.buffer;
+  } else {
+    const buffer = Buffer.from(base64, "base64");
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  }
+}
+function decodePCM16(base64) {
+  const buffer = base64ToArrayBuffer(base64);
+  const int16 = new Int16Array(buffer);
+  const float32 = new Float32Array(int16.length);
+  for (let i = 0; i < int16.length; i++) {
+    float32[i] = int16[i] / 32768;
+  }
+  return float32;
+}
+function createWavFile(audio, sampleRate) {
+  const dataSize = audio.byteLength;
+  const fileSize = 44 + dataSize;
+  const buffer = new ArrayBuffer(fileSize);
+  const view = new DataView(buffer);
+  writeString(view, 0, "RIFF");
+  view.setUint32(4, fileSize - 8, true);
+  writeString(view, 8, "WAVE");
+  writeString(view, 12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * 2, true);
+  view.setUint16(32, 2, true);
+  view.setUint16(34, 16, true);
+  writeString(view, 36, "data");
+  view.setUint32(40, dataSize, true);
+  const audioBytes = new Uint8Array(audio);
+  const wavBytes = new Uint8Array(buffer);
+  wavBytes.set(audioBytes, 44);
+  return buffer;
+}
+function writeString(view, offset, str) {
+  for (let i = 0; i < str.length; i++) {
+    view.setUint8(offset + i, str.charCodeAt(i));
+  }
+}
+function createWavBlob(audio, sampleRate) {
+  const wavBuffer = createWavFile(audio, sampleRate);
+  return new Blob([wavBuffer], { type: "audio/wav" });
+}
+
+// package.json
+var package_default = {
+  name: "kugelaudio",
+  version: "0.8.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"
+  }
+};
+
+export {
+  __require,
+  __privateGet,
+  __privateAdd,
+  __privateSet,
+  __privateMethod,
+  ErrorCodes,
+  WsCloseCodes,
+  KugelAudioError,
+  AuthenticationError,
+  RateLimitError,
+  InsufficientCreditsError,
+  ValidationError,
+  ConnectionError,
+  NotFoundError,
+  classifyHttpError,
+  classifyWsFrame,
+  classifyWsClose,
+  classifyWsHandshakeError,
+  clampCfgScale,
+  base64ToArrayBuffer,
+  decodePCM16,
+  createWavFile,
+  createWavBlob,
+  package_default
+};

package/dist/index.d.mts

@@ -34,6 +34,7 @@ interface Voice {
     category?: VoiceCategory;
     sex?: VoiceSex;
     age?: VoiceAge;
+    quality?: string;
     supportedLanguages: string[];
     sampleText?: string;
     avatarUrl?: string;
@@ -221,7 +222,7 @@ interface GenerateOptions {
     modelId?: string;
     /** Voice ID to use */
     voiceId?: number;
-    /** CFG scale for generation (default: 2.0) */
+    /** Classifier-free guidance scale. Clamped to [1.2, 2.5] (default: 2.0). */
     cfgScale?: number;
     /**
      * Sampling variance. Range [0.0, 1.0]. 0 = most stable (near-greedy),
@@ -269,8 +270,9 @@ interface GenerateOptions {
     /**
      * Playback speed multiplier (0.8 = slower, 1.0 = normal, 1.2 = faster).
      *
-     * Uses pitch-preserving time-stretching (WSOLA); applies uniformly to the
-     * whole request (no per-span control).
+     * Uses pitch-preserving time-stretching (WSOLA); applies to the whole
+     * request. Wrap text in `<prosody rate="slow|medium|fast|0.8-1.2">` to
+     * override the rate for a span (the span rate wins inside the span).
      * Range: [0.8, 1.2]. Default: 1.0.
      */
     speed?: number;
@@ -312,7 +314,7 @@ interface StreamConfig {
     voiceId?: number;
     /** Model ID. Default: 'kugel-3'. Legacy ids still accepted; they alias to kugel-3 server-side. */
     modelId?: string;
-    /** CFG scale for generation */
+    /** Classifier-free guidance scale. Clamped to [1.2, 2.5] (default: 2.0). */
     cfgScale?: number;
     /**
      * Sampling variance. Range [0.0, 1.0]. 0 = most stable, 1 = most variance.
@@ -369,8 +371,9 @@ interface StreamConfig {
     /**
      * Playback speed multiplier (0.8 = slower, 1.0 = normal, 1.2 = faster).
      *
-     * Uses pitch-preserving time-stretching (WSOLA); applies uniformly to the
-     * whole request (no per-span control).
+     * Uses pitch-preserving time-stretching (WSOLA); applies to the whole
+     * request. Wrap text in `<prosody rate="slow|medium|fast|0.8-1.2">` to
+     * override the rate for a span (the span rate wins inside the span).
      * Range: [0.8, 1.2]. Default: 1.0.
      */
     speed?: number;
@@ -383,6 +386,41 @@ interface StreamConfig {
      */
     dictionaryIds?: number[];
 }
+/**
+ * Generation parameters changeable mid-connection via
+ * {@link StreamingSession.updateSettings} / {@link MultiContextSession.updateSettings}
+ * (KUG-1166). Every field is optional; an update changes only the fields it
+ * carries. Identity / audio-format fields (`voiceId`, `modelId`, `sampleRate`,
+ * `outputFormat`, `dictionaryIds`) are NOT here — they are fixed for the
+ * connection's lifetime and the server rejects them in an update.
+ */
+interface SettingsUpdate {
+    /** Classifier-free guidance scale (0.0–10.0). */
+    cfgScale?: number;
+    /** Sampling variance (0.0–1.0). */
+    temperature?: number;
+    /** Playback speed multiplier (0.8–1.2). */
+    speed?: number;
+    /** Maximum tokens per generation (1–8192). */
+    maxNewTokens?: number;
+    /** Language code for normalization (e.g. `'de'`). */
+    language?: string;
+    /** Enable text normalization. */
+    normalize?: boolean;
+}
+/**
+ * The generation parameters in effect after an
+ * {@link StreamingSession.updateSettings} call — the server's echo. Fields the
+ * session never set come back `null` (e.g. `temperature`, `language`).
+ */
+interface EffectiveSettings {
+    cfgScale?: number;
+    temperature?: number | null;
+    speed?: number;
+    maxNewTokens?: number;
+    language?: string | null;
+    normalize?: boolean;
+}
 /**
  * Event callbacks for a streaming session (`/ws/tts/stream`).
  *
@@ -577,7 +615,7 @@ interface MultiContextConfig {
     sampleRate?: number;
     /** Combined codec+rate token (e.g. 'ulaw_8000'); opt-in, set-once per context. */
     outputFormat?: string;
-    /** CFG scale for generation (default: 2.0) */
+    /** Classifier-free guidance scale. Clamped to [1.2, 2.5] (default: 2.0). */
     cfgScale?: number;
     /**
      * Sampling variance. Range [0.0, 1.0]. 0 = most stable, 1 = most variance.
@@ -1061,6 +1099,22 @@ declare class MultiContextSession {
      * Send keep-alive to reset a context's inactivity timeout.
      */
     keepAlive(contextId: string): void;
+    /**
+     * Change the session's generation parameters mid-connection (KUG-1166).
+     *
+     * Session-scoped (there is no `contextId`): the update applies to contexts
+     * started **after** it — a context already streaming keeps the settings it
+     * began with, since generation parameters are bound when a context's engine
+     * session opens. With the common one-context-per-turn pattern that means it
+     * takes effect on the next turn. Per-context `cfgScale` / `maxNewTokens`
+     * passed to {@link createContext} still win for that context.
+     *
+     * Resolves with the generation parameters now in effect (the server's echo).
+     *
+     * @throws {KugelAudioError} if no field is provided, the socket is not open,
+     *   or the server rejects the update.
+     */
+    updateSettings(settings: SettingsUpdate): Promise<EffectiveSettings>;
     /**
      * Close the session and all contexts.
      */
@@ -1190,6 +1244,28 @@ declare class StreamingSession {
      * to change voice, model, language, or other settings.
      */
     updateConfig(config: Partial<StreamConfig>): void;
+    /**
+     * Change generation parameters mid-connection without reconnecting (KUG-1166).
+     *
+     * Sends an `update_settings` message and resolves with the generation
+     * parameters now in effect (the server's echo). Only the six fields of
+     * {@link SettingsUpdate} are updatable; identity / audio-format fields
+     * (`voiceId`, `modelId`, `sampleRate`, `outputFormat`, `dictionaryIds`) are
+     * fixed for the connection — change those with {@link updateConfig} after
+     * {@link endSession} instead.
+     *
+     * The change applies to the **next turn**: a turn already streaming keeps the
+     * settings it started with, so call this between turns.
+     *
+     * @example
+     * ```typescript
+     * const effective = await session.updateSettings({ cfgScale: 1.5, speed: 1.1 });
+     * ```
+     *
+     * @throws {KugelAudioError} if no field is provided, the socket is not open,
+     *   or the server rejects the update (e.g. a value out of range).
+     */
+    updateSettings(settings: SettingsUpdate): Promise<EffectiveSettings>;
     /**
      * Close the session and the WebSocket connection.
      *
@@ -1445,9 +1521,6 @@ declare function classifyWsClose(code: number | undefined, reason?: string): Kug
  */
 declare function classifyWsHandshakeError(err: unknown): KugelAudioError | null;
 
-/**
- * Utility functions for KugelAudio SDK.
- */
 /**
  * Decode base64 string to ArrayBuffer.
  */
@@ -1465,4 +1538,4 @@ declare function createWavFile(audio: ArrayBuffer, sampleRate: number): ArrayBuf
  */
 declare function createWavBlob(audio: ArrayBuffer, sampleRate: number): Blob;
 
-export { type AudioChunk, type AudioResponse, AuthenticationError, type BulkReplaceResult, ConnectionError, type ContextVoiceSettings, type CreateDictionaryOptions, type CreateVoiceOptions, DictionariesResource, type Dictionary, DictionaryEntriesResource, type DictionaryEntry, type DictionaryEntryInput, type DictionaryEntryListResponse, type ErrorCode, ErrorCodes, type GenerateOptions, type GenerationStats, InsufficientCreditsError, KugelAudio, KugelAudioError, type KugelAudioErrorOptions, type KugelAudioOptions, type Model, type MultiContextAudioChunk, type MultiContextCallbacks, type MultiContextConfig, NotFoundError, RateLimitError, type Region, type SessionUsage, type StreamCallbacks, type StreamConfig, type StreamingSessionCallbacks, type UpdateDictionaryEntryOptions, type UpdateDictionaryOptions, type UpdateVoiceOptions, ValidationError, type Voice, type VoiceAge, type VoiceCategory, type VoiceDetail, type VoiceListResponse, type VoiceQuality, type VoiceReference, type VoiceSex, type WordTimestamp, WsCloseCodes, base64ToArrayBuffer, classifyHttpError, classifyWsClose, classifyWsFrame, classifyWsHandshakeError, createWavBlob, createWavFile, decodePCM16, parseSessionUsage };
+export { type AudioChunk, type AudioResponse, AuthenticationError, type BulkReplaceResult, ConnectionError, type ContextVoiceSettings, type CreateDictionaryOptions, type CreateVoiceOptions, DictionariesResource, type Dictionary, DictionaryEntriesResource, type DictionaryEntry, type DictionaryEntryInput, type DictionaryEntryListResponse, type EffectiveSettings, type ErrorCode, ErrorCodes, type GenerateOptions, type GenerationStats, InsufficientCreditsError, KugelAudio, KugelAudioError, type KugelAudioErrorOptions, type KugelAudioOptions, type Model, type MultiContextAudioChunk, type MultiContextCallbacks, type MultiContextConfig, NotFoundError, RateLimitError, type Region, type SessionUsage, type SettingsUpdate, type StreamCallbacks, type StreamConfig, type StreamingSessionCallbacks, type UpdateDictionaryEntryOptions, type UpdateDictionaryOptions, type UpdateVoiceOptions, ValidationError, type Voice, type VoiceAge, type VoiceCategory, type VoiceDetail, type VoiceListResponse, type VoiceQuality, type VoiceReference, type VoiceSex, type WordTimestamp, WsCloseCodes, base64ToArrayBuffer, classifyHttpError, classifyWsClose, classifyWsFrame, classifyWsHandshakeError, createWavBlob, createWavFile, decodePCM16, parseSessionUsage };