@voiceloop/web-sdk 0.2.0

package/dist/index.cjs

@@ -0,0 +1,642 @@
+"use strict";
+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 __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 __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  MIC_SAMPLE_RATE: () => MIC_SAMPLE_RATE,
+  TTS_SAMPLE_RATE: () => TTS_SAMPLE_RATE,
+  VoiceLoopClient: () => VoiceLoopClient,
+  clearLog: () => clearLog,
+  createInitialState: () => createInitialState,
+  createPcmPlayer: () => createPcmPlayer,
+  createStateMachineContext: () => createStateMachineContext,
+  formatForCopy: () => formatForCopy,
+  getEntries: () => getEntries,
+  log: () => log,
+  logError: () => logError,
+  reduceServerEvent: () => reduceServerEvent,
+  startMicCapture: () => startMicCapture,
+  subscribe: () => subscribe,
+  warn: () => warn
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/logger.ts
+var MAX_ENTRIES = 300;
+var seq = 0;
+var entries = [];
+var listeners = /* @__PURE__ */ new Set();
+function emit() {
+  listeners.forEach((fn) => fn());
+}
+function log(tag, msg, detail, level = "info") {
+  entries.push({ id: seq++, ts: Date.now(), level, tag, msg, detail });
+  if (entries.length > MAX_ENTRIES) entries.splice(0, entries.length - MAX_ENTRIES);
+  emit();
+}
+function warn(tag, msg, detail) {
+  log(tag, msg, detail, "warn");
+}
+function logError(tag, msg, detail) {
+  log(tag, msg, detail, "error");
+}
+function getEntries() {
+  return entries;
+}
+function clearLog() {
+  entries.length = 0;
+  seq = 0;
+  emit();
+}
+function subscribe(fn) {
+  listeners.add(fn);
+  return () => listeners.delete(fn);
+}
+function formatForCopy() {
+  return entries.map((e) => {
+    const d = new Date(e.ts);
+    const ts = [
+      d.getHours().toString().padStart(2, "0"),
+      d.getMinutes().toString().padStart(2, "0"),
+      d.getSeconds().toString().padStart(2, "0")
+    ].join(":") + "." + d.getMilliseconds().toString().padStart(3, "0");
+    const detail = e.detail ? `  ${e.detail}` : "";
+    return `[${ts}] ${e.tag.padEnd(8)} ${e.msg}${detail}`;
+  }).join("\n");
+}
+
+// src/audio.ts
+var MIC_SAMPLE_RATE = 16e3;
+var TTS_SAMPLE_RATE = 24e3;
+var SCRIPT_PROCESSOR_FRAMES = 1024;
+async function startMicCapture(onPcm) {
+  const stream = await navigator.mediaDevices.getUserMedia({
+    audio: {
+      sampleRate: MIC_SAMPLE_RATE,
+      channelCount: 1,
+      echoCancellation: true,
+      noiseSuppression: true,
+      autoGainControl: true
+    }
+  });
+  const ctx = new AudioContext({ sampleRate: MIC_SAMPLE_RATE });
+  const source = ctx.createMediaStreamSource(stream);
+  const processor = ctx.createScriptProcessor(SCRIPT_PROCESSOR_FRAMES, 1, 1);
+  let lastVolume = 0;
+  processor.onaudioprocess = (e) => {
+    const f32 = e.inputBuffer.getChannelData(0);
+    let sum = 0;
+    for (let i = 0; i < f32.length; i++) sum += f32[i] * f32[i];
+    lastVolume = Math.min(1, Math.sqrt(sum / f32.length) * 10);
+    const i16 = new Int16Array(f32.length);
+    for (let i = 0; i < f32.length; i++) {
+      i16[i] = Math.max(-32768, Math.min(32767, f32[i] * 32768));
+    }
+    onPcm(i16.buffer);
+  };
+  source.connect(processor);
+  processor.connect(ctx.destination);
+  return {
+    stop() {
+      processor.disconnect();
+      source.disconnect();
+      ctx.close();
+      stream.getTracks().forEach((t) => t.stop());
+      lastVolume = 0;
+    },
+    getVolume: () => lastVolume
+  };
+}
+function createPcmPlayer() {
+  let ctx = null;
+  let nextPlayTime = 0;
+  function ensureCtx() {
+    if (!ctx) ctx = new AudioContext({ sampleRate: TTS_SAMPLE_RATE });
+    if (ctx.state === "suspended") ctx.resume();
+    return ctx;
+  }
+  return {
+    resume() {
+      ensureCtx();
+    },
+    enqueue(pcm) {
+      const ac = ensureCtx();
+      const byteLen = pcm.byteLength & ~1;
+      if (byteLen === 0) return;
+      const buf = new ArrayBuffer(byteLen);
+      new Uint8Array(buf).set(pcm.subarray(0, byteLen));
+      const i16 = new Int16Array(buf);
+      const f32 = new Float32Array(i16.length);
+      for (let i = 0; i < i16.length; i++) f32[i] = i16[i] / 32768;
+      const audioBuf = ac.createBuffer(1, f32.length, TTS_SAMPLE_RATE);
+      audioBuf.copyToChannel(f32, 0);
+      const src = ac.createBufferSource();
+      src.buffer = audioBuf;
+      src.connect(ac.destination);
+      const startAt = Math.max(ac.currentTime, nextPlayTime);
+      src.start(startAt);
+      nextPlayTime = startAt + audioBuf.duration;
+    },
+    flush() {
+      if (ctx) {
+        ctx.close();
+        ctx = null;
+      }
+      nextPlayTime = 0;
+    }
+  };
+}
+
+// src/state-machine.ts
+function createStateMachineContext() {
+  return {
+    assistantBubbleOpen: false,
+    userTurnActive: false,
+    incompleteAccum: "",
+    hasIncompleteUserTurn: false,
+    preLLMText: ""
+  };
+}
+function patch(state, p) {
+  return __spreadValues(__spreadValues({}, state), p);
+}
+function finaliseLastUtterance(state, role, finalText) {
+  const list = [...state.utterances];
+  for (let i = list.length - 1; i >= 0; i--) {
+    if (list[i].role === role && list[i].partial) {
+      list[i] = __spreadProps(__spreadValues({}, list[i]), {
+        text: finalText != null ? finalText : list[i].text,
+        partial: false,
+        fillerPrefix: void 0
+      });
+      break;
+    }
+  }
+  return __spreadProps(__spreadValues({}, state), { utterances: list });
+}
+function upsertAssistantBubble(state, update) {
+  const list = [...state.utterances];
+  for (let i = list.length - 1; i >= 0; i--) {
+    if (list[i].role === "assistant" && list[i].partial) {
+      list[i] = update(list[i]);
+      return __spreadProps(__spreadValues({}, state), { utterances: list });
+    }
+  }
+  const created = update(null);
+  return __spreadProps(__spreadValues({}, state), { utterances: [...list, created] });
+}
+function reduceServerEvent(state, ctx, evt) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  ctx = __spreadValues({}, ctx);
+  const effects = [];
+  switch (evt.type) {
+    case "session.config":
+      log("session", `config  brain=${evt.brain_mode}  vad_stop=${evt.turn_policy.vad_stop_secs * 1e3}ms  eot=${evt.turn_policy.eot_strategy}  smart_eot=${evt.capabilities.smart_eot}`);
+      state = patch(state, { session: "idle", error: null });
+      break;
+    case "transcript.partial": {
+      state = patch(state, { session: "listening" });
+      const list = [...state.utterances];
+      const last = list.length > 0 ? list[list.length - 1] : null;
+      const prefix = ctx.incompleteAccum;
+      const display = prefix ? prefix + evt.text : evt.text;
+      if ((last == null ? void 0 : last.role) === "user" && last.partial) {
+        list[list.length - 1] = __spreadProps(__spreadValues({}, last), { text: display });
+      } else {
+        list.push({ role: "user", text: display, partial: true });
+      }
+      state = __spreadProps(__spreadValues({}, state), { utterances: list });
+      break;
+    }
+    case "transcript.final": {
+      const prefix = ctx.incompleteAccum;
+      const display = prefix ? prefix + evt.text : evt.text;
+      log("asr", `final  "${evt.text}"`);
+      ctx.preLLMText = ctx.preLLMText ? ctx.preLLMText + display : display;
+      ctx.userTurnActive = false;
+      break;
+    }
+    case "transcript.timing":
+      log("asr", `timing  wait=${evt.wait_ms}ms`);
+      {
+        const list = [...state.utterances];
+        for (let i = list.length - 1; i >= 0; i--) {
+          if (list[i].role === "user") {
+            const prev = list[i];
+            list[i] = __spreadProps(__spreadValues({}, prev), { waitTimes: [...(_a = prev.waitTimes) != null ? _a : [], evt.wait_ms] });
+            break;
+          }
+        }
+        state = __spreadProps(__spreadValues({}, state), { utterances: list });
+      }
+      break;
+    case "transcript.incomplete":
+      log("asr", `incomplete  "${evt.text}"  wait=${evt.wait_ms}ms`);
+      ctx.incompleteAccum = (ctx.incompleteAccum || "") + evt.text;
+      ctx.hasIncompleteUserTurn = true;
+      {
+        const list = [...state.utterances];
+        for (let i = list.length - 1; i >= 0; i--) {
+          if (list[i].role === "user") {
+            const prev = list[i];
+            list[i] = __spreadProps(__spreadValues({}, prev), {
+              text: ctx.incompleteAccum,
+              partial: true,
+              incomplete: true,
+              waitTimes: [...(_b = prev.waitTimes) != null ? _b : [], ...evt.wait_ms != null ? [evt.wait_ms] : []]
+            });
+            break;
+          }
+        }
+        state = __spreadProps(__spreadValues({}, state), { utterances: list });
+      }
+      state = patch(state, { session: "idle" });
+      break;
+    case "turn.started":
+      log("turn", "started");
+      ctx.userTurnActive = true;
+      if (ctx.assistantBubbleOpen) {
+        ctx.assistantBubbleOpen = false;
+        state = finaliseLastUtterance(state, "assistant");
+      }
+      if (!ctx.hasIncompleteUserTurn) {
+        ctx.incompleteAccum = "";
+      }
+      state = patch(state, { session: "listening" });
+      break;
+    case "turn.ended":
+      log("turn", `ended  transcript="${(_c = evt.transcript) != null ? _c : ""}"`);
+      if (!ctx.hasIncompleteUserTurn) {
+        state = finaliseLastUtterance(state, "user", ctx.preLLMText || void 0);
+        ctx.incompleteAccum = "";
+        ctx.preLLMText = "";
+      }
+      state = patch(state, { session: "thinking" });
+      break;
+    case "filler.started":
+      log("filler", `started  id=${evt.id}  text="${evt.text}"`);
+      state = patch(state, { session: "speaking" });
+      state = upsertAssistantBubble(state, (prev) => {
+        if (!prev) {
+          return { role: "assistant", text: evt.text, partial: true, fillerPrefix: evt.text };
+        }
+        if (prev.fillerPrefix || prev.text.startsWith(evt.text)) {
+          return prev;
+        }
+        const body = prev.text;
+        return __spreadProps(__spreadValues({}, prev), {
+          fillerPrefix: evt.text,
+          text: body ? `${evt.text} ${body}` : evt.text
+        });
+      });
+      ctx.assistantBubbleOpen = true;
+      break;
+    case "filler.stopped":
+      log("filler", `stopped  id=${evt.id}`);
+      break;
+    case "filler.skipped":
+      log("filler", `skipped  wait_ms=${evt.wait_ms}`);
+      break;
+    case "assistant.delta":
+      state = patch(state, { session: "speaking" });
+      state = upsertAssistantBubble(state, (prev) => {
+        var _a2;
+        if (!prev) {
+          return { role: "assistant", text: evt.text, partial: true };
+        }
+        const prefix = (_a2 = prev.fillerPrefix) != null ? _a2 : "";
+        const body = prefix && prev.text.startsWith(prefix) ? prev.text.slice(prefix.length).trimStart() : prev.text;
+        const joined = body + evt.text;
+        return __spreadProps(__spreadValues({}, prev), {
+          text: prefix ? `${prefix} ${joined}` : joined
+        });
+      });
+      ctx.assistantBubbleOpen = true;
+      break;
+    case "tts.started":
+      log("tts", "started");
+      state = patch(state, { session: "speaking" });
+      break;
+    case "tts.stopped":
+      log("tts", `stopped  reason=${evt.reason}`);
+      break;
+    case "turn.metrics": {
+      const prevCurrent = state.latency.current;
+      const merged = prevCurrent && prevCurrent.turn_id === evt.turn_id ? { turn_id: evt.turn_id, ftl: (_d = evt.ftl) != null ? _d : prevCurrent.ftl, il: (_e = evt.il) != null ? _e : prevCurrent.il, ts: Date.now() } : { turn_id: evt.turn_id, ftl: evt.ftl, il: evt.il, ts: Date.now() };
+      const history = ((_f = state.latency.history[0]) == null ? void 0 : _f.turn_id) === evt.turn_id ? [merged, ...state.latency.history.slice(1)] : [merged, ...state.latency.history].slice(0, 50);
+      state = __spreadProps(__spreadValues({}, state), { latency: { current: merged, history } });
+      log("turn", `metrics  ftl=${(_h = (_g = evt.ftl) == null ? void 0 : _g.total_ms) != null ? _h : "-"}ms  il=${(_j = (_i = evt.il) == null ? void 0 : _i.total_ms) != null ? _j : "-"}ms`);
+      break;
+    }
+    case "assistant.done":
+      log("turn", "assistant done");
+      ctx.assistantBubbleOpen = false;
+      state = finaliseLastUtterance(state, "assistant");
+      if (ctx.hasIncompleteUserTurn) {
+        state = finaliseLastUtterance(state, "user");
+        ctx.incompleteAccum = "";
+        ctx.hasIncompleteUserTurn = false;
+      }
+      ctx.preLLMText = "";
+      state = patch(state, { session: "idle" });
+      break;
+    case "interrupted":
+      log("turn", "interrupted");
+      effects.push({ kind: "flush_player" });
+      ctx.assistantBubbleOpen = false;
+      state = finaliseLastUtterance(state, "assistant");
+      if (ctx.hasIncompleteUserTurn) {
+        ctx.incompleteAccum = "";
+        ctx.hasIncompleteUserTurn = false;
+      }
+      ctx.preLLMText = "";
+      state = patch(state, { session: "listening" });
+      break;
+    case "error":
+      logError("ws", evt.message);
+      state = patch(state, { error: evt.message });
+      break;
+    case "brain.request":
+      warn("ws", "unexpected brain.request in state machine");
+      break;
+  }
+  return { state, ctx, effects };
+}
+
+// src/session-state.ts
+function createInitialState() {
+  return {
+    connection: "disconnected",
+    session: "idle",
+    utterances: [],
+    volume: 0,
+    error: null,
+    latency: { current: null, history: [] }
+  };
+}
+
+// src/client.ts
+var TypedEmitter = class {
+  constructor() {
+    this._listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, fn) {
+    if (!this._listeners.has(event)) this._listeners.set(event, /* @__PURE__ */ new Set());
+    this._listeners.get(event).add(fn);
+    return this;
+  }
+  off(event, fn) {
+    var _a;
+    (_a = this._listeners.get(event)) == null ? void 0 : _a.delete(fn);
+    return this;
+  }
+  emit(event, ...args) {
+    var _a;
+    (_a = this._listeners.get(event)) == null ? void 0 : _a.forEach((fn) => fn(...args));
+  }
+};
+var DEFAULT_SERVER = "http://localhost:9000";
+var VOLUME_INTERVAL_MS = 50;
+var VoiceLoopClient = class extends TypedEmitter {
+  constructor(opts = {}) {
+    var _a, _b, _c, _d;
+    super();
+    this._state = createInitialState();
+    this._ctx = createStateMachineContext();
+    this._ws = null;
+    this._mic = null;
+    this._volTimer = null;
+    this._serverUrl = (_a = opts.serverUrl) != null ? _a : DEFAULT_SERVER;
+    this._apiKey = (_b = opts.apiKey) != null ? _b : "dev-key";
+    this._turnPolicy = opts.turnPolicy;
+    this._onBrainRequest = opts.onBrainRequest;
+    this._micCapture = (_c = opts.micCapture) != null ? _c : startMicCapture;
+    this._player = ((_d = opts.playerFactory) != null ? _d : createPcmPlayer)();
+  }
+  get state() {
+    return this._state;
+  }
+  // ── Connection ──────────────────────────────────────────────────────────────
+  async connect() {
+    var _a;
+    if (this._ws) return;
+    this._player.resume();
+    log("session", `create  server=${this._serverUrl}`);
+    this._applyPatch({ connection: "connecting", error: null, utterances: [] });
+    this._ctx = createStateMachineContext();
+    let token;
+    try {
+      let res;
+      try {
+        const _b = (_a = this._turnPolicy) != null ? _a : {}, { tts_options } = _b, policyRest = __objRest(_b, ["tts_options"]);
+        const sessionBody = __spreadValues(__spreadValues({
+          brain_mode: "client"
+        }, Object.keys(policyRest).length > 0 ? { turn_policy: policyRest } : {}), tts_options ? { tts_options } : {});
+        log("session", `create body=${JSON.stringify(sessionBody)}`);
+        res = await fetch(`${this._serverUrl}/v1/sessions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${this._apiKey}`
+          },
+          body: JSON.stringify(sessionBody)
+        });
+      } catch (e) {
+        throw new Error(`\u65E0\u6CD5\u8FDE\u63A5\u670D\u52A1\u5668\uFF08${this._serverUrl}\uFF09\uFF0C\u8BF7\u68C0\u67E5 serverUrl \u662F\u5426\u6B63\u786E\uFF0C\u4EE5\u53CA\u670D\u52A1\u662F\u5426\u5728\u8FD0\u884C`);
+      }
+      if (res.status === 401) throw new Error(`\u9274\u6743\u5931\u8D25\uFF08401\uFF09\uFF0C\u8BF7\u68C0\u67E5 apiKey \u662F\u5426\u6B63\u786E`);
+      if (res.status === 403) throw new Error(`\u65E0\u8BBF\u95EE\u6743\u9650\uFF08403\uFF09\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u786E\u8BA4 apiKey \u6743\u9650`);
+      if (res.status === 404) throw new Error(`\u63A5\u53E3\u4E0D\u5B58\u5728\uFF08404\uFF09\uFF0C\u8BF7\u68C0\u67E5 serverUrl \u662F\u5426\u6B63\u786E\uFF0C\u4E0D\u8981\u5E26\u8DEF\u5F84\u540E\u7F00`);
+      if (!res.ok) throw new Error(`\u670D\u52A1\u5668\u9519\u8BEF\uFF08${res.status}\uFF09\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u6392\u67E5\u670D\u52A1\u7AEF\u65E5\u5FD7`);
+      const data = await res.json();
+      token = data.session_token;
+      log("session", `created  id=${data.session_id}`);
+    } catch (e) {
+      logError("session", `create failed  ${e}`);
+      this._applyPatch({ connection: "disconnected", error: String(e) });
+      return;
+    }
+    const wsUrl = this._serverUrl.replace(/^http/, "ws") + `/ws?token=${token}`;
+    log("ws", `connecting  ${wsUrl}`);
+    const ws = new WebSocket(wsUrl);
+    ws.binaryType = "arraybuffer";
+    this._ws = ws;
+    ws.onopen = async () => {
+      log("ws", "open");
+      this._applyPatch({ connection: "connected" });
+      try {
+        this._mic = await this._micCapture((chunk) => {
+          if (ws.readyState === WebSocket.OPEN) ws.send(chunk);
+        });
+        log("mic", "capture started");
+        this._volTimer = setInterval(() => {
+          var _a2, _b2;
+          this._applyPatch({ volume: (_b2 = (_a2 = this._mic) == null ? void 0 : _a2.getVolume()) != null ? _b2 : 0 });
+        }, VOLUME_INTERVAL_MS);
+      } catch (e) {
+        logError("mic", `capture failed  ${e}`);
+        const name = e instanceof Error ? e.name : "";
+        const msg = name === "NotAllowedError" ? "\u9EA6\u514B\u98CE\u6743\u9650\u88AB\u62D2\u7EDD\uFF0C\u8BF7\u5728\u6D4F\u89C8\u5668\u5730\u5740\u680F\u5141\u8BB8\u9EA6\u514B\u98CE\u8BBF\u95EE" : name === "NotFoundError" ? "\u672A\u627E\u5230\u9EA6\u514B\u98CE\u8BBE\u5907\uFF0C\u8BF7\u786E\u8BA4\u8BBE\u5907\u5DF2\u8FDE\u63A5" : `\u9EA6\u514B\u98CE\u542F\u52A8\u5931\u8D25\uFF1A${e}`;
+        this._applyPatch({ error: msg });
+        ws.close();
+      }
+    };
+    ws.onmessage = (e) => {
+      if (e.data instanceof ArrayBuffer) {
+        this._player.enqueue(new Uint8Array(e.data));
+        return;
+      }
+      try {
+        const evt = JSON.parse(e.data);
+        if (evt.type === "brain.request") {
+          if (this._onBrainRequest) {
+            this._onBrainRequest(evt, (frame) => {
+              if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(frame));
+            });
+          } else {
+            warn("ws", "brain.request received but no onBrainRequest handler provided");
+            this._applyPatch({ error: "\u6536\u5230 brain.request \u4F46\u672A\u63D0\u4F9B onBrainRequest \u56DE\u8C03\uFF0CAI \u5C06\u65E0\u6CD5\u56DE\u7B54\u3002\u8BF7\u5728 VoiceLoopClient \u521D\u59CB\u5316\u65F6\u4F20\u5165 onBrainRequest" });
+          }
+          return;
+        }
+        this._handleEvent(evt);
+      } catch (e2) {
+        warn("ws", "malformed frame", typeof e.data === "string" ? e.data.slice(0, 100) : "binary");
+      }
+    };
+    ws.onclose = (e) => {
+      log(
+        "ws",
+        `closed  code=${e.code}  reason=${e.reason || "(none)"}`,
+        void 0,
+        e.code >= 4e3 ? "warn" : "info"
+      );
+      this._cleanup();
+      if (this._ws !== null || this._state.connection !== "disconnected") {
+        this._ws = null;
+        this._applyPatch({ connection: "disconnected", session: "idle", volume: 0 });
+      }
+    };
+    ws.onerror = () => {
+      logError("ws", "error");
+      this._applyPatch({ error: `WebSocket \u8FDE\u63A5\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216\u8054\u7CFB\u7BA1\u7406\u5458\uFF08serverUrl: ${this._serverUrl}\uFF09` });
+    };
+  }
+  disconnect() {
+    log("session", "disconnect");
+    this._cleanup();
+    const ws = this._ws;
+    this._ws = null;
+    ws == null ? void 0 : ws.close();
+    this._applyPatch({ connection: "disconnected", session: "idle", volume: 0 });
+  }
+  // ── Control frames ──────────────────────────────────────────────────────────
+  barge() {
+    this._send({ type: "barge" });
+  }
+  endTurn(transcript) {
+    this._send(__spreadValues({ type: "turn.end" }, transcript ? { transcript } : {}));
+  }
+  say(text, voice) {
+    this._send(__spreadValues({ type: "say", text }, voice ? { voice } : {}));
+  }
+  // ── Private ─────────────────────────────────────────────────────────────────
+  _send(frame) {
+    var _a;
+    if (((_a = this._ws) == null ? void 0 : _a.readyState) === WebSocket.OPEN) {
+      this._ws.send(JSON.stringify(frame));
+    }
+  }
+  _handleEvent(evt) {
+    const { state, ctx, effects } = reduceServerEvent(this._state, this._ctx, evt);
+    this._ctx = ctx;
+    if (state !== this._state) {
+      this._state = state;
+      this.emit("state", state);
+    }
+    for (const effect of effects) {
+      if (effect.kind === "flush_player") {
+        this._player.flush();
+      }
+    }
+  }
+  _applyPatch(p) {
+    this._state = __spreadValues(__spreadValues({}, this._state), p);
+    this.emit("state", this._state);
+  }
+  _cleanup() {
+    var _a;
+    if (this._volTimer) {
+      clearInterval(this._volTimer);
+      this._volTimer = null;
+    }
+    (_a = this._mic) == null ? void 0 : _a.stop();
+    this._mic = null;
+    this._player.flush();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MIC_SAMPLE_RATE,
+  TTS_SAMPLE_RATE,
+  VoiceLoopClient,
+  clearLog,
+  createInitialState,
+  createPcmPlayer,
+  createStateMachineContext,
+  formatForCopy,
+  getEntries,
+  log,
+  logError,
+  reduceServerEvent,
+  startMicCapture,
+  subscribe,
+  warn
+});
+//# sourceMappingURL=index.cjs.map