@cartesia/cartesia-js 0.0.4-alpha.0 → 1.0.0-alpha.2

package/dist/tts/websocket.cjs

@@ -0,0 +1,479 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw 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);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/tts/websocket.ts
+var websocket_exports = {};
+__export(websocket_exports, {
+  default: () => WebSocket
+});
+module.exports = __toCommonJS(websocket_exports);
+var import_emittery2 = __toESM(require("emittery"), 1);
+var import_human_id = require("human-id");
+var import_partysocket = require("partysocket");
+
+// src/lib/client.ts
+var import_cross_fetch = __toESM(require("cross-fetch"), 1);
+
+// src/lib/constants.ts
+var BASE_URL = "https://api.cartesia.ai/";
+var CARTESIA_VERSION = "2024-06-10";
+var constructApiUrl = (baseUrl, path, protocol) => {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  if (!protocol) {
+    return new URL(`${baseUrl}${normalizedPath}`);
+  }
+  if (!["http", "ws"].includes(protocol)) {
+    throw new Error(`Invalid protocol: ${protocol}`);
+  }
+  return new URL(`${baseUrl.replace(/^http/, protocol)}${normalizedPath}`);
+};
+
+// src/lib/client.ts
+var Client = class {
+  constructor(options = {}) {
+    if (!(options.apiKey || process.env.CARTESIA_API_KEY)) {
+      throw new Error("Missing Cartesia API key.");
+    }
+    this.apiKey = options.apiKey || process.env.CARTESIA_API_KEY;
+    this.baseUrl = options.baseUrl || BASE_URL;
+  }
+  fetch(path, options = {}) {
+    const url = constructApiUrl(this.baseUrl, path);
+    return (0, import_cross_fetch.default)(url.toString(), __spreadProps(__spreadValues({}, options), {
+      headers: __spreadValues({
+        "X-API-Key": this.apiKey,
+        "Cartesia-Version": CARTESIA_VERSION
+      }, options.headers)
+    }));
+  }
+};
+
+// src/tts/source.ts
+var import_emittery = __toESM(require("emittery"), 1);
+var _emitter, _buffer, _readIndex, _writeIndex, _closed, _sampleRate;
+var Source = class {
+  /**
+   * Create a new Source.
+   *
+   * @param options - Options for the Source.
+   * @param options.sampleRate - The sample rate of the audio.
+   */
+  constructor({ sampleRate }) {
+    __privateAdd(this, _emitter, new import_emittery.default());
+    __privateAdd(this, _buffer, void 0);
+    __privateAdd(this, _readIndex, 0);
+    __privateAdd(this, _writeIndex, 0);
+    __privateAdd(this, _closed, false);
+    __privateAdd(this, _sampleRate, void 0);
+    this.on = __privateGet(this, _emitter).on.bind(__privateGet(this, _emitter));
+    this.once = __privateGet(this, _emitter).once.bind(__privateGet(this, _emitter));
+    this.events = __privateGet(this, _emitter).events.bind(__privateGet(this, _emitter));
+    this.off = __privateGet(this, _emitter).off.bind(__privateGet(this, _emitter));
+    __privateSet(this, _sampleRate, sampleRate);
+    __privateSet(this, _buffer, new Float32Array(1024));
+  }
+  get sampleRate() {
+    return __privateGet(this, _sampleRate);
+  }
+  /**
+   * Append audio to the buffer.
+   *
+   * @param src The audio to append.
+   */
+  enqueue(src) {
+    return __async(this, null, function* () {
+      const requiredCapacity = __privateGet(this, _writeIndex) + src.length;
+      if (requiredCapacity > __privateGet(this, _buffer).length) {
+        let newCapacity = __privateGet(this, _buffer).length;
+        while (newCapacity < requiredCapacity) {
+          newCapacity *= 2;
+        }
+        const newBuffer = new Float32Array(newCapacity);
+        newBuffer.set(__privateGet(this, _buffer));
+        __privateSet(this, _buffer, newBuffer);
+      }
+      __privateGet(this, _buffer).set(src, __privateGet(this, _writeIndex));
+      __privateSet(this, _writeIndex, __privateGet(this, _writeIndex) + src.length);
+      yield __privateGet(this, _emitter).emit("enqueue");
+    });
+  }
+  /**
+   * Read audio from the buffer.
+   *
+   * @param dst The buffer to read the audio into.
+   * @returns The number of samples read. If the source is closed, this will be
+   * less than the length of the provided buffer.
+   */
+  read(dst) {
+    return __async(this, null, function* () {
+      const targetReadIndex = __privateGet(this, _readIndex) + dst.length;
+      while (!__privateGet(this, _closed) && targetReadIndex > __privateGet(this, _writeIndex)) {
+        yield __privateGet(this, _emitter).emit("wait");
+        yield Promise.race([
+          __privateGet(this, _emitter).once("enqueue"),
+          __privateGet(this, _emitter).once("close")
+        ]);
+        yield __privateGet(this, _emitter).emit("read");
+      }
+      const read = Math.min(dst.length, __privateGet(this, _writeIndex) - __privateGet(this, _readIndex));
+      dst.set(__privateGet(this, _buffer).subarray(__privateGet(this, _readIndex), __privateGet(this, _readIndex) + read));
+      __privateSet(this, _readIndex, __privateGet(this, _readIndex) + read);
+      return read;
+    });
+  }
+  /**
+   * Get the number of samples in a given duration.
+   *
+   * @param durationSecs The duration in seconds.
+   * @returns The number of samples.
+   */
+  durationToSampleCount(durationSecs) {
+    return Math.trunc(durationSecs * __privateGet(this, _sampleRate));
+  }
+  get buffer() {
+    return __privateGet(this, _buffer);
+  }
+  get readIndex() {
+    return __privateGet(this, _readIndex);
+  }
+  /**
+   * Close the source. This signals that no more audio will be enqueued.
+   *
+   * This will emit a "close" event.
+   *
+   * @returns A promise that resolves when the source is closed.
+   */
+  close() {
+    return __async(this, null, function* () {
+      __privateSet(this, _closed, true);
+      yield __privateGet(this, _emitter).emit("close");
+      __privateGet(this, _emitter).clearListeners();
+    });
+  }
+};
+_emitter = new WeakMap();
+_buffer = new WeakMap();
+_readIndex = new WeakMap();
+_writeIndex = new WeakMap();
+_closed = new WeakMap();
+_sampleRate = new WeakMap();
+
+// src/tts/utils.ts
+var import_base64_js = __toESM(require("base64-js"), 1);
+function base64ToArray(b64) {
+  const byteArrays = filterSentinel(b64).map((b) => import_base64_js.default.toByteArray(b));
+  const totalLength = byteArrays.reduce(
+    (acc, arr) => acc + arr.length / Float32Array.BYTES_PER_ELEMENT,
+    0
+  );
+  const result = new Float32Array(totalLength);
+  let offset = 0;
+  for (const arr of byteArrays) {
+    const floats = new Float32Array(arr.buffer);
+    result.set(floats, offset);
+    offset += floats.length;
+  }
+  return result;
+}
+function createMessageHandlerForContextId(contextId, handler) {
+  return (event) => {
+    if (typeof event.data !== "string") {
+      return;
+    }
+    const message = JSON.parse(event.data);
+    if (message.context_id !== contextId) {
+      return;
+    }
+    let chunk;
+    if (message.done) {
+      chunk = getSentinel();
+    } else {
+      chunk = message.data;
+    }
+    handler({ chunk, message: event.data });
+  };
+}
+function getSentinel() {
+  return null;
+}
+function isSentinel(x) {
+  return x === getSentinel();
+}
+function filterSentinel(collection) {
+  return collection.filter(
+    (x) => !isSentinel(x)
+  );
+}
+function getEmitteryCallbacks(emitter) {
+  return {
+    on: emitter.on.bind(emitter),
+    off: emitter.off.bind(emitter),
+    once: emitter.once.bind(emitter),
+    events: emitter.events.bind(emitter)
+  };
+}
+
+// src/tts/websocket.ts
+var _isConnected, _sampleRate2, _generateId, generateId_fn;
+var WebSocket = class extends Client {
+  /**
+   * Create a new WebSocket client.
+   *
+   * @param args - Arguments to pass to the Client constructor.
+   */
+  constructor({ sampleRate }, ...args) {
+    super(...args);
+    /**
+     * Generate a unique ID suitable for a streaming context.
+     *
+     * Not suitable for security purposes or as a primary key, since
+     * it lacks the amount of entropy required for those use cases.
+     *
+     * @returns A unique ID.
+     */
+    __privateAdd(this, _generateId);
+    __privateAdd(this, _isConnected, false);
+    __privateAdd(this, _sampleRate2, void 0);
+    __privateSet(this, _sampleRate2, sampleRate);
+  }
+  /**
+   * Send a message over the WebSocket in order to start a stream.
+   *
+   * @param inputs - Stream options.
+   * @param options - Options for the stream.
+   * @param options.timeout - The maximum time to wait for a chunk before cancelling the stream.
+   * If `0`, the stream will not time out.
+   * @returns A Source object that can be passed to a Player to play the audio.
+   */
+  send(inputs, { timeout = 0 } = {}) {
+    var _a, _b, _c, _d;
+    if (!__privateGet(this, _isConnected)) {
+      throw new Error("Not connected to WebSocket. Call .connect() first.");
+    }
+    const contextId = __privateMethod(this, _generateId, generateId_fn).call(this);
+    (_a = this.socket) == null ? void 0 : _a.send(
+      JSON.stringify(__spreadProps(__spreadValues({
+        context_id: contextId
+      }, inputs), {
+        output_format: {
+          container: "raw",
+          encoding: "pcm_f32le",
+          sample_rate: __privateGet(this, _sampleRate2)
+        }
+      }))
+    );
+    const emitter = new import_emittery2.default();
+    const source = new Source({
+      sampleRate: __privateGet(this, _sampleRate2)
+    });
+    const streamCompleteController = new AbortController();
+    let timeoutId = null;
+    if (timeout > 0) {
+      timeoutId = setTimeout(streamCompleteController.abort, timeout);
+    }
+    const handleMessage = createMessageHandlerForContextId(
+      contextId,
+      (_0) => __async(this, [_0], function* ({ chunk, message }) {
+        emitter.emit("message", message);
+        if (isSentinel(chunk)) {
+          yield source.close();
+          streamCompleteController.abort();
+          return;
+        }
+        yield source.enqueue(base64ToArray([chunk]));
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = setTimeout(streamCompleteController.abort, timeout);
+        }
+      })
+    );
+    (_b = this.socket) == null ? void 0 : _b.addEventListener("message", handleMessage, {
+      signal: streamCompleteController.signal
+    });
+    (_c = this.socket) == null ? void 0 : _c.addEventListener(
+      "close",
+      () => {
+        streamCompleteController.abort();
+      },
+      {
+        once: true
+      }
+    );
+    (_d = this.socket) == null ? void 0 : _d.addEventListener(
+      "error",
+      () => {
+        streamCompleteController.abort();
+      },
+      {
+        once: true
+      }
+    );
+    streamCompleteController.signal.addEventListener("abort", () => {
+      source.close();
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    });
+    return __spreadValues({ source }, getEmitteryCallbacks(emitter));
+  }
+  /**
+   * Authenticate and connect to a Cartesia streaming WebSocket.
+   *
+   * @returns A promise that resolves when the WebSocket is connected.
+   * @throws {Error} If the WebSocket fails to connect.
+   */
+  connect() {
+    const url = constructApiUrl(
+      this.baseUrl,
+      `/tts/websocket?cartesia_version=${CARTESIA_VERSION}`,
+      "ws"
+    );
+    url.searchParams.set("api_key", this.apiKey);
+    const emitter = new import_emittery2.default();
+    this.socket = new import_partysocket.WebSocket(url.toString());
+    this.socket.onopen = () => {
+      __privateSet(this, _isConnected, true);
+      emitter.emit("open");
+    };
+    this.socket.onclose = () => {
+      __privateSet(this, _isConnected, false);
+      emitter.emit("close");
+    };
+    return new Promise(
+      (resolve, reject) => {
+        var _a, _b, _c;
+        (_a = this.socket) == null ? void 0 : _a.addEventListener(
+          "open",
+          () => {
+            resolve(getEmitteryCallbacks(emitter));
+          },
+          {
+            once: true
+          }
+        );
+        const aborter = new AbortController();
+        (_b = this.socket) == null ? void 0 : _b.addEventListener(
+          "error",
+          () => {
+            aborter.abort();
+            reject(new Error("WebSocket failed to connect."));
+          },
+          {
+            signal: aborter.signal
+          }
+        );
+        (_c = this.socket) == null ? void 0 : _c.addEventListener(
+          "close",
+          () => {
+            aborter.abort();
+            reject(new Error("WebSocket closed before it could connect."));
+          },
+          {
+            signal: aborter.signal
+          }
+        );
+      }
+    );
+  }
+  /**
+   * Disconnect from the Cartesia streaming WebSocket.
+   */
+  disconnect() {
+    var _a;
+    (_a = this.socket) == null ? void 0 : _a.close();
+  }
+};
+_isConnected = new WeakMap();
+_sampleRate2 = new WeakMap();
+_generateId = new WeakSet();
+generateId_fn = function() {
+  return (0, import_human_id.humanId)({
+    separator: "-",
+    capitalize: false
+  });
+};

package/dist/tts/websocket.d.cts

@@ -0,0 +1,53 @@
+import * as emittery from 'emittery';
+import { WebSocket as WebSocket$1 } from 'partysocket';
+import { Client } from '../lib/client.cjs';
+import { WebSocketOptions, StreamRequest, EmitteryCallbacks, ConnectionEventData } from '../types/index.cjs';
+import Source from './source.cjs';
+
+declare class WebSocket extends Client {
+    #private;
+    socket?: WebSocket$1;
+    /**
+     * Create a new WebSocket client.
+     *
+     * @param args - Arguments to pass to the Client constructor.
+     */
+    constructor({ sampleRate }: WebSocketOptions, ...args: ConstructorParameters<typeof Client>);
+    /**
+     * Send a message over the WebSocket in order to start a stream.
+     *
+     * @param inputs - Stream options.
+     * @param options - Options for the stream.
+     * @param options.timeout - The maximum time to wait for a chunk before cancelling the stream.
+     * If `0`, the stream will not time out.
+     * @returns A Source object that can be passed to a Player to play the audio.
+     */
+    send(inputs: StreamRequest["inputs"], { timeout }?: StreamRequest["options"]): {
+        on: <Name extends keyof emittery.OmnipresentEventData | "message">(eventName: Name | readonly Name[], listener: (eventData: ({
+            message: string;
+        } & emittery.OmnipresentEventData)[Name]) => void | Promise<void>) => emittery.UnsubscribeFunction;
+        off: <Name_1 extends keyof emittery.OmnipresentEventData | "message">(eventName: Name_1 | readonly Name_1[], listener: (eventData: ({
+            message: string;
+        } & emittery.OmnipresentEventData)[Name_1]) => void | Promise<void>) => void;
+        once: <Name_2 extends keyof emittery.OmnipresentEventData | "message">(eventName: Name_2 | readonly Name_2[]) => emittery.EmitteryOncePromise<({
+            message: string;
+        } & emittery.OmnipresentEventData)[Name_2]>;
+        events: <Name_3 extends "message">(eventName: Name_3 | readonly Name_3[]) => AsyncIterableIterator<{
+            message: string;
+        }[Name_3]>;
+        source: Source;
+    };
+    /**
+     * Authenticate and connect to a Cartesia streaming WebSocket.
+     *
+     * @returns A promise that resolves when the WebSocket is connected.
+     * @throws {Error} If the WebSocket fails to connect.
+     */
+    connect(): Promise<EmitteryCallbacks<ConnectionEventData>>;
+    /**
+     * Disconnect from the Cartesia streaming WebSocket.
+     */
+    disconnect(): void;
+}
+
+export { WebSocket as default };

package/dist/tts/websocket.d.ts

@@ -0,0 +1,53 @@
+import * as emittery from 'emittery';
+import { WebSocket as WebSocket$1 } from 'partysocket';
+import { Client } from '../lib/client.js';
+import { WebSocketOptions, StreamRequest, EmitteryCallbacks, ConnectionEventData } from '../types/index.js';
+import Source from './source.js';
+
+declare class WebSocket extends Client {
+    #private;
+    socket?: WebSocket$1;
+    /**
+     * Create a new WebSocket client.
+     *
+     * @param args - Arguments to pass to the Client constructor.
+     */
+    constructor({ sampleRate }: WebSocketOptions, ...args: ConstructorParameters<typeof Client>);
+    /**
+     * Send a message over the WebSocket in order to start a stream.
+     *
+     * @param inputs - Stream options.
+     * @param options - Options for the stream.
+     * @param options.timeout - The maximum time to wait for a chunk before cancelling the stream.
+     * If `0`, the stream will not time out.
+     * @returns A Source object that can be passed to a Player to play the audio.
+     */
+    send(inputs: StreamRequest["inputs"], { timeout }?: StreamRequest["options"]): {
+        on: <Name extends keyof emittery.OmnipresentEventData | "message">(eventName: Name | readonly Name[], listener: (eventData: ({
+            message: string;
+        } & emittery.OmnipresentEventData)[Name]) => void | Promise<void>) => emittery.UnsubscribeFunction;
+        off: <Name_1 extends keyof emittery.OmnipresentEventData | "message">(eventName: Name_1 | readonly Name_1[], listener: (eventData: ({
+            message: string;
+        } & emittery.OmnipresentEventData)[Name_1]) => void | Promise<void>) => void;
+        once: <Name_2 extends keyof emittery.OmnipresentEventData | "message">(eventName: Name_2 | readonly Name_2[]) => emittery.EmitteryOncePromise<({
+            message: string;
+        } & emittery.OmnipresentEventData)[Name_2]>;
+        events: <Name_3 extends "message">(eventName: Name_3 | readonly Name_3[]) => AsyncIterableIterator<{
+            message: string;
+        }[Name_3]>;
+        source: Source;
+    };
+    /**
+     * Authenticate and connect to a Cartesia streaming WebSocket.
+     *
+     * @returns A promise that resolves when the WebSocket is connected.
+     * @throws {Error} If the WebSocket fails to connect.
+     */
+    connect(): Promise<EmitteryCallbacks<ConnectionEventData>>;
+    /**
+     * Disconnect from the Cartesia streaming WebSocket.
+     */
+    disconnect(): void;
+}
+
+export { WebSocket as default };

package/dist/tts/websocket.js

@@ -0,0 +1,11 @@
+import {
+  WebSocket
+} from "../chunk-3F5E46FT.js";
+import "../chunk-PQ6CIPFW.js";
+import "../chunk-JGP5BIUV.js";
+import "../chunk-XHTDPLFR.js";
+import "../chunk-RO7TY474.js";
+import "../chunk-WIFMLPT5.js";
+export {
+  WebSocket as default
+};

package/dist/types/index.d.cts

@@ -1,6 +1,55 @@
+import emittery__default from 'emittery';
+
 interface ClientOptions {
     apiKey?: string;
     baseUrl?: string;
 }
+type Sentinel = null;
+type Chunk = string | Sentinel;
+type ConnectionEventData = {
+    open: never;
+    close: never;
+};
+type StreamRequest = {
+    inputs: object;
+    options: {
+        timeout?: number;
+    };
+};
+type EmitteryCallbacks<T> = {
+    on: emittery__default<T>["on"];
+    off: emittery__default<T>["off"];
+    once: emittery__default<T>["once"];
+    events: emittery__default<T>["events"];
+};
+type CloneOptions = {
+    mode: "url";
+    link: string;
+} | {
+    mode: "clip";
+    clip: Blob;
+};
+type Voice = {
+    id: string;
+    name: string;
+    description: string;
+    embedding: number[];
+    is_public: boolean;
+    user_id: string;
+    created_at: string;
+};
+type CreateVoice = Pick<Voice, "name" | "description" | "embedding"> & Partial<Omit<Voice, "name" | "description" | "embedding">>;
+type CloneResponse = {
+    embedding: number[];
+};
+type WebSocketOptions = {
+    sampleRate: number;
+};
+type SourceEventData = {
+    enqueue: never;
+    close: never;
+    wait: never;
+    read: never;
+};
 
-export type { ClientOptions };
+export type { Chunk, ClientOptions, CloneOptions, CloneResponse, ConnectionEventData, CreateVoice, EmitteryCallbacks, Sentinel, SourceEventData, StreamRequest, Voice, WebSocketOptions };