univoice 0.0.1

package/dist/chunk-HONGPTUH.js

@@ -0,0 +1,947 @@
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/tts/providers/doubao.ts
+import { Buffer as Buffer3 } from "buffer";
+import { randomUUID } from "crypto";
+
+// src/tts/base.ts
+var BaseTTS = class {
+  static {
+    __name(this, "BaseTTS");
+  }
+  apiKey;
+  baseUrl;
+  model;
+  voice;
+  speed;
+  volume;
+  pitch;
+  format;
+  language;
+  constructor(options) {
+    this.apiKey = options.apiKey || "";
+    this.baseUrl = options.baseUrl || "";
+    this.model = options.model || "default";
+    this.voice = options.voice || "default";
+    this.speed = options.speed || 1;
+    this.volume = options.volume || 1;
+    this.pitch = options.pitch || 1;
+    this.format = options.format || "mp3";
+    this.language = options.language || "zh-CN";
+  }
+  async listVoices() {
+    return [];
+  }
+  buildRequestOptions(request) {
+    return {
+      provider: this.constructor.name,
+      apiKey: this.apiKey,
+      baseUrl: this.baseUrl,
+      model: this.model,
+      voice: this.voice,
+      speed: this.speed,
+      volume: this.volume,
+      pitch: this.pitch,
+      format: this.format,
+      language: this.language,
+      ...request.options
+    };
+  }
+};
+
+// src/tts/factory.ts
+var providers = /* @__PURE__ */ new Map();
+function registerTTSProvider(type, provider) {
+  providers.set(type, provider);
+}
+__name(registerTTSProvider, "registerTTSProvider");
+function createTTS(options) {
+  const ProviderClass = providers.get(options.provider);
+  if (!ProviderClass) {
+    throw new Error(`TTS provider "${options.provider}" not found`);
+  }
+  return new ProviderClass(options);
+}
+__name(createTTS, "createTTS");
+function getTTSProviders() {
+  return Array.from(providers.keys());
+}
+__name(getTTSProviders, "getTTSProviders");
+async function synthesize(text, options) {
+  const tts = createTTS(options);
+  return tts.synthesize({ text, options });
+}
+__name(synthesize, "synthesize");
+
+// src/tts/protocols/volcengine.ts
+import { Buffer as Buffer2 } from "buffer";
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2[EventType2["None"] = 0] = "None";
+  EventType2[EventType2["StartConnection"] = 1] = "StartConnection";
+  EventType2[EventType2["FinishConnection"] = 2] = "FinishConnection";
+  EventType2[EventType2["ConnectionStarted"] = 50] = "ConnectionStarted";
+  EventType2[EventType2["ConnectionFailed"] = 51] = "ConnectionFailed";
+  EventType2[EventType2["ConnectionFinished"] = 52] = "ConnectionFinished";
+  EventType2[EventType2["StartSession"] = 100] = "StartSession";
+  EventType2[EventType2["CancelSession"] = 101] = "CancelSession";
+  EventType2[EventType2["FinishSession"] = 102] = "FinishSession";
+  EventType2[EventType2["SessionStarted"] = 150] = "SessionStarted";
+  EventType2[EventType2["SessionCanceled"] = 151] = "SessionCanceled";
+  EventType2[EventType2["SessionFinished"] = 152] = "SessionFinished";
+  EventType2[EventType2["SessionFailed"] = 153] = "SessionFailed";
+  EventType2[EventType2["UsageResponse"] = 154] = "UsageResponse";
+  EventType2[EventType2["TaskRequest"] = 200] = "TaskRequest";
+  EventType2[EventType2["UpdateConfig"] = 201] = "UpdateConfig";
+  EventType2[EventType2["AudioMuted"] = 250] = "AudioMuted";
+  EventType2[EventType2["SayHello"] = 300] = "SayHello";
+  EventType2[EventType2["TTSSentenceStart"] = 350] = "TTSSentenceStart";
+  EventType2[EventType2["TTSSentenceEnd"] = 351] = "TTSSentenceEnd";
+  EventType2[EventType2["TTSResponse"] = 352] = "TTSResponse";
+  EventType2[EventType2["TTSEnded"] = 359] = "TTSEnded";
+  EventType2[EventType2["PodcastRoundStart"] = 360] = "PodcastRoundStart";
+  EventType2[EventType2["PodcastRoundResponse"] = 361] = "PodcastRoundResponse";
+  EventType2[EventType2["PodcastRoundEnd"] = 362] = "PodcastRoundEnd";
+  EventType2[EventType2["ASRInfo"] = 450] = "ASRInfo";
+  EventType2[EventType2["ASRResponse"] = 451] = "ASRResponse";
+  EventType2[EventType2["ASREnded"] = 459] = "ASREnded";
+  EventType2[EventType2["ChatTTSText"] = 500] = "ChatTTSText";
+  EventType2[EventType2["ChatResponse"] = 550] = "ChatResponse";
+  EventType2[EventType2["ChatEnded"] = 559] = "ChatEnded";
+  EventType2[EventType2["SourceSubtitleStart"] = 650] = "SourceSubtitleStart";
+  EventType2[EventType2["SourceSubtitleResponse"] = 651] = "SourceSubtitleResponse";
+  EventType2[EventType2["SourceSubtitleEnd"] = 652] = "SourceSubtitleEnd";
+  EventType2[EventType2["TranslationSubtitleStart"] = 653] = "TranslationSubtitleStart";
+  EventType2[EventType2["TranslationSubtitleResponse"] = 654] = "TranslationSubtitleResponse";
+  EventType2[EventType2["TranslationSubtitleEnd"] = 655] = "TranslationSubtitleEnd";
+  return EventType2;
+})(EventType || {});
+var MsgType = /* @__PURE__ */ ((MsgType2) => {
+  MsgType2[MsgType2["Invalid"] = 0] = "Invalid";
+  MsgType2[MsgType2["FullClientRequest"] = 1] = "FullClientRequest";
+  MsgType2[MsgType2["AudioOnlyClient"] = 2] = "AudioOnlyClient";
+  MsgType2[MsgType2["FullServerResponse"] = 9] = "FullServerResponse";
+  MsgType2[MsgType2["AudioOnlyServer"] = 11] = "AudioOnlyServer";
+  MsgType2[MsgType2["FrontEndResultServer"] = 12] = "FrontEndResultServer";
+  MsgType2[MsgType2["Error"] = 15] = "Error";
+  return MsgType2;
+})(MsgType || {});
+function getEventTypeName(eventType) {
+  return EventType[eventType] || `invalid event type: ${eventType}`;
+}
+__name(getEventTypeName, "getEventTypeName");
+function getMsgTypeName(msgType) {
+  return MsgType[msgType] || `invalid message type: ${msgType}`;
+}
+__name(getMsgTypeName, "getMsgTypeName");
+function messageToString(msg) {
+  const eventStr = msg.event !== void 0 ? getEventTypeName(msg.event) : "NoEvent";
+  const typeStr = getMsgTypeName(msg.type);
+  switch (msg.type) {
+    case 11 /* AudioOnlyServer */:
+    case 2 /* AudioOnlyClient */:
+      if (msg.flag === 1 /* PositiveSeq */ || msg.flag === 3 /* NegativeSeq */) {
+        return `MsgType: ${typeStr}, EventType: ${eventStr}, Sequence: ${msg.sequence}, PayloadSize: ${msg.payload.length}`;
+      }
+      return `MsgType: ${typeStr}, EventType: ${eventStr}, PayloadSize: ${msg.payload.length}`;
+    case 15 /* Error */:
+      return `MsgType: ${typeStr}, EventType: ${eventStr}, ErrorCode: ${msg.errorCode}, Payload: ${new TextDecoder().decode(msg.payload)}`;
+    default:
+      if (msg.flag === 1 /* PositiveSeq */ || msg.flag === 3 /* NegativeSeq */) {
+        return `MsgType: ${typeStr}, EventType: ${eventStr}, Sequence: ${msg.sequence}, Payload: ${new TextDecoder().decode(msg.payload)}`;
+      }
+      return `MsgType: ${typeStr}, EventType: ${eventStr}, Payload: ${new TextDecoder().decode(msg.payload)}`;
+  }
+}
+__name(messageToString, "messageToString");
+function createMessage(msgType, flag) {
+  const msg = {
+    type: msgType,
+    flag,
+    version: 1 /* Version1 */,
+    headerSize: 1 /* HeaderSize4 */,
+    serialization: 1 /* JSON */,
+    compression: 0 /* None */,
+    payload: new Uint8Array(0)
+  };
+  Object.defineProperty(msg, "toString", {
+    enumerable: false,
+    configurable: true,
+    writable: true,
+    value: /* @__PURE__ */ __name(function() {
+      return messageToString(this);
+    }, "value")
+  });
+  return msg;
+}
+__name(createMessage, "createMessage");
+function marshalMessage(msg) {
+  const buffers = [];
+  const headerSize = 4 * msg.headerSize;
+  const header = new Uint8Array(headerSize);
+  header[0] = msg.version << 4 | msg.headerSize;
+  header[1] = msg.type << 4 | msg.flag;
+  header[2] = msg.serialization << 4 | msg.compression;
+  buffers.push(header);
+  const writers = getWriters(msg);
+  for (const writer of writers) {
+    const data = writer(msg);
+    if (data) buffers.push(data);
+  }
+  const totalLength = buffers.reduce((sum, buf) => sum + buf.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const buf of buffers) {
+    result.set(buf, offset);
+    offset += buf.length;
+  }
+  return result;
+}
+__name(marshalMessage, "marshalMessage");
+function unmarshalMessage(data) {
+  if (data.length < 3) {
+    throw new Error(`data too short: expected at least 3 bytes, got ${data.length}`);
+  }
+  let offset = 0;
+  const versionAndHeaderSize = data[offset++];
+  const typeAndFlag = data[offset++];
+  const serializationAndCompression = data[offset++];
+  const msg = {
+    version: versionAndHeaderSize >> 4,
+    headerSize: versionAndHeaderSize & 15,
+    type: typeAndFlag >> 4,
+    flag: typeAndFlag & 15,
+    serialization: serializationAndCompression >> 4,
+    compression: serializationAndCompression & 15,
+    payload: new Uint8Array(0)
+  };
+  Object.defineProperty(msg, "toString", {
+    enumerable: false,
+    configurable: true,
+    writable: true,
+    value: /* @__PURE__ */ __name(function() {
+      return messageToString(this);
+    }, "value")
+  });
+  offset = 4 * msg.headerSize;
+  const readers = getReaders(msg);
+  for (const reader of readers) {
+    offset = reader(msg, data, offset);
+  }
+  return msg;
+}
+__name(unmarshalMessage, "unmarshalMessage");
+function getWriters(msg) {
+  const writers = [];
+  if (msg.flag === 4 /* WithEvent */) {
+    writers.push(writeEvent, writeSessionId);
+  }
+  switch (msg.type) {
+    case 2 /* AudioOnlyClient */:
+    case 11 /* AudioOnlyServer */:
+    case 12 /* FrontEndResultServer */:
+    case 1 /* FullClientRequest */:
+    case 9 /* FullServerResponse */:
+      if (msg.flag === 1 /* PositiveSeq */ || msg.flag === 3 /* NegativeSeq */) {
+        writers.push(writeSequence);
+      }
+      break;
+    case 15 /* Error */:
+      writers.push(writeErrorCode);
+      break;
+    default:
+      throw new Error(`unsupported message type: ${msg.type}`);
+  }
+  writers.push(writePayload);
+  return writers;
+}
+__name(getWriters, "getWriters");
+function getReaders(msg) {
+  const readers = [];
+  switch (msg.type) {
+    case 2 /* AudioOnlyClient */:
+    case 11 /* AudioOnlyServer */:
+    case 12 /* FrontEndResultServer */:
+    case 1 /* FullClientRequest */:
+    case 9 /* FullServerResponse */:
+      if (msg.flag === 1 /* PositiveSeq */ || msg.flag === 3 /* NegativeSeq */) {
+        readers.push(readSequence);
+      }
+      break;
+    case 15 /* Error */:
+      readers.push(readErrorCode);
+      break;
+    default:
+      throw new Error(`unsupported message type: ${msg.type}`);
+  }
+  if (msg.flag === 4 /* WithEvent */) {
+    readers.push(readEvent, readSessionId, readConnectId);
+  }
+  readers.push(readPayload);
+  return readers;
+}
+__name(getReaders, "getReaders");
+function writeEvent(msg) {
+  if (msg.event === void 0) return null;
+  const buffer = new ArrayBuffer(4);
+  const view = new DataView(buffer);
+  view.setInt32(0, msg.event, false);
+  return new Uint8Array(buffer);
+}
+__name(writeEvent, "writeEvent");
+function writeSessionId(msg) {
+  if (msg.event === void 0) return null;
+  switch (msg.event) {
+    case 1 /* StartConnection */:
+    case 2 /* FinishConnection */:
+    case 50 /* ConnectionStarted */:
+    case 51 /* ConnectionFailed */:
+      return null;
+  }
+  const sessionId = msg.sessionId || "";
+  const sessionIdBytes = Buffer2.from(sessionId, "utf8");
+  const sizeBuffer = new ArrayBuffer(4);
+  const sizeView = new DataView(sizeBuffer);
+  sizeView.setUint32(0, sessionIdBytes.length, false);
+  const result = new Uint8Array(4 + sessionIdBytes.length);
+  result.set(new Uint8Array(sizeBuffer), 0);
+  result.set(sessionIdBytes, 4);
+  return result;
+}
+__name(writeSessionId, "writeSessionId");
+function writeSequence(msg) {
+  if (msg.sequence === void 0) return null;
+  const buffer = new ArrayBuffer(4);
+  const view = new DataView(buffer);
+  view.setInt32(0, msg.sequence, false);
+  return new Uint8Array(buffer);
+}
+__name(writeSequence, "writeSequence");
+function writeErrorCode(msg) {
+  if (msg.errorCode === void 0) return null;
+  const buffer = new ArrayBuffer(4);
+  const view = new DataView(buffer);
+  view.setUint32(0, msg.errorCode, false);
+  return new Uint8Array(buffer);
+}
+__name(writeErrorCode, "writeErrorCode");
+function writePayload(msg) {
+  const payloadSize = msg.payload.length;
+  const sizeBuffer = new ArrayBuffer(4);
+  const sizeView = new DataView(sizeBuffer);
+  sizeView.setUint32(0, payloadSize, false);
+  const result = new Uint8Array(4 + payloadSize);
+  result.set(new Uint8Array(sizeBuffer), 0);
+  result.set(msg.payload, 4);
+  return result;
+}
+__name(writePayload, "writePayload");
+function readEvent(msg, data, offset) {
+  if (offset + 4 > data.length) {
+    throw new Error("insufficient data for event");
+  }
+  const view = new DataView(data.buffer, data.byteOffset + offset, 4);
+  msg.event = view.getInt32(0, false);
+  return offset + 4;
+}
+__name(readEvent, "readEvent");
+function readSessionId(msg, data, initialOffset) {
+  let offset = initialOffset;
+  if (msg.event === void 0) return offset;
+  switch (msg.event) {
+    case 1 /* StartConnection */:
+    case 2 /* FinishConnection */:
+    case 50 /* ConnectionStarted */:
+    case 51 /* ConnectionFailed */:
+    case 52 /* ConnectionFinished */:
+      return offset;
+  }
+  if (offset + 4 > data.length) {
+    throw new Error("insufficient data for session ID size");
+  }
+  const view = new DataView(data.buffer, data.byteOffset + offset, 4);
+  const size = view.getUint32(0, false);
+  offset += 4;
+  if (size > 0) {
+    if (offset + size > data.length) {
+      throw new Error("insufficient data for session ID");
+    }
+    msg.sessionId = new TextDecoder().decode(data.slice(offset, offset + size));
+    offset += size;
+  }
+  return offset;
+}
+__name(readSessionId, "readSessionId");
+function readConnectId(msg, data, initialOffset) {
+  let offset = initialOffset;
+  if (msg.event === void 0) return offset;
+  switch (msg.event) {
+    case 50 /* ConnectionStarted */:
+    case 51 /* ConnectionFailed */:
+    case 52 /* ConnectionFinished */:
+      break;
+    default:
+      return offset;
+  }
+  if (offset + 4 > data.length) {
+    throw new Error("insufficient data for connect ID size");
+  }
+  const view = new DataView(data.buffer, data.byteOffset + offset, 4);
+  const size = view.getUint32(0, false);
+  offset += 4;
+  if (size > 0) {
+    if (offset + size > data.length) {
+      throw new Error("insufficient data for connect ID");
+    }
+    msg.connectId = new TextDecoder().decode(data.slice(offset, offset + size));
+    offset += size;
+  }
+  return offset;
+}
+__name(readConnectId, "readConnectId");
+function readSequence(msg, data, offset) {
+  if (offset + 4 > data.length) {
+    throw new Error("insufficient data for sequence");
+  }
+  const view = new DataView(data.buffer, data.byteOffset + offset, 4);
+  msg.sequence = view.getInt32(0, false);
+  return offset + 4;
+}
+__name(readSequence, "readSequence");
+function readErrorCode(msg, data, offset) {
+  if (offset + 4 > data.length) {
+    throw new Error("insufficient data for error code");
+  }
+  const view = new DataView(data.buffer, data.byteOffset + offset, 4);
+  msg.errorCode = view.getUint32(0, false);
+  return offset + 4;
+}
+__name(readErrorCode, "readErrorCode");
+function readPayload(msg, data, initialOffset) {
+  let offset = initialOffset;
+  if (offset + 4 > data.length) {
+    throw new Error("insufficient data for payload size");
+  }
+  const view = new DataView(data.buffer, data.byteOffset + offset, 4);
+  const size = view.getUint32(0, false);
+  offset += 4;
+  if (size > 0) {
+    if (offset + size > data.length) {
+      throw new Error("insufficient data for payload");
+    }
+    msg.payload = data.slice(offset, offset + size);
+    offset += size;
+  }
+  return offset;
+}
+__name(readPayload, "readPayload");
+var wsStates = /* @__PURE__ */ new Map();
+function getOrCreateState(ws) {
+  let state = wsStates.get(ws);
+  if (!state) {
+    state = { queue: [], callbacks: [] };
+    wsStates.set(ws, state);
+  }
+  return state;
+}
+__name(getOrCreateState, "getOrCreateState");
+function setupMessageHandler(ws) {
+  if (!wsStates.has(ws)) {
+    const state = getOrCreateState(ws);
+    ws.on("message", (data) => {
+      try {
+        let uint8Data;
+        if (Buffer2.isBuffer(data)) {
+          uint8Data = new Uint8Array(data);
+        } else if (data instanceof ArrayBuffer) {
+          uint8Data = new Uint8Array(data);
+        } else if (data instanceof Uint8Array) {
+          uint8Data = data;
+        } else {
+          throw new Error(`Unexpected WebSocket message type: ${typeof data}`);
+        }
+        const msg = unmarshalMessage(uint8Data);
+        if (state.callbacks.length > 0) {
+          const callback = state.callbacks.shift();
+          if (callback) callback(msg);
+        } else {
+          state.queue.push(msg);
+        }
+      } catch (error) {
+        throw new Error(`Error processing message: ${error}`);
+      }
+    });
+    ws.on("close", () => {
+      wsStates.delete(ws);
+    });
+  }
+}
+__name(setupMessageHandler, "setupMessageHandler");
+async function receiveMessage(ws) {
+  setupMessageHandler(ws);
+  return new Promise((resolve, reject) => {
+    const state = wsStates.get(ws);
+    if (!state) {
+      reject(new Error("WebSocket state not found"));
+      return;
+    }
+    if (state.queue.length > 0) {
+      const msg = state.queue.shift();
+      if (msg) {
+        resolve(msg);
+        return;
+      }
+    }
+    const errorHandler = /* @__PURE__ */ __name((error) => {
+      const index = state.callbacks.findIndex((cb) => cb === resolver);
+      if (index !== -1) {
+        state.callbacks.splice(index, 1);
+      }
+      reject(error);
+    }, "errorHandler");
+    const resolver = /* @__PURE__ */ __name((msg) => {
+      ws.removeListener("error", errorHandler);
+      resolve(msg);
+    }, "resolver");
+    state.callbacks.push(resolver);
+    ws.once("error", errorHandler);
+  });
+}
+__name(receiveMessage, "receiveMessage");
+async function waitForEvent(ws, msgType, eventType) {
+  const msg = await receiveMessage(ws);
+  if (msg.type !== msgType || msg.event !== eventType) {
+    throw new Error(
+      `Unexpected message: type=${getMsgTypeName(msg.type)}, event=${getEventTypeName(msg.event || 0)}`
+    );
+  }
+  return msg;
+}
+__name(waitForEvent, "waitForEvent");
+async function startConnection(ws) {
+  const msg = createMessage(1 /* FullClientRequest */, 4 /* WithEvent */);
+  msg.event = 1 /* StartConnection */;
+  msg.payload = new TextEncoder().encode("{}");
+  const data = marshalMessage(msg);
+  return new Promise((resolve, reject) => {
+    ws.send(data, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+__name(startConnection, "startConnection");
+async function finishConnection(ws) {
+  const msg = createMessage(1 /* FullClientRequest */, 4 /* WithEvent */);
+  msg.event = 2 /* FinishConnection */;
+  msg.payload = new TextEncoder().encode("{}");
+  const data = marshalMessage(msg);
+  return new Promise((resolve, reject) => {
+    ws.send(data, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+__name(finishConnection, "finishConnection");
+async function startSession(ws, payload, sessionId) {
+  const msg = createMessage(1 /* FullClientRequest */, 4 /* WithEvent */);
+  msg.event = 100 /* StartSession */;
+  msg.sessionId = sessionId;
+  msg.payload = payload;
+  const data = marshalMessage(msg);
+  return new Promise((resolve, reject) => {
+    ws.send(data, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+__name(startSession, "startSession");
+async function finishSession(ws, sessionId) {
+  const msg = createMessage(1 /* FullClientRequest */, 4 /* WithEvent */);
+  msg.event = 102 /* FinishSession */;
+  msg.sessionId = sessionId;
+  msg.payload = new TextEncoder().encode("{}");
+  const data = marshalMessage(msg);
+  return new Promise((resolve, reject) => {
+    ws.send(data, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+__name(finishSession, "finishSession");
+async function taskRequest(ws, payload, sessionId) {
+  const msg = createMessage(1 /* FullClientRequest */, 4 /* WithEvent */);
+  msg.event = 200 /* TaskRequest */;
+  msg.sessionId = sessionId;
+  msg.payload = payload;
+  const data = marshalMessage(msg);
+  return new Promise((resolve, reject) => {
+    ws.send(data, (error) => {
+      if (error) reject(error);
+      else resolve();
+    });
+  });
+}
+__name(taskRequest, "taskRequest");
+
+// src/tts/providers/doubao.ts
+import WebSocket from "ws";
+var DoubaoTTS = class extends BaseTTS {
+  static {
+    __name(this, "DoubaoTTS");
+  }
+  name = "doubao";
+  /** 火山引擎 App ID */
+  appId;
+  /** 火山引擎 Access Token */
+  accessToken;
+  /** 火山引擎 Resource ID */
+  resourceId;
+  /** 采样率 */
+  sampleRate;
+  /** 是否启用时间戳 */
+  enableTimestamp;
+  constructor(options) {
+    super(options);
+    this.appId = options.appId || "";
+    this.accessToken = options.accessToken || "";
+    this.resourceId = options.resourceId || "seed-tts-2.0";
+    this.sampleRate = options.sampleRate || 24e3;
+    this.enableTimestamp = options.enableTimestamp ?? false;
+    this.baseUrl = options.baseUrl || "wss://openspeech.bytedance.com/api/v3/tts/bidirection";
+    this.voice = options.voice || "zh_female_tianmeixiaoyuan_moon_bigtts";
+    this.format = options.format || "mp3";
+  }
+  /**
+   * 构建认证请求头
+   */
+  buildAuthHeaders() {
+    return {
+      "X-Api-App-Key": this.appId,
+      "X-Api-Access-Key": this.accessToken,
+      "X-Api-Resource-Id": this.resourceId,
+      "X-Api-Connect-Id": randomUUID()
+    };
+  }
+  /**
+   * 构建会话请求 payload
+   */
+  buildSessionPayload() {
+    const payload = {
+      user: {
+        uid: randomUUID()
+      },
+      req_params: {
+        speaker: this.voice,
+        audio_params: {
+          format: this.format,
+          sample_rate: this.sampleRate,
+          enable_timestamp: this.enableTimestamp
+        },
+        additions: JSON.stringify({
+          disable_markdown_filter: true
+        })
+      },
+      event: 100 /* StartSession */
+    };
+    return new TextEncoder().encode(JSON.stringify(payload));
+  }
+  /**
+   * 构建任务请求 payload
+   */
+  buildTaskPayload(text) {
+    const payload = {
+      user: {
+        uid: randomUUID()
+      },
+      req_params: {
+        speaker: this.voice,
+        audio_params: {
+          format: this.format,
+          sample_rate: this.sampleRate,
+          enable_timestamp: this.enableTimestamp
+        },
+        additions: JSON.stringify({
+          disable_markdown_filter: true
+        }),
+        text
+      },
+      event: 200 /* TaskRequest */
+    };
+    return new TextEncoder().encode(JSON.stringify(payload));
+  }
+  /**
+   * 合并多个 Uint8Array
+   */
+  concatArrays(arrays) {
+    const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+      result.set(arr, offset);
+      offset += arr.length;
+    }
+    return result;
+  }
+  /**
+   * 合成语音
+   */
+  async synthesize(request) {
+    const text = request.text;
+    const ws = new WebSocket(this.baseUrl, {
+      headers: this.buildAuthHeaders(),
+      skipUTF8Validation: true
+    });
+    await new Promise((resolve, reject) => {
+      ws.on("open", resolve);
+      ws.on("error", reject);
+    });
+    try {
+      await startConnection(ws);
+      await waitForEvent(ws, 9 /* FullServerResponse */, 50 /* ConnectionStarted */);
+      const sessionId = randomUUID();
+      const sessionPayload = this.buildSessionPayload();
+      await startSession(ws, sessionPayload, sessionId);
+      await waitForEvent(ws, 9 /* FullServerResponse */, 150 /* SessionStarted */);
+      const taskPayload = this.buildTaskPayload(text);
+      await taskRequest(ws, taskPayload, sessionId);
+      await finishSession(ws, sessionId);
+      const audioChunks = [];
+      while (true) {
+        const msg = await receiveMessage(ws);
+        switch (msg.type) {
+          case 11 /* AudioOnlyServer */:
+            audioChunks.push(msg.payload);
+            break;
+          case 9 /* FullServerResponse */:
+            break;
+          case 15 /* Error */:
+            throw new Error(
+              `TTS error: ${msg.errorCode}, ${new TextDecoder().decode(msg.payload)}`
+            );
+          default:
+            throw new Error(`Unexpected message type: ${msg.type}`);
+        }
+        if (msg.event === 152 /* SessionFinished */) {
+          break;
+        }
+      }
+      await finishConnection(ws);
+      await waitForEvent(ws, 9 /* FullServerResponse */, 52 /* ConnectionFinished */);
+      const audio = this.concatArrays(audioChunks);
+      if (audio.length === 0) {
+        throw new Error("No audio received from TTS service");
+      }
+      return {
+        audio: Buffer3.from(audio),
+        format: this.format
+      };
+    } finally {
+      ws.close();
+    }
+  }
+};
+registerTTSProvider("doubao", DoubaoTTS);
+
+// src/tts/providers/minimax.ts
+var MinimaxTTS = class extends BaseTTS {
+  static {
+    __name(this, "MinimaxTTS");
+  }
+  name = "minimax";
+  constructor(options) {
+    super(options);
+    this.baseUrl = options.baseUrl || "https://api.minimax.chat/v1";
+    this.model = options.model || "speech-01-turbo";
+  }
+  async synthesize(request) {
+    const opts = this.buildRequestOptions(request);
+    return {
+      audio: new Uint8Array(0),
+      format: opts.format || "mp3",
+      duration: 0
+    };
+  }
+};
+registerTTSProvider("minimax", MinimaxTTS);
+
+// src/tts/providers/qwen.ts
+var QwenTTS = class extends BaseTTS {
+  static {
+    __name(this, "QwenTTS");
+  }
+  name = "qwen";
+  constructor(options) {
+    super(options);
+    this.baseUrl = options.baseUrl || "https://dashscope.aliyuncs.com/api/v1";
+    this.model = options.model || "paraformer-realtime-v2";
+  }
+  async synthesize(request) {
+    const opts = this.buildRequestOptions(request);
+    return {
+      audio: new Uint8Array(0),
+      format: opts.format || "mp3",
+      duration: 0
+    };
+  }
+};
+registerTTSProvider("qwen", QwenTTS);
+
+// src/tts/providers/openai.ts
+var TTS1 = class extends BaseTTS {
+  static {
+    __name(this, "TTS1");
+  }
+  name = "openai";
+  constructor(options) {
+    super(options);
+    this.baseUrl = options.baseUrl || "https://api.openai.com/v1";
+    this.model = options.model || "tts-1";
+  }
+  async synthesize(request) {
+    const opts = this.buildRequestOptions(request);
+    return {
+      audio: new Uint8Array(0),
+      format: opts.format || "mp3",
+      duration: 0
+    };
+  }
+};
+registerTTSProvider("openai", TTS1);
+
+// src/tts/providers/gemini.ts
+var GeminiTTS = class extends BaseTTS {
+  static {
+    __name(this, "GeminiTTS");
+  }
+  name = "gemini";
+  constructor(options) {
+    super(options);
+    this.baseUrl = options.baseUrl || "https://generativelanguage.googleapis.com/v1beta";
+    this.model = options.model || "gemini-tts";
+  }
+  async synthesize(request) {
+    const opts = this.buildRequestOptions(request);
+    return {
+      audio: new Uint8Array(0),
+      format: opts.format || "mp3",
+      duration: 0
+    };
+  }
+};
+registerTTSProvider("gemini", GeminiTTS);
+
+// src/tts/utils/collect.ts
+import { Buffer as Buffer4 } from "buffer";
+async function collectAudio(response, options = {}) {
+  const { audio } = response;
+  const chunks = [];
+  if (isUint8Array(audio)) {
+    chunks.push(audio);
+  } else if (isBuffer(audio)) {
+    chunks.push(new Uint8Array(audio));
+  }
+  const result = concatUint8Arrays(chunks);
+  if (options.onComplete) {
+    options.onComplete(result);
+  }
+  return result;
+}
+__name(collectAudio, "collectAudio");
+function isUint8Array(value) {
+  return value instanceof Uint8Array;
+}
+__name(isUint8Array, "isUint8Array");
+function isBuffer(value) {
+  return Buffer4.isBuffer(value);
+}
+__name(isBuffer, "isBuffer");
+function concatUint8Arrays(arrays) {
+  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+__name(concatUint8Arrays, "concatUint8Arrays");
+
+// src/tts/utils/save.ts
+import { writeFile } from "fs/promises";
+async function saveAudio(response, options = {}) {
+  const { format } = response;
+  const timestamp = Date.now();
+  const filename = options.filename || `tts_${timestamp}.${format}`;
+  const filepath = options.directory ? `${options.directory}/${filename}` : filename;
+  let buffer;
+  if (response.audio instanceof Buffer) {
+    buffer = response.audio;
+  } else if (response.audio instanceof Uint8Array) {
+    buffer = Buffer.from(response.audio);
+  } else {
+    throw new Error("Invalid audio data");
+  }
+  await writeFile(filepath, buffer);
+  return filepath;
+}
+__name(saveAudio, "saveAudio");
+
+// src/tts/utils/play.ts
+import { spawn } from "child_process";
+async function playAudio(response, options = {}) {
+  const player = options.player || "afplay";
+  let buffer;
+  if (response.audio instanceof Buffer) {
+    buffer = response.audio;
+  } else if (response.audio instanceof Uint8Array) {
+    buffer = Buffer.from(response.audio);
+  } else {
+    throw new Error("Invalid audio data");
+  }
+  return new Promise((resolve, reject) => {
+    const proc = spawn(player, [], { stdio: ["pipe", "inherit", "inherit"] });
+    proc.stdin.write(buffer);
+    proc.stdin.end();
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Player exited with code ${code}`));
+      }
+    });
+    proc.on("error", reject);
+  });
+}
+__name(playAudio, "playAudio");
+
+// src/tts/utils/tee.ts
+async function teeAudio(response, options = {}) {
+  const audio = await collectAudio(response);
+  if (options.save) {
+    await saveAudio({ ...response, audio }, options.save);
+  }
+  if (options.play) {
+    await playAudio({ ...response, audio }, options.play);
+  }
+  return { ...response, audio };
+}
+__name(teeAudio, "teeAudio");
+
+export {
+  BaseTTS,
+  registerTTSProvider,
+  createTTS,
+  getTTSProviders,
+  synthesize,
+  collectAudio,
+  saveAudio,
+  playAudio,
+  teeAudio
+};
+//# sourceMappingURL=chunk-HONGPTUH.js.map