@livekit/agents 0.0.0-20260120144724

package/dist/tts/stream_adapter.cjs

@@ -0,0 +1,105 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stream_adapter_exports = {};
+__export(stream_adapter_exports, {
+  StreamAdapter: () => StreamAdapter,
+  StreamAdapterWrapper: () => StreamAdapterWrapper
+});
+module.exports = __toCommonJS(stream_adapter_exports);
+var import_utils = require("../utils.cjs");
+var import_tts = require("./tts.cjs");
+class StreamAdapter extends import_tts.TTS {
+  #tts;
+  #sentenceTokenizer;
+  label;
+  constructor(tts, sentenceTokenizer) {
+    super(tts.sampleRate, tts.numChannels, { streaming: true });
+    this.#tts = tts;
+    this.#sentenceTokenizer = sentenceTokenizer;
+    this.label = this.#tts.label;
+    this.label = `tts.StreamAdapter<${this.#tts.label}>`;
+    this.#tts.on("metrics_collected", (metrics) => {
+      this.emit("metrics_collected", metrics);
+    });
+    this.#tts.on("error", (error) => {
+      this.emit("error", error);
+    });
+  }
+  synthesize(text, connOptions, abortSignal) {
+    return this.#tts.synthesize(text, connOptions, abortSignal);
+  }
+  stream(options) {
+    return new StreamAdapterWrapper(this.#tts, this.#sentenceTokenizer, options == null ? void 0 : options.connOptions);
+  }
+}
+class StreamAdapterWrapper extends import_tts.SynthesizeStream {
+  #tts;
+  #sentenceStream;
+  label;
+  constructor(tts, sentenceTokenizer, connOptions) {
+    super(tts, connOptions);
+    this.#tts = tts;
+    this.#sentenceStream = sentenceTokenizer.stream();
+    this.label = `tts.StreamAdapterWrapper<${this.#tts.label}>`;
+  }
+  async run() {
+    const forwardInput = async () => {
+      for await (const input of this.input) {
+        if (this.abortController.signal.aborted) break;
+        if (input === import_tts.SynthesizeStream.FLUSH_SENTINEL) {
+          this.#sentenceStream.flush();
+        } else {
+          this.#sentenceStream.pushText(input);
+        }
+      }
+      this.#sentenceStream.endInput();
+      this.#sentenceStream.close();
+    };
+    const synthesizeSentenceStream = async () => {
+      let task;
+      const tokenCompletionTasks = [];
+      for await (const ev of this.#sentenceStream) {
+        if (this.abortController.signal.aborted) break;
+        task = import_utils.Task.from(
+          (controller) => synthesize(ev.token, task, controller),
+          this.abortController
+        );
+        tokenCompletionTasks.push(task);
+      }
+      await Promise.all(tokenCompletionTasks.map((t) => t.result));
+      this.queue.put(import_tts.SynthesizeStream.END_OF_STREAM);
+    };
+    const synthesize = async (token, prevTask, controller) => {
+      const audioStream = this.#tts.synthesize(token, this.connOptions, this.abortSignal);
+      await (prevTask == null ? void 0 : prevTask.result);
+      if (controller.signal.aborted) return;
+      for await (const audio of audioStream) {
+        if (controller.signal.aborted) break;
+        this.queue.put(audio);
+      }
+    };
+    await Promise.all([forwardInput(), synthesizeSentenceStream()]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StreamAdapter,
+  StreamAdapterWrapper
+});
+//# sourceMappingURL=stream_adapter.cjs.map

package/dist/tts/stream_adapter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tts/stream_adapter.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2024 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { SentenceStream, SentenceTokenizer } from '../tokenize/index.js';\nimport type { APIConnectOptions } from '../types.js';\nimport { Task } from '../utils.js';\nimport type { ChunkedStream } from './tts.js';\nimport { SynthesizeStream, TTS } from './tts.js';\n\nexport class StreamAdapter extends TTS {\n  #tts: TTS;\n  #sentenceTokenizer: SentenceTokenizer;\n  label: string;\n\n  constructor(tts: TTS, sentenceTokenizer: SentenceTokenizer) {\n    super(tts.sampleRate, tts.numChannels, { streaming: true });\n    this.#tts = tts;\n    this.#sentenceTokenizer = sentenceTokenizer;\n    this.label = this.#tts.label;\n    this.label = `tts.StreamAdapter<${this.#tts.label}>`;\n\n    this.#tts.on('metrics_collected', (metrics) => {\n      this.emit('metrics_collected', metrics);\n    });\n    this.#tts.on('error', (error) => {\n      this.emit('error', error);\n    });\n  }\n\n  synthesize(\n    text: string,\n    connOptions?: APIConnectOptions,\n    abortSignal?: AbortSignal,\n  ): ChunkedStream {\n    return this.#tts.synthesize(text, connOptions, abortSignal);\n  }\n\n  stream(options?: { connOptions?: APIConnectOptions }): StreamAdapterWrapper {\n    return new StreamAdapterWrapper(this.#tts, this.#sentenceTokenizer, options?.connOptions);\n  }\n}\n\nexport class StreamAdapterWrapper extends SynthesizeStream {\n  #tts: TTS;\n  #sentenceStream: SentenceStream;\n  label: string;\n\n  constructor(tts: TTS, sentenceTokenizer: SentenceTokenizer, connOptions?: APIConnectOptions) {\n    super(tts, connOptions);\n    this.#tts = tts;\n    this.#sentenceStream = sentenceTokenizer.stream();\n    this.label = `tts.StreamAdapterWrapper<${this.#tts.label}>`;\n  }\n\n  protected async run() {\n    const forwardInput = async () => {\n      for await (const input of this.input) {\n        if (this.abortController.signal.aborted) break;\n\n        if (input === SynthesizeStream.FLUSH_SENTINEL) {\n          this.#sentenceStream.flush();\n        } else {\n          this.#sentenceStream.pushText(input);\n        }\n      }\n      this.#sentenceStream.endInput();\n      this.#sentenceStream.close();\n    };\n\n    const synthesizeSentenceStream = async () => {\n      let task: Task<void> | undefined;\n      const tokenCompletionTasks: Task<void>[] = [];\n\n      for await (const ev of this.#sentenceStream) {\n        if (this.abortController.signal.aborted) break;\n\n        // this will enable non-blocking synthesis of the stream of tokens\n        task = Task.from(\n          (controller) => synthesize(ev.token, task, controller),\n          this.abortController,\n        );\n\n        tokenCompletionTasks.push(task);\n      }\n\n      await Promise.all(tokenCompletionTasks.map((t) => t.result));\n      this.queue.put(SynthesizeStream.END_OF_STREAM);\n    };\n\n    const synthesize = async (\n      token: string,\n      prevTask: Task<void> | undefined,\n      controller: AbortController,\n    ) => {\n      const audioStream = this.#tts.synthesize(token, this.connOptions, this.abortSignal);\n\n      // wait for previous audio transcription to complete before starting\n      // to queuing audio frames of the current token\n      await prevTask?.result;\n      if (controller.signal.aborted) return;\n\n      for await (const audio of audioStream) {\n        if (controller.signal.aborted) break;\n        this.queue.put(audio);\n      }\n    };\n\n    await Promise.all([forwardInput(), synthesizeSentenceStream()]);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,mBAAqB;AAErB,iBAAsC;AAE/B,MAAM,sBAAsB,eAAI;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,KAAU,mBAAsC;AAC1D,UAAM,IAAI,YAAY,IAAI,aAAa,EAAE,WAAW,KAAK,CAAC;AAC1D,SAAK,OAAO;AACZ,SAAK,qBAAqB;AAC1B,SAAK,QAAQ,KAAK,KAAK;AACvB,SAAK,QAAQ,qBAAqB,KAAK,KAAK,KAAK;AAEjD,SAAK,KAAK,GAAG,qBAAqB,CAAC,YAAY;AAC7C,WAAK,KAAK,qBAAqB,OAAO;AAAA,IACxC,CAAC;AACD,SAAK,KAAK,GAAG,SAAS,CAAC,UAAU;AAC/B,WAAK,KAAK,SAAS,KAAK;AAAA,IAC1B,CAAC;AAAA,EACH;AAAA,EAEA,WACE,MACA,aACA,aACe;AACf,WAAO,KAAK,KAAK,WAAW,MAAM,aAAa,WAAW;AAAA,EAC5D;AAAA,EAEA,OAAO,SAAqE;AAC1E,WAAO,IAAI,qBAAqB,KAAK,MAAM,KAAK,oBAAoB,mCAAS,WAAW;AAAA,EAC1F;AACF;AAEO,MAAM,6BAA6B,4BAAiB;AAAA,EACzD;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,KAAU,mBAAsC,aAAiC;AAC3F,UAAM,KAAK,WAAW;AACtB,SAAK,OAAO;AACZ,SAAK,kBAAkB,kBAAkB,OAAO;AAChD,SAAK,QAAQ,4BAA4B,KAAK,KAAK,KAAK;AAAA,EAC1D;AAAA,EAEA,MAAgB,MAAM;AACpB,UAAM,eAAe,YAAY;AAC/B,uBAAiB,SAAS,KAAK,OAAO;AACpC,YAAI,KAAK,gBAAgB,OAAO,QAAS;AAEzC,YAAI,UAAU,4BAAiB,gBAAgB;AAC7C,eAAK,gBAAgB,MAAM;AAAA,QAC7B,OAAO;AACL,eAAK,gBAAgB,SAAS,KAAK;AAAA,QACrC;AAAA,MACF;AACA,WAAK,gBAAgB,SAAS;AAC9B,WAAK,gBAAgB,MAAM;AAAA,IAC7B;AAEA,UAAM,2BAA2B,YAAY;AAC3C,UAAI;AACJ,YAAM,uBAAqC,CAAC;AAE5C,uBAAiB,MAAM,KAAK,iBAAiB;AAC3C,YAAI,KAAK,gBAAgB,OAAO,QAAS;AAGzC,eAAO,kBAAK;AAAA,UACV,CAAC,eAAe,WAAW,GAAG,OAAO,MAAM,UAAU;AAAA,UACrD,KAAK;AAAA,QACP;AAEA,6BAAqB,KAAK,IAAI;AAAA,MAChC;AAEA,YAAM,QAAQ,IAAI,qBAAqB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;AAC3D,WAAK,MAAM,IAAI,4BAAiB,aAAa;AAAA,IAC/C;AAEA,UAAM,aAAa,OACjB,OACA,UACA,eACG;AACH,YAAM,cAAc,KAAK,KAAK,WAAW,OAAO,KAAK,aAAa,KAAK,WAAW;AAIlF,aAAM,qCAAU;AAChB,UAAI,WAAW,OAAO,QAAS;AAE/B,uBAAiB,SAAS,aAAa;AACrC,YAAI,WAAW,OAAO,QAAS;AAC/B,aAAK,MAAM,IAAI,KAAK;AAAA,MACtB;AAAA,IACF;AAEA,UAAM,QAAQ,IAAI,CAAC,aAAa,GAAG,yBAAyB,CAAC,CAAC;AAAA,EAChE;AACF;","names":[]}

package/dist/tts/stream_adapter.d.cts

@@ -0,0 +1,20 @@
+import type { SentenceTokenizer } from '../tokenize/index.js';
+import type { APIConnectOptions } from '../types.js';
+import type { ChunkedStream } from './tts.js';
+import { SynthesizeStream, TTS } from './tts.js';
+export declare class StreamAdapter extends TTS {
+    #private;
+    label: string;
+    constructor(tts: TTS, sentenceTokenizer: SentenceTokenizer);
+    synthesize(text: string, connOptions?: APIConnectOptions, abortSignal?: AbortSignal): ChunkedStream;
+    stream(options?: {
+        connOptions?: APIConnectOptions;
+    }): StreamAdapterWrapper;
+}
+export declare class StreamAdapterWrapper extends SynthesizeStream {
+    #private;
+    label: string;
+    constructor(tts: TTS, sentenceTokenizer: SentenceTokenizer, connOptions?: APIConnectOptions);
+    protected run(): Promise<void>;
+}
+//# sourceMappingURL=stream_adapter.d.ts.map

package/dist/tts/stream_adapter.d.ts

@@ -0,0 +1,20 @@
+import type { SentenceTokenizer } from '../tokenize/index.js';
+import type { APIConnectOptions } from '../types.js';
+import type { ChunkedStream } from './tts.js';
+import { SynthesizeStream, TTS } from './tts.js';
+export declare class StreamAdapter extends TTS {
+    #private;
+    label: string;
+    constructor(tts: TTS, sentenceTokenizer: SentenceTokenizer);
+    synthesize(text: string, connOptions?: APIConnectOptions, abortSignal?: AbortSignal): ChunkedStream;
+    stream(options?: {
+        connOptions?: APIConnectOptions;
+    }): StreamAdapterWrapper;
+}
+export declare class StreamAdapterWrapper extends SynthesizeStream {
+    #private;
+    label: string;
+    constructor(tts: TTS, sentenceTokenizer: SentenceTokenizer, connOptions?: APIConnectOptions);
+    protected run(): Promise<void>;
+}
+//# sourceMappingURL=stream_adapter.d.ts.map

package/dist/tts/stream_adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream_adapter.d.ts","sourceRoot":"","sources":["../../src/tts/stream_adapter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAkB,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAEjD,qBAAa,aAAc,SAAQ,GAAG;;IAGpC,KAAK,EAAE,MAAM,CAAC;gBAEF,GAAG,EAAE,GAAG,EAAE,iBAAiB,EAAE,iBAAiB;IAe1D,UAAU,CACR,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,iBAAiB,EAC/B,WAAW,CAAC,EAAE,WAAW,GACxB,aAAa;IAIhB,MAAM,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,iBAAiB,CAAA;KAAE,GAAG,oBAAoB;CAG5E;AAED,qBAAa,oBAAqB,SAAQ,gBAAgB;;IAGxD,KAAK,EAAE,MAAM,CAAC;gBAEF,GAAG,EAAE,GAAG,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,WAAW,CAAC,EAAE,iBAAiB;cAO3E,GAAG;CAuDpB"}

package/dist/tts/stream_adapter.js

@@ -0,0 +1,80 @@
+import { Task } from "../utils.js";
+import { SynthesizeStream, TTS } from "./tts.js";
+class StreamAdapter extends TTS {
+  #tts;
+  #sentenceTokenizer;
+  label;
+  constructor(tts, sentenceTokenizer) {
+    super(tts.sampleRate, tts.numChannels, { streaming: true });
+    this.#tts = tts;
+    this.#sentenceTokenizer = sentenceTokenizer;
+    this.label = this.#tts.label;
+    this.label = `tts.StreamAdapter<${this.#tts.label}>`;
+    this.#tts.on("metrics_collected", (metrics) => {
+      this.emit("metrics_collected", metrics);
+    });
+    this.#tts.on("error", (error) => {
+      this.emit("error", error);
+    });
+  }
+  synthesize(text, connOptions, abortSignal) {
+    return this.#tts.synthesize(text, connOptions, abortSignal);
+  }
+  stream(options) {
+    return new StreamAdapterWrapper(this.#tts, this.#sentenceTokenizer, options == null ? void 0 : options.connOptions);
+  }
+}
+class StreamAdapterWrapper extends SynthesizeStream {
+  #tts;
+  #sentenceStream;
+  label;
+  constructor(tts, sentenceTokenizer, connOptions) {
+    super(tts, connOptions);
+    this.#tts = tts;
+    this.#sentenceStream = sentenceTokenizer.stream();
+    this.label = `tts.StreamAdapterWrapper<${this.#tts.label}>`;
+  }
+  async run() {
+    const forwardInput = async () => {
+      for await (const input of this.input) {
+        if (this.abortController.signal.aborted) break;
+        if (input === SynthesizeStream.FLUSH_SENTINEL) {
+          this.#sentenceStream.flush();
+        } else {
+          this.#sentenceStream.pushText(input);
+        }
+      }
+      this.#sentenceStream.endInput();
+      this.#sentenceStream.close();
+    };
+    const synthesizeSentenceStream = async () => {
+      let task;
+      const tokenCompletionTasks = [];
+      for await (const ev of this.#sentenceStream) {
+        if (this.abortController.signal.aborted) break;
+        task = Task.from(
+          (controller) => synthesize(ev.token, task, controller),
+          this.abortController
+        );
+        tokenCompletionTasks.push(task);
+      }
+      await Promise.all(tokenCompletionTasks.map((t) => t.result));
+      this.queue.put(SynthesizeStream.END_OF_STREAM);
+    };
+    const synthesize = async (token, prevTask, controller) => {
+      const audioStream = this.#tts.synthesize(token, this.connOptions, this.abortSignal);
+      await (prevTask == null ? void 0 : prevTask.result);
+      if (controller.signal.aborted) return;
+      for await (const audio of audioStream) {
+        if (controller.signal.aborted) break;
+        this.queue.put(audio);
+      }
+    };
+    await Promise.all([forwardInput(), synthesizeSentenceStream()]);
+  }
+}
+export {
+  StreamAdapter,
+  StreamAdapterWrapper
+};
+//# sourceMappingURL=stream_adapter.js.map

package/dist/tts/stream_adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tts/stream_adapter.ts"],"sourcesContent":["// SPDX-FileCopyrightText: 2024 LiveKit, Inc.\n//\n// SPDX-License-Identifier: Apache-2.0\nimport type { SentenceStream, SentenceTokenizer } from '../tokenize/index.js';\nimport type { APIConnectOptions } from '../types.js';\nimport { Task } from '../utils.js';\nimport type { ChunkedStream } from './tts.js';\nimport { SynthesizeStream, TTS } from './tts.js';\n\nexport class StreamAdapter extends TTS {\n  #tts: TTS;\n  #sentenceTokenizer: SentenceTokenizer;\n  label: string;\n\n  constructor(tts: TTS, sentenceTokenizer: SentenceTokenizer) {\n    super(tts.sampleRate, tts.numChannels, { streaming: true });\n    this.#tts = tts;\n    this.#sentenceTokenizer = sentenceTokenizer;\n    this.label = this.#tts.label;\n    this.label = `tts.StreamAdapter<${this.#tts.label}>`;\n\n    this.#tts.on('metrics_collected', (metrics) => {\n      this.emit('metrics_collected', metrics);\n    });\n    this.#tts.on('error', (error) => {\n      this.emit('error', error);\n    });\n  }\n\n  synthesize(\n    text: string,\n    connOptions?: APIConnectOptions,\n    abortSignal?: AbortSignal,\n  ): ChunkedStream {\n    return this.#tts.synthesize(text, connOptions, abortSignal);\n  }\n\n  stream(options?: { connOptions?: APIConnectOptions }): StreamAdapterWrapper {\n    return new StreamAdapterWrapper(this.#tts, this.#sentenceTokenizer, options?.connOptions);\n  }\n}\n\nexport class StreamAdapterWrapper extends SynthesizeStream {\n  #tts: TTS;\n  #sentenceStream: SentenceStream;\n  label: string;\n\n  constructor(tts: TTS, sentenceTokenizer: SentenceTokenizer, connOptions?: APIConnectOptions) {\n    super(tts, connOptions);\n    this.#tts = tts;\n    this.#sentenceStream = sentenceTokenizer.stream();\n    this.label = `tts.StreamAdapterWrapper<${this.#tts.label}>`;\n  }\n\n  protected async run() {\n    const forwardInput = async () => {\n      for await (const input of this.input) {\n        if (this.abortController.signal.aborted) break;\n\n        if (input === SynthesizeStream.FLUSH_SENTINEL) {\n          this.#sentenceStream.flush();\n        } else {\n          this.#sentenceStream.pushText(input);\n        }\n      }\n      this.#sentenceStream.endInput();\n      this.#sentenceStream.close();\n    };\n\n    const synthesizeSentenceStream = async () => {\n      let task: Task<void> | undefined;\n      const tokenCompletionTasks: Task<void>[] = [];\n\n      for await (const ev of this.#sentenceStream) {\n        if (this.abortController.signal.aborted) break;\n\n        // this will enable non-blocking synthesis of the stream of tokens\n        task = Task.from(\n          (controller) => synthesize(ev.token, task, controller),\n          this.abortController,\n        );\n\n        tokenCompletionTasks.push(task);\n      }\n\n      await Promise.all(tokenCompletionTasks.map((t) => t.result));\n      this.queue.put(SynthesizeStream.END_OF_STREAM);\n    };\n\n    const synthesize = async (\n      token: string,\n      prevTask: Task<void> | undefined,\n      controller: AbortController,\n    ) => {\n      const audioStream = this.#tts.synthesize(token, this.connOptions, this.abortSignal);\n\n      // wait for previous audio transcription to complete before starting\n      // to queuing audio frames of the current token\n      await prevTask?.result;\n      if (controller.signal.aborted) return;\n\n      for await (const audio of audioStream) {\n        if (controller.signal.aborted) break;\n        this.queue.put(audio);\n      }\n    };\n\n    await Promise.all([forwardInput(), synthesizeSentenceStream()]);\n  }\n}\n"],"mappings":"AAKA,SAAS,YAAY;AAErB,SAAS,kBAAkB,WAAW;AAE/B,MAAM,sBAAsB,IAAI;AAAA,EACrC;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,KAAU,mBAAsC;AAC1D,UAAM,IAAI,YAAY,IAAI,aAAa,EAAE,WAAW,KAAK,CAAC;AAC1D,SAAK,OAAO;AACZ,SAAK,qBAAqB;AAC1B,SAAK,QAAQ,KAAK,KAAK;AACvB,SAAK,QAAQ,qBAAqB,KAAK,KAAK,KAAK;AAEjD,SAAK,KAAK,GAAG,qBAAqB,CAAC,YAAY;AAC7C,WAAK,KAAK,qBAAqB,OAAO;AAAA,IACxC,CAAC;AACD,SAAK,KAAK,GAAG,SAAS,CAAC,UAAU;AAC/B,WAAK,KAAK,SAAS,KAAK;AAAA,IAC1B,CAAC;AAAA,EACH;AAAA,EAEA,WACE,MACA,aACA,aACe;AACf,WAAO,KAAK,KAAK,WAAW,MAAM,aAAa,WAAW;AAAA,EAC5D;AAAA,EAEA,OAAO,SAAqE;AAC1E,WAAO,IAAI,qBAAqB,KAAK,MAAM,KAAK,oBAAoB,mCAAS,WAAW;AAAA,EAC1F;AACF;AAEO,MAAM,6BAA6B,iBAAiB;AAAA,EACzD;AAAA,EACA;AAAA,EACA;AAAA,EAEA,YAAY,KAAU,mBAAsC,aAAiC;AAC3F,UAAM,KAAK,WAAW;AACtB,SAAK,OAAO;AACZ,SAAK,kBAAkB,kBAAkB,OAAO;AAChD,SAAK,QAAQ,4BAA4B,KAAK,KAAK,KAAK;AAAA,EAC1D;AAAA,EAEA,MAAgB,MAAM;AACpB,UAAM,eAAe,YAAY;AAC/B,uBAAiB,SAAS,KAAK,OAAO;AACpC,YAAI,KAAK,gBAAgB,OAAO,QAAS;AAEzC,YAAI,UAAU,iBAAiB,gBAAgB;AAC7C,eAAK,gBAAgB,MAAM;AAAA,QAC7B,OAAO;AACL,eAAK,gBAAgB,SAAS,KAAK;AAAA,QACrC;AAAA,MACF;AACA,WAAK,gBAAgB,SAAS;AAC9B,WAAK,gBAAgB,MAAM;AAAA,IAC7B;AAEA,UAAM,2BAA2B,YAAY;AAC3C,UAAI;AACJ,YAAM,uBAAqC,CAAC;AAE5C,uBAAiB,MAAM,KAAK,iBAAiB;AAC3C,YAAI,KAAK,gBAAgB,OAAO,QAAS;AAGzC,eAAO,KAAK;AAAA,UACV,CAAC,eAAe,WAAW,GAAG,OAAO,MAAM,UAAU;AAAA,UACrD,KAAK;AAAA,QACP;AAEA,6BAAqB,KAAK,IAAI;AAAA,MAChC;AAEA,YAAM,QAAQ,IAAI,qBAAqB,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;AAC3D,WAAK,MAAM,IAAI,iBAAiB,aAAa;AAAA,IAC/C;AAEA,UAAM,aAAa,OACjB,OACA,UACA,eACG;AACH,YAAM,cAAc,KAAK,KAAK,WAAW,OAAO,KAAK,aAAa,KAAK,WAAW;AAIlF,aAAM,qCAAU;AAChB,UAAI,WAAW,OAAO,QAAS;AAE/B,uBAAiB,SAAS,aAAa;AACrC,YAAI,WAAW,OAAO,QAAS;AAC/B,aAAK,MAAM,IAAI,KAAK;AAAA,MACtB;AAAA,IACF;AAEA,UAAM,QAAQ,IAAI,CAAC,aAAa,GAAG,yBAAyB,CAAC,CAAC;AAAA,EAChE;AACF;","names":[]}

package/dist/tts/tts.cjs

@@ -0,0 +1,431 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tts_exports = {};
+__export(tts_exports, {
+  ChunkedStream: () => ChunkedStream,
+  SynthesizeStream: () => SynthesizeStream,
+  TTS: () => TTS
+});
+module.exports = __toCommonJS(tts_exports);
+var import_node_events = require("node:events");
+var import_exceptions = require("../_exceptions.cjs");
+var import_log = require("../log.cjs");
+var import_deferred_stream = require("../stream/deferred_stream.cjs");
+var import_telemetry = require("../telemetry/index.cjs");
+var import_types = require("../types.cjs");
+var import_utils = require("../utils.cjs");
+class TTS extends import_node_events.EventEmitter {
+  #capabilities;
+  #sampleRate;
+  #numChannels;
+  constructor(sampleRate, numChannels, capabilities) {
+    super();
+    this.#capabilities = capabilities;
+    this.#sampleRate = sampleRate;
+    this.#numChannels = numChannels;
+  }
+  /** Returns this TTS's capabilities */
+  get capabilities() {
+    return this.#capabilities;
+  }
+  /** Returns the sample rate of audio frames returned by this TTS */
+  get sampleRate() {
+    return this.#sampleRate;
+  }
+  /** Returns the channel count of audio frames returned by this TTS */
+  get numChannels() {
+    return this.#numChannels;
+  }
+  async close() {
+    return;
+  }
+}
+class SynthesizeStream {
+  static FLUSH_SENTINEL = Symbol("FLUSH_SENTINEL");
+  static END_OF_STREAM = Symbol("END_OF_STREAM");
+  input = new import_utils.AsyncIterableQueue();
+  queue = new import_utils.AsyncIterableQueue();
+  output = new import_utils.AsyncIterableQueue();
+  closed = false;
+  connOptions;
+  abortController = new AbortController();
+  deferredInputStream;
+  logger = (0, import_log.log)();
+  #tts;
+  #metricsPendingTexts = [];
+  #metricsText = "";
+  #monitorMetricsTask;
+  #ttsRequestSpan;
+  constructor(tts, connOptions = import_types.DEFAULT_API_CONNECT_OPTIONS) {
+    this.#tts = tts;
+    this.connOptions = connOptions;
+    this.deferredInputStream = new import_deferred_stream.DeferredReadableStream();
+    this.pumpInput();
+    this.abortController.signal.addEventListener("abort", () => {
+      this.deferredInputStream.detachSource();
+      if (!this.input.closed) this.input.close();
+      if (!this.output.closed) this.output.close();
+      this.closed = true;
+    });
+    (0, import_utils.startSoon)(() => this.mainTask().finally(() => this.queue.close()));
+  }
+  _mainTaskImpl = async (span) => {
+    this.#ttsRequestSpan = span;
+    span.setAttributes({
+      [import_telemetry.traceTypes.ATTR_TTS_STREAMING]: true,
+      [import_telemetry.traceTypes.ATTR_TTS_LABEL]: this.#tts.label
+    });
+    for (let i = 0; i < this.connOptions.maxRetry + 1; i++) {
+      try {
+        return await import_telemetry.tracer.startActiveSpan(
+          async (attemptSpan) => {
+            attemptSpan.setAttribute(import_telemetry.traceTypes.ATTR_RETRY_COUNT, i);
+            try {
+              return await this.run();
+            } catch (error) {
+              (0, import_telemetry.recordException)(attemptSpan, (0, import_utils.toError)(error));
+              throw error;
+            }
+          },
+          { name: "tts_request_run" }
+        );
+      } catch (error) {
+        if (error instanceof import_exceptions.APIError) {
+          const retryInterval = (0, import_types.intervalForRetry)(this.connOptions, i);
+          if (this.connOptions.maxRetry === 0 || !error.retryable) {
+            this.emitError({ error, recoverable: false });
+            throw error;
+          } else if (i === this.connOptions.maxRetry) {
+            this.emitError({ error, recoverable: false });
+            throw new import_exceptions.APIConnectionError({
+              message: `failed to generate TTS completion after ${this.connOptions.maxRetry + 1} attempts`,
+              options: { retryable: false }
+            });
+          } else {
+            this.logger.warn(
+              { tts: this.#tts.label, attempt: i + 1, error },
+              `failed to synthesize speech, retrying in  ${retryInterval}s`
+            );
+          }
+          if (retryInterval > 0) {
+            await (0, import_utils.delay)(retryInterval);
+          }
+        } else {
+          this.emitError({ error: (0, import_utils.toError)(error), recoverable: false });
+          throw error;
+        }
+      }
+    }
+  };
+  mainTask = async () => import_telemetry.tracer.startActiveSpan(async (span) => this._mainTaskImpl(span), {
+    name: "tts_request",
+    endOnExit: false
+  });
+  emitError({ error, recoverable }) {
+    this.#tts.emit("error", {
+      type: "tts_error",
+      timestamp: Date.now(),
+      label: this.#tts.label,
+      error,
+      recoverable
+    });
+  }
+  // NOTE(AJS-37): The implementation below uses an AsyncIterableQueue (`this.input`)
+  // bridged from a DeferredReadableStream (`this.deferredInputStream`) rather than
+  // consuming the stream directly.
+  //
+  // A full refactor to native Web Streams was considered but is currently deferred.
+  // The primary reason is to maintain architectural parity with the Python SDK,
+  // which is a key design goal for the project. This ensures a consistent developer
+  // experience across both platforms.
+  //
+  // For more context, see the discussion in GitHub issue # 844.
+  async pumpInput() {
+    const reader = this.deferredInputStream.stream.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done || value === SynthesizeStream.FLUSH_SENTINEL) {
+          break;
+        }
+        this.pushText(value);
+      }
+      this.endInput();
+    } catch (error) {
+      this.logger.error(error, "Error reading deferred input stream");
+    } finally {
+      reader.releaseLock();
+      if (!this.#monitorMetricsTask) {
+        this.output.close();
+      }
+    }
+  }
+  async monitorMetrics() {
+    const startTime = process.hrtime.bigint();
+    let audioDurationMs = 0;
+    let ttfb = BigInt(-1);
+    let requestId = "";
+    const emit = () => {
+      if (this.#metricsPendingTexts.length) {
+        const text = this.#metricsPendingTexts.shift();
+        const duration = process.hrtime.bigint() - startTime;
+        const roundedAudioDurationMs = Math.round(audioDurationMs);
+        const metrics = {
+          type: "tts_metrics",
+          timestamp: Date.now(),
+          requestId,
+          ttfbMs: ttfb === BigInt(-1) ? -1 : Math.trunc(Number(ttfb / BigInt(1e6))),
+          durationMs: Math.trunc(Number(duration / BigInt(1e6))),
+          charactersCount: text.length,
+          audioDurationMs: roundedAudioDurationMs,
+          cancelled: this.abortController.signal.aborted,
+          label: this.#tts.label,
+          streamed: false
+        };
+        if (this.#ttsRequestSpan) {
+          this.#ttsRequestSpan.setAttribute(import_telemetry.traceTypes.ATTR_TTS_METRICS, JSON.stringify(metrics));
+        }
+        this.#tts.emit("metrics_collected", metrics);
+      }
+    };
+    for await (const audio of this.queue) {
+      if (this.abortController.signal.aborted) {
+        break;
+      }
+      this.output.put(audio);
+      if (audio === SynthesizeStream.END_OF_STREAM) continue;
+      requestId = audio.requestId;
+      if (ttfb === BigInt(-1)) {
+        ttfb = process.hrtime.bigint() - startTime;
+      }
+      audioDurationMs += audio.frame.samplesPerChannel / audio.frame.sampleRate * 1e3;
+      if (audio.final) {
+        emit();
+      }
+    }
+    if (requestId) {
+      emit();
+    }
+    if (this.#ttsRequestSpan) {
+      this.#ttsRequestSpan.end();
+      this.#ttsRequestSpan = void 0;
+    }
+  }
+  updateInputStream(text) {
+    this.deferredInputStream.setSource(text);
+  }
+  /** Push a string of text to the TTS */
+  /** @deprecated Use `updateInputStream` instead */
+  pushText(text) {
+    if (!this.#monitorMetricsTask) {
+      this.#monitorMetricsTask = this.monitorMetrics();
+      this.#monitorMetricsTask.finally(() => this.output.close());
+    }
+    this.#metricsText += text;
+    if (this.input.closed || this.closed) {
+      return;
+    }
+    this.input.put(text);
+  }
+  /** Flush the TTS, causing it to process all pending text */
+  flush() {
+    if (this.#metricsText) {
+      this.#metricsPendingTexts.push(this.#metricsText);
+      this.#metricsText = "";
+    }
+    if (this.input.closed || this.closed) {
+      return;
+    }
+    this.input.put(SynthesizeStream.FLUSH_SENTINEL);
+  }
+  /** Mark the input as ended and forbid additional pushes */
+  endInput() {
+    this.flush();
+    if (this.input.closed || this.closed) {
+      return;
+    }
+    this.input.close();
+  }
+  next() {
+    return this.output.next();
+  }
+  get abortSignal() {
+    return this.abortController.signal;
+  }
+  /** Close both the input and output of the TTS stream */
+  close() {
+    this.abortController.abort();
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+}
+class ChunkedStream {
+  queue = new import_utils.AsyncIterableQueue();
+  output = new import_utils.AsyncIterableQueue();
+  closed = false;
+  #text;
+  #tts;
+  #ttsRequestSpan;
+  _connOptions;
+  logger = (0, import_log.log)();
+  abortController = new AbortController();
+  constructor(text, tts, connOptions = import_types.DEFAULT_API_CONNECT_OPTIONS, abortSignal) {
+    this.#text = text;
+    this.#tts = tts;
+    this._connOptions = connOptions;
+    if (abortSignal) {
+      abortSignal.addEventListener("abort", () => this.abortController.abort(), { once: true });
+    }
+    this.monitorMetrics();
+    Promise.resolve().then(() => this.mainTask().finally(() => this.queue.close()));
+  }
+  _mainTaskImpl = async (span) => {
+    this.#ttsRequestSpan = span;
+    span.setAttributes({
+      [import_telemetry.traceTypes.ATTR_TTS_STREAMING]: false,
+      [import_telemetry.traceTypes.ATTR_TTS_LABEL]: this.#tts.label
+    });
+    for (let i = 0; i < this._connOptions.maxRetry + 1; i++) {
+      try {
+        return await import_telemetry.tracer.startActiveSpan(
+          async (attemptSpan) => {
+            attemptSpan.setAttribute(import_telemetry.traceTypes.ATTR_RETRY_COUNT, i);
+            try {
+              return await this.run();
+            } catch (error) {
+              (0, import_telemetry.recordException)(attemptSpan, (0, import_utils.toError)(error));
+              throw error;
+            }
+          },
+          { name: "tts_request_run" }
+        );
+      } catch (error) {
+        if (error instanceof import_exceptions.APIError) {
+          const retryInterval = (0, import_types.intervalForRetry)(this._connOptions, i);
+          if (this._connOptions.maxRetry === 0 || !error.retryable) {
+            this.emitError({ error, recoverable: false });
+            throw error;
+          } else if (i === this._connOptions.maxRetry) {
+            this.emitError({ error, recoverable: false });
+            throw new import_exceptions.APIConnectionError({
+              message: `failed to generate TTS completion after ${this._connOptions.maxRetry + 1} attempts`,
+              options: { retryable: false }
+            });
+          } else {
+            this.logger.warn(
+              { tts: this.#tts.label, attempt: i + 1, error },
+              `failed to generate TTS completion, retrying in ${retryInterval}s`
+            );
+          }
+          if (retryInterval > 0) {
+            await (0, import_utils.delay)(retryInterval);
+          }
+        } else {
+          this.emitError({ error: (0, import_utils.toError)(error), recoverable: false });
+          throw error;
+        }
+      }
+    }
+  };
+  async mainTask() {
+    return import_telemetry.tracer.startActiveSpan(async (span) => this._mainTaskImpl(span), {
+      name: "tts_request",
+      endOnExit: false
+    });
+  }
+  emitError({ error, recoverable }) {
+    this.#tts.emit("error", {
+      type: "tts_error",
+      timestamp: Date.now(),
+      label: this.#tts.label,
+      error,
+      recoverable
+    });
+  }
+  get inputText() {
+    return this.#text;
+  }
+  get abortSignal() {
+    return this.abortController.signal;
+  }
+  async monitorMetrics() {
+    const startTime = process.hrtime.bigint();
+    let audioDurationMs = 0;
+    let ttfb = BigInt(-1);
+    let requestId = "";
+    for await (const audio of this.queue) {
+      this.output.put(audio);
+      requestId = audio.requestId;
+      if (ttfb === BigInt(-1)) {
+        ttfb = process.hrtime.bigint() - startTime;
+      }
+      audioDurationMs += audio.frame.samplesPerChannel / audio.frame.sampleRate * 1e3;
+    }
+    this.output.close();
+    const duration = process.hrtime.bigint() - startTime;
+    const metrics = {
+      type: "tts_metrics",
+      timestamp: Date.now(),
+      requestId,
+      ttfbMs: ttfb === BigInt(-1) ? -1 : Math.trunc(Number(ttfb / BigInt(1e6))),
+      durationMs: Math.trunc(Number(duration / BigInt(1e6))),
+      charactersCount: this.#text.length,
+      audioDurationMs: Math.round(audioDurationMs),
+      cancelled: false,
+      // TODO(AJS-186): support ChunkedStream with 1.0 - add this.abortController.signal.aborted here
+      label: this.#tts.label,
+      streamed: false
+    };
+    if (this.#ttsRequestSpan) {
+      this.#ttsRequestSpan.setAttribute(import_telemetry.traceTypes.ATTR_TTS_METRICS, JSON.stringify(metrics));
+      this.#ttsRequestSpan.end();
+      this.#ttsRequestSpan = void 0;
+    }
+    this.#tts.emit("metrics_collected", metrics);
+  }
+  /** Collect every frame into one in a single call */
+  async collect() {
+    const frames = [];
+    for await (const event of this) {
+      frames.push(event.frame);
+    }
+    return (0, import_utils.mergeFrames)(frames);
+  }
+  next() {
+    return this.output.next();
+  }
+  /** Close both the input and output of the TTS stream */
+  close() {
+    if (!this.queue.closed) this.queue.close();
+    if (!this.output.closed) this.output.close();
+    if (!this.abortController.signal.aborted) this.abortController.abort();
+    this.closed = true;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChunkedStream,
+  SynthesizeStream,
+  TTS
+});
+//# sourceMappingURL=tts.cjs.map