@upliftai/sdk-js 0.1.0

package/dist/index.js

@@ -0,0 +1,865 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  UpliftAI: () => UpliftAI,
+  UpliftAIAuthError: () => UpliftAIAuthError,
+  UpliftAIError: () => UpliftAIError,
+  UpliftAIInsufficientBalanceError: () => UpliftAIInsufficientBalanceError,
+  UpliftAIRateLimitError: () => UpliftAIRateLimitError,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var UpliftAIError = class extends Error {
+  constructor(message, statusCode, code, requestId) {
+    super(message);
+    this.statusCode = statusCode;
+    this.code = code;
+    this.requestId = requestId;
+    this.name = "UpliftAIError";
+  }
+};
+var UpliftAIAuthError = class extends UpliftAIError {
+  constructor(message = "Authentication failed. Check your API key.", requestId) {
+    super(message, 401, "auth_error", requestId);
+    this.name = "UpliftAIAuthError";
+  }
+};
+var UpliftAIInsufficientBalanceError = class extends UpliftAIError {
+  constructor(message = "Insufficient balance. Please add credits to your account.", requestId) {
+    super(message, 402, "insufficient_balance", requestId);
+    this.name = "UpliftAIInsufficientBalanceError";
+  }
+};
+var UpliftAIRateLimitError = class extends UpliftAIError {
+  constructor(message = "Rate limit exceeded.", requestId) {
+    super(message, 429, "rate_limited", requestId);
+    this.name = "UpliftAIRateLimitError";
+  }
+};
+
+// src/http.ts
+var SDK_VERSION = "0.1.0";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var HttpClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  maxRetries;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  }
+  headers(extra) {
+    return {
+      Authorization: `Bearer ${this.apiKey}`,
+      "User-Agent": `upliftai-js/${SDK_VERSION}`,
+      Connection: "keep-alive",
+      ...extra
+    };
+  }
+  async fetchWithRetry(url, init, retriesLeft = this.maxRetries) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const res = await fetch(url, { ...init, signal: controller.signal });
+      if (!res.ok && retriesLeft > 0 && RETRYABLE_STATUS_CODES.has(res.status)) {
+        const delay = this.retryDelay(this.maxRetries - retriesLeft);
+        await sleep(delay);
+        return this.fetchWithRetry(url, init, retriesLeft - 1);
+      }
+      return res;
+    } catch (err) {
+      if (err instanceof DOMException && err.name === "AbortError") {
+        throw new UpliftAIError("Request timed out", void 0, "timeout");
+      }
+      if (retriesLeft > 0) {
+        const delay = this.retryDelay(this.maxRetries - retriesLeft);
+        await sleep(delay);
+        return this.fetchWithRetry(url, init, retriesLeft - 1);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  retryDelay(attempt) {
+    const base = Math.min(500 * Math.pow(2, attempt), 5e3);
+    const jitter = base * 0.25 * Math.random();
+    return base + jitter;
+  }
+  async postJSON(path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const res = await this.fetchWithRetry(url, {
+      method: "POST",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      await this.throwForStatus(res);
+    }
+    const data = await res.json();
+    return { data, headers: res.headers };
+  }
+  async postJSONForBuffer(path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const res = await this.fetchWithRetry(url, {
+      method: "POST",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      await this.throwForStatus(res);
+    }
+    const buffer = Buffer.from(await res.arrayBuffer());
+    return { buffer, headers: res.headers };
+  }
+  async postJSONForStream(path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const res = await this.fetchWithRetry(url, {
+      method: "POST",
+      headers: this.headers({ "Content-Type": "application/json" }),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      await this.throwForStatus(res);
+    }
+    if (!res.body) {
+      throw new UpliftAIError("Response body is null");
+    }
+    return { body: res.body, headers: res.headers };
+  }
+  async postMultipart(path, formData) {
+    const url = `${this.baseUrl}${path}`;
+    const res = await this.fetchWithRetry(url, {
+      method: "POST",
+      headers: this.headers(),
+      body: formData
+    });
+    if (!res.ok) {
+      await this.throwForStatus(res);
+    }
+    const data = await res.json();
+    return { data, headers: res.headers };
+  }
+  async get(path) {
+    const url = `${this.baseUrl}${path}`;
+    const res = await this.fetchWithRetry(url, {
+      method: "GET",
+      headers: this.headers()
+    });
+    if (!res.ok) {
+      await this.throwForStatus(res);
+    }
+    const data = await res.json();
+    return { data, headers: res.headers };
+  }
+  async getStream(path, query) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        url.searchParams.set(k, v);
+      }
+    }
+    const res = await this.fetchWithRetry(url.toString(), {
+      method: "GET",
+      headers: this.headers()
+    });
+    if (!res.ok) {
+      await this.throwForStatus(res);
+    }
+    if (!res.body) {
+      throw new UpliftAIError("Response body is null");
+    }
+    return { body: res.body, headers: res.headers };
+  }
+  async throwForStatus(res) {
+    const requestId = res.headers.get("x-uplift-ai-request-id") ?? void 0;
+    const body = await this.safeText(res);
+    if (res.status === 401) throw new UpliftAIAuthError(void 0, requestId);
+    if (res.status === 402) throw new UpliftAIInsufficientBalanceError(void 0, requestId);
+    if (res.status === 429) throw new UpliftAIRateLimitError(void 0, requestId);
+    throw new UpliftAIError(`HTTP ${res.status}: ${body}`, res.status, void 0, requestId);
+  }
+  async safeText(res) {
+    try {
+      return await res.text();
+    } catch {
+      return "";
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/tts.ts
+var import_node_stream = require("stream");
+
+// src/phrase-replacements.ts
+var PhraseReplacements = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async create(replacements) {
+    const { data } = await this.http.postJSON(
+      "/v1/synthesis/phrase-replacement-config",
+      { phraseReplacements: replacements }
+    );
+    return data;
+  }
+  async get(configId) {
+    const { data } = await this.http.get(
+      `/v1/synthesis/phrase-replacement-config/${configId}`
+    );
+    return data;
+  }
+  async list() {
+    const { data } = await this.http.get(
+      "/v1/synthesis/phrase-replacement-config"
+    );
+    return data;
+  }
+  async update(configId, replacements) {
+    const { data } = await this.http.postJSON(
+      `/v1/synthesis/phrase-replacement-config/${configId}`,
+      { phraseReplacements: replacements }
+    );
+    return data;
+  }
+};
+
+// src/ws.ts
+var import_node_crypto = require("crypto");
+var import_ws = __toESM(require("ws"));
+var TTSWebSocketImpl = class {
+  ws;
+  _sessionId = "";
+  streams = /* @__PURE__ */ new Map();
+  readyPromise;
+  readyResolve;
+  readyReject;
+  listeners = {
+    error: [],
+    close: []
+  };
+  constructor(url, apiKey) {
+    this.readyPromise = new Promise((resolve, reject) => {
+      this.readyResolve = resolve;
+      this.readyReject = reject;
+    });
+    this.ws = new import_ws.default(url, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    this.ws.on("message", (raw) => {
+      this.handleMessage(raw);
+    });
+    this.ws.on("error", (err) => {
+      this.readyReject(err);
+      for (const listener of this.listeners.error) {
+        try {
+          listener(err);
+        } catch (e) {
+          process.emitWarning(`Error in listener callback: ${e}`, "UpliftAI");
+        }
+      }
+      for (const stream of this.streams.values()) stream.error(err);
+    });
+    this.ws.on("close", (code, reason) => {
+      const reasonStr = reason.toString();
+      for (const listener of this.listeners.close) {
+        try {
+          listener(code, reasonStr);
+        } catch (e) {
+          process.emitWarning(`Error in listener callback: ${e}`, "UpliftAI");
+        }
+      }
+      for (const stream of this.streams.values()) {
+        stream.error(new UpliftAIError(`WebSocket closed: ${code} ${reasonStr}`));
+      }
+      this.streams.clear();
+    });
+  }
+  /** @internal Wait for the server `ready` message. Called by `tts.connect()`. */
+  async waitForReady() {
+    return this.readyPromise;
+  }
+  /** Current connection state. */
+  get readyState() {
+    switch (this.ws.readyState) {
+      case import_ws.default.CONNECTING:
+        return "connecting";
+      case import_ws.default.OPEN:
+        return "open";
+      case import_ws.default.CLOSING:
+        return "closing";
+      case import_ws.default.CLOSED:
+        return "closed";
+      default:
+        return "closed";
+    }
+  }
+  /** Server-assigned session ID, available after connection is ready. */
+  get sessionId() {
+    return this._sessionId;
+  }
+  on(event, listener) {
+    if (event === "error") {
+      this.listeners.error.push(listener);
+    } else {
+      this.listeners.close.push(listener);
+    }
+    return this;
+  }
+  /**
+   * Start a TTS stream. Sends text to the server and returns an async iterable
+   * of audio events (`audio_start`, `audio`, `audio_end`, `error`).
+   *
+   * Multiple streams can run concurrently on the same connection — each is
+   * demuxed by its `requestId`. For real-time conversational AI, break your
+   * LLM output into sentence-sized chunks and stream each one as it arrives.
+   * This gives the lowest time-to-first-audio since synthesis starts before
+   * the LLM finishes generating. If you use LiveKit, the UpliftAI plugin
+   * handles this sentence segmentation automatically.
+   *
+   * **Connection scope:** Use one WebSocket per conversation / user session.
+   * Don't multiplex unrelated use cases on a single connection — we may use
+   * connection-level context for prosody and other improvements in the future.
+   *
+   * @example // Simple usage
+   * const stream = ws.stream({ text: 'سلام', voiceId: 'v_meklc281' });
+   * for await (const event of stream) {
+   *   if (event.type === 'audio') speaker.write(event.audio);
+   * }
+   *
+   * @example // Real-time: stream sentence-by-sentence as LLM generates
+   * for await (const sentence of llm.streamSentences(prompt)) {
+   *   const stream = ws.stream({ text: sentence, voiceId });
+   *   for await (const event of stream) {
+   *     if (event.type === 'audio') speaker.write(event.audio);
+   *   }
+   * }
+   *
+   * @example // Overlap: fire next sentence before previous finishes
+   * const sentences = ['پہلا جملہ۔', 'دوسرا جملہ۔', 'تیسرا جملہ۔'];
+   * for (const sentence of sentences) {
+   *   const stream = ws.stream({ text: sentence, voiceId });
+   *   consume(stream); // don't await — let them overlap
+   * }
+   */
+  stream(request) {
+    const requestId = request.requestId ?? (0, import_node_crypto.randomUUID)();
+    const buffer = [];
+    let resolve = null;
+    let done = false;
+    let error = null;
+    const cleanup = () => {
+      this.streams.delete(requestId);
+      buffer.length = 0;
+      resolve = null;
+    };
+    const pending = {
+      push(event) {
+        if (done) return;
+        if (resolve) {
+          const r = resolve;
+          resolve = null;
+          r({ value: event, done: false });
+        } else {
+          buffer.push(event);
+        }
+      },
+      end() {
+        if (done) return;
+        done = true;
+        if (resolve) {
+          const r = resolve;
+          resolve = null;
+          r({ value: void 0, done: true });
+        }
+      },
+      error(err) {
+        if (done) return;
+        error = err;
+        done = true;
+        if (resolve) {
+          const r = resolve;
+          resolve = null;
+          r({ value: void 0, done: true });
+        }
+      }
+    };
+    this.streams.set(requestId, pending);
+    this.safeSend({
+      type: "synthesize",
+      requestId,
+      text: request.text,
+      voiceId: request.voiceId,
+      outputFormat: request.outputFormat ?? "PCM_22050_16"
+    });
+    const iterator = {
+      next() {
+        if (error || done) {
+          if (buffer.length > 0) {
+            return Promise.resolve({ value: buffer.shift(), done: false });
+          }
+          cleanup();
+          return Promise.resolve({ value: void 0, done: true });
+        }
+        if (buffer.length > 0) {
+          return Promise.resolve({ value: buffer.shift(), done: false });
+        }
+        return new Promise((r) => {
+          resolve = r;
+        });
+      },
+      return() {
+        done = true;
+        cleanup();
+        return Promise.resolve({ value: void 0, done: true });
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+    const stream = {
+      requestId,
+      /** Cancel this stream. Tells the server to stop generating and ends the iterator. */
+      cancel: async () => {
+        this.safeSend({ type: "cancel", requestId });
+        cleanup();
+        pending.end();
+      },
+      [Symbol.asyncIterator]() {
+        return iterator;
+      }
+    };
+    return stream;
+  }
+  /**
+   * Cancel all in-flight streams. Use for barge-in / interruption — when the
+   * user starts speaking and you need to immediately stop all TTS playback.
+   *
+   * Sends a cancel message to the server for each active stream and ends
+   * all iterators synchronously.
+   *
+   * @example
+   * ws.stream({ text: 'sentence 1...', voiceId });
+   * ws.stream({ text: 'sentence 2...', voiceId });
+   * // User interrupts!
+   * ws.cancelAll(); // both streams end immediately
+   */
+  cancelAll() {
+    for (const [requestId, stream] of this.streams) {
+      this.safeSend({ type: "cancel", requestId });
+      stream.end();
+    }
+    this.streams.clear();
+  }
+  /** Number of streams currently in-flight on this connection. */
+  get activeStreams() {
+    return this.streams.size;
+  }
+  /** Close the WebSocket connection. */
+  close() {
+    this.ws.close();
+  }
+  safeSend(msg) {
+    try {
+      this.ws.send(JSON.stringify(msg));
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      for (const stream of this.streams.values()) {
+        stream.error(new UpliftAIError(`WebSocket send failed: ${error.message}`));
+      }
+    }
+  }
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+    const type = msg.type;
+    if (type === "ready") {
+      this._sessionId = msg.sessionId;
+      this.readyResolve();
+      return;
+    }
+    const requestId = msg.requestId;
+    if (!requestId) return;
+    const stream = this.streams.get(requestId);
+    if (!stream) return;
+    switch (type) {
+      case "audio_start":
+        stream.push({
+          type: "audio_start",
+          requestId,
+          timestamp: msg.timestamp
+        });
+        break;
+      case "audio": {
+        let audio;
+        try {
+          audio = Buffer.from(msg.audio, "base64");
+        } catch {
+          stream.push({
+            type: "error",
+            requestId,
+            code: "decode_error",
+            message: "Failed to decode base64 audio data"
+          });
+          stream.end();
+          this.streams.delete(requestId);
+          return;
+        }
+        stream.push({
+          type: "audio",
+          requestId,
+          sequence: msg.sequence,
+          audio
+        });
+        break;
+      }
+      case "audio_end":
+        stream.push({
+          type: "audio_end",
+          requestId,
+          timestamp: msg.timestamp
+        });
+        stream.end();
+        this.streams.delete(requestId);
+        break;
+      case "error":
+        stream.push({
+          type: "error",
+          requestId,
+          code: msg.code,
+          message: msg.message
+        });
+        stream.end();
+        this.streams.delete(requestId);
+        break;
+    }
+  }
+};
+
+// src/tts.ts
+var DEFAULT_OUTPUT_FORMAT = "WAV_22050_32";
+function buildTTSBody(request) {
+  const body = {
+    text: request.text,
+    voiceId: request.voiceId,
+    outputFormat: request.outputFormat ?? DEFAULT_OUTPUT_FORMAT
+  };
+  if (request.phraseReplacementConfigId) body.phraseReplacementConfigId = request.phraseReplacementConfigId;
+  return body;
+}
+function parseAudioMetadata(headers) {
+  return {
+    requestId: headers.get("x-uplift-ai-request-id") ?? "",
+    duration: Number(headers.get("x-uplift-ai-audio-duration") ?? 0),
+    contentType: headers.get("content-type") ?? "application/octet-stream",
+    sampleRate: Number(headers.get("x-uplift-ai-sample-rate") ?? 0),
+    bitRate: Number(headers.get("x-uplift-ai-bit-rate") ?? 0)
+  };
+}
+function readableFromWeb(webStream) {
+  const reader = webStream.getReader();
+  return new import_node_stream.Readable({
+    async read() {
+      const { done, value } = await reader.read();
+      if (done) {
+        this.push(null);
+      } else {
+        this.push(Buffer.from(value));
+      }
+    },
+    destroy(_err, callback) {
+      reader.cancel().then(() => callback(null), callback);
+    }
+  });
+}
+var TTS = class {
+  http;
+  apiKey;
+  baseUrl;
+  wsBaseUrl;
+  /** Manage phrase replacement configs for pronunciation control. */
+  phraseReplacements;
+  constructor(http, apiKey, baseUrl, wsBaseUrl) {
+    this.http = http;
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl;
+    this.wsBaseUrl = wsBaseUrl;
+    this.phraseReplacements = new PhraseReplacements(http);
+  }
+  /**
+   * Synthesize text and return the full audio buffer.
+   *
+   * Generates the complete audio before returning. Faster end-to-end than
+   * streaming, but the caller must wait for the entire file. Best for
+   * batch/offline use cases where latency to first byte doesn't matter.
+   *
+   * @example
+   * const { audio, metadata } = await client.tts.create({ text: 'سلام', voiceId: 'v_meklc281' });
+   * fs.writeFileSync('output.mp3', audio);
+   */
+  async create(request) {
+    const { buffer, headers } = await this.http.postJSONForBuffer(
+      "/v1/synthesis/text-to-speech",
+      buildTTSBody(request)
+    );
+    return {
+      audio: buffer,
+      metadata: parseAudioMetadata(headers)
+    };
+  }
+  /**
+   * Synthesize text and return a readable stream of audio chunks.
+   *
+   * The first chunk arrives quickly, but total generation is slower than
+   * `create()`. Use this in latency-sensitive environments like live agents,
+   * phone calls, or real-time playback where you want audio to start playing
+   * immediately rather than waiting for the full file.
+   *
+   * @example
+   * const { stream, metadata } = await client.tts.createStream({ text: 'سلام', voiceId: 'v_meklc281' });
+   * for await (const chunk of stream) speaker.write(chunk);
+   */
+  async createStream(request) {
+    const { body, headers } = await this.http.postJSONForStream(
+      "/v1/synthesis/text-to-speech/stream",
+      buildTTSBody(request)
+    );
+    return {
+      stream: readableFromWeb(body),
+      metadata: parseAudioMetadata(headers)
+    };
+  }
+  /**
+   * Enqueue an async TTS job. Returns a `mediaId` to retrieve the audio later.
+   *
+   * Use for batch processing or when you don't need audio immediately.
+   * Poll or call `retrieve(mediaId)` when the audio is ready.
+   *
+   * @example
+   * const { mediaId, temporaryUrl } = await client.tts.enqueue({ text: 'سلام', voiceId: 'v_meklc281' });
+   * // retrieve server-side
+   * const audio = await client.tts.retrieve(mediaId);
+   * // or pass URL directly to a client/browser
+   * console.log(temporaryUrl);
+   */
+  async enqueue(request) {
+    const { data } = await this.http.postJSON(
+      "/v1/synthesis/text-to-speech-async",
+      buildTTSBody(request)
+    );
+    return {
+      ...data,
+      temporaryUrl: this.buildTemporaryUrl(data.mediaId, data.token)
+    };
+  }
+  /**
+   * Enqueue an async TTS job with streaming retrieval.
+   *
+   * Same as `enqueue()`, but when retrieved via `retrieve(mediaId)` the audio
+   * streams in chunks instead of arriving as a single buffer.
+   *
+   * @example
+   * const { mediaId, temporaryUrl } = await client.tts.enqueueStream({ text: 'سلام', voiceId: 'v_meklc281' });
+   * const stream = await client.tts.retrieve(mediaId);
+   * for await (const chunk of stream) speaker.write(chunk);
+   */
+  async enqueueStream(request) {
+    const { data } = await this.http.postJSON(
+      "/v1/synthesis/text-to-speech/stream-async",
+      buildTTSBody(request)
+    );
+    return {
+      ...data,
+      temporaryUrl: this.buildTemporaryUrl(data.mediaId, data.token)
+    };
+  }
+  /**
+   * Retrieve audio from a previously enqueued job.
+   *
+   * Returns the audio stream along with metadata (encoding, sample rate, etc.)
+   * from response headers.
+   *
+   * @example
+   * const { stream, metadata } = await client.tts.retrieve('<mediaId from enqueue>');
+   * console.log(metadata.contentType); // 'audio/mpeg'
+   * for await (const chunk of stream) fs.appendFileSync('out.mp3', chunk);
+   */
+  async retrieve(mediaId) {
+    const { body, headers } = await this.http.getStream(`/v1/synthesis/stream-audio/${mediaId}`);
+    return {
+      stream: readableFromWeb(body),
+      metadata: parseAudioMetadata(headers)
+    };
+  }
+  /**
+   * Open a persistent WebSocket connection for low-latency streaming TTS.
+   *
+   * Supports multiple concurrent streams on one connection, multiplexed by
+   * requestId. Use for real-time conversational AI, live agents, and
+   * interactive use cases. Resolves once the connection is ready.
+   *
+   * Open one connection per conversation or user session — don't share across
+   * unrelated contexts.
+   *
+   * @example
+   * const ws = await client.tts.connect();
+   * // Stream sentence-by-sentence as your LLM generates
+   * for await (const sentence of llm.streamSentences(prompt)) {
+   *   const stream = ws.stream({ text: sentence, voiceId: 'v_meklc281' });
+   *   for await (const event of stream) {
+   *     if (event.type === 'audio') speaker.write(event.audio);
+   *   }
+   * }
+   * ws.close();
+   */
+  buildTemporaryUrl(mediaId, token) {
+    return `${this.baseUrl}/v1/synthesis/stream-audio/${mediaId}?token=${encodeURIComponent(token)}`;
+  }
+  async connect() {
+    const wsUrl = `${this.wsBaseUrl}/v1/text-to-speech/multi-stream`;
+    const ws = new TTSWebSocketImpl(wsUrl, this.apiKey);
+    await ws.waitForReady();
+    return ws;
+  }
+};
+
+// src/stt.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+async function streamToBuffer(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    if (Buffer.isBuffer(chunk)) {
+      chunks.push(chunk);
+    } else if (chunk instanceof Uint8Array) {
+      chunks.push(Buffer.from(chunk));
+    } else if (typeof chunk === "string") {
+      chunks.push(Buffer.from(chunk));
+    } else {
+      throw new UpliftAIError("Unexpected chunk type in audio stream");
+    }
+  }
+  return Buffer.concat(chunks);
+}
+var STT = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Transcribe audio to text.
+   *
+   * Accepts a file path, Buffer, or readable stream as input.
+   *
+   * @example
+   * // From file path (extension used for content-type detection)
+   * const { transcript } = await client.stt.transcribe({ file: './call.mp3', model: 'scribe' });
+   *
+   * // From Buffer (pass fileName so the server knows the format)
+   * const { transcript } = await client.stt.transcribe({ file: audioBuffer, fileName: 'call.mp3', language: 'ur' });
+   */
+  async transcribe(request) {
+    const formData = new FormData();
+    if (typeof request.file === "string") {
+      const stream = (0, import_node_fs.createReadStream)(request.file);
+      const buffer = await streamToBuffer(stream);
+      formData.append("file", new Blob([buffer]), (0, import_node_path.basename)(request.file));
+    } else if (Buffer.isBuffer(request.file)) {
+      formData.append("file", new Blob([request.file]), request.fileName);
+    } else {
+      const buffer = await streamToBuffer(request.file);
+      formData.append("file", new Blob([buffer]), request.fileName);
+    }
+    if (request.model) formData.append("model", request.model);
+    if (request.language) formData.append("language", request.language);
+    if (request.domain) formData.append("domain", request.domain);
+    const { data } = await this.http.postMultipart(
+      "/v1/transcribe/speech-to-text",
+      formData
+    );
+    return data;
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.upliftai.org";
+var UpliftAI = class {
+  tts;
+  stt;
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? process.env.UPLIFTAI_API_KEY;
+    if (!apiKey) {
+      throw new UpliftAIError(
+        "apiKey is required. Pass it in options or set the UPLIFTAI_API_KEY environment variable.",
+        void 0,
+        "invalid_config"
+      );
+    }
+    const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    const http = new HttpClient({
+      baseUrl,
+      apiKey,
+      timeout: options.timeout,
+      maxRetries: options.maxRetries
+    });
+    const wsBaseUrl = baseUrl.replace(/^http/, "ws").replace(/^https/, "wss");
+    this.tts = new TTS(http, apiKey, baseUrl, wsBaseUrl);
+    this.stt = new STT(http);
+  }
+};
+
+// src/index.ts
+var index_default = UpliftAI;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UpliftAI,
+  UpliftAIAuthError,
+  UpliftAIError,
+  UpliftAIInsufficientBalanceError,
+  UpliftAIRateLimitError
+});
+//# sourceMappingURL=index.js.map