@omnivoice/page-agent 0.3.0 → 0.5.0

package/dist/voice/index.js

@@ -0,0 +1,1096 @@
+class VoiceError extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "VoiceError";
+    this.code = code;
+  }
+}
+function recognitionConstructor() {
+  const scope = globalThis;
+  return scope.SpeechRecognition ?? scope.webkitSpeechRecognition;
+}
+function createBrowserVoice(language, listenTimeoutMs = 3e4) {
+  const Recognition = recognitionConstructor();
+  let active;
+  return {
+    get supportsInput() {
+      return Recognition !== void 0;
+    },
+    listen() {
+      if (!Recognition) return Promise.reject(new VoiceError("UNSUPPORTED", "este navegador não oferece reconhecimento de fala"));
+      return new Promise((resolve, reject) => {
+        const recognition = new Recognition();
+        active = recognition;
+        let transcript = "";
+        let settled = false;
+        const finish = (outcome) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          if (active === recognition) active = void 0;
+          outcome();
+        };
+        const timer = setTimeout(() => {
+          try {
+            recognition.stop();
+          } catch {
+          }
+          finish(() => resolve(transcript.trim()));
+        }, listenTimeoutMs);
+        recognition.lang = language;
+        recognition.continuous = false;
+        recognition.interimResults = false;
+        recognition.maxAlternatives = 1;
+        recognition.onresult = (event) => {
+          for (let i = event.resultIndex; i < event.results.length; i++) {
+            const result = event.results[i];
+            if (result?.isFinal) transcript = result[0]?.transcript ?? transcript;
+          }
+        };
+        recognition.onerror = (event) => {
+          const code = event.error ?? "desconhecido";
+          if (code === "no-speech" || code === "aborted") {
+            finish(() => resolve(transcript.trim()));
+            return;
+          }
+          finish(() => reject(new VoiceError("MICROPHONE", `erro de reconhecimento de voz: ${code}`)));
+        };
+        recognition.onend = () => finish(() => resolve(transcript.trim()));
+        try {
+          recognition.start();
+        } catch (error) {
+          finish(() => reject(new VoiceError("MICROPHONE", "não foi possível iniciar o reconhecimento", { cause: error })));
+        }
+      });
+    },
+    stopListening() {
+      try {
+        active?.stop();
+      } catch {
+      }
+    },
+    speak(text) {
+      const synth = globalThis.speechSynthesis;
+      const clean = text.trim();
+      if (!synth || !clean) return;
+      synth.cancel();
+      const utterance = new SpeechSynthesisUtterance(clean);
+      utterance.lang = language;
+      synth.speak(utterance);
+    },
+    stopSpeaking() {
+      globalThis.speechSynthesis?.cancel();
+    }
+  };
+}
+class EventHub {
+  constructor() {
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.closed = false;
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  emit(event) {
+    if (this.closed) return;
+    for (const subscriber of this.subscribers) {
+      const waiter = subscriber.waiters.shift();
+      if (waiter) waiter({ value: event, done: false });
+      else subscriber.queue.push(event);
+    }
+  }
+  /** Encerra todos os iteradores: quem espera recebe `done`, quem tem fila a consome antes. */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const subscriber of this.subscribers) {
+      for (const waiter of subscriber.waiters.splice(0)) waiter({ value: void 0, done: true });
+    }
+  }
+  subscribe() {
+    const subscriber = { queue: [], waiters: [] };
+    this.subscribers.add(subscriber);
+    const hub = this;
+    return {
+      [Symbol.asyncIterator]() {
+        return {
+          next() {
+            const queued = subscriber.queue.shift();
+            if (queued !== void 0) return Promise.resolve({ value: queued, done: false });
+            if (hub.closed) {
+              hub.subscribers.delete(subscriber);
+              return Promise.resolve({ value: void 0, done: true });
+            }
+            return new Promise((resolve) => subscriber.waiters.push(resolve));
+          },
+          return() {
+            hub.subscribers.delete(subscriber);
+            return Promise.resolve({ value: void 0, done: true });
+          }
+        };
+      }
+    };
+  }
+}
+const TEXT_INPUT = "text_input";
+const MUTE = "mute";
+const REPLAY = "replay";
+const IDLE_PAUSE_MS = 250;
+class LocalEngine {
+  constructor(settings, deps = {}) {
+    this.capabilities = /* @__PURE__ */ new Set([TEXT_INPUT, MUTE]);
+    this.hub = new EventHub();
+    this.running = false;
+    this.turn = "idle";
+    this.settings = settings;
+    this.deps = deps;
+    this.muted = !settings.mic;
+  }
+  async enter() {
+    if (this.running) throw new VoiceError("CONNECTION_FAILED", "o motor local já foi aberto");
+    const voice = this.deps.voice ?? createBrowserVoice(this.settings.language);
+    if (!voice.supportsInput && !this.muted) {
+      throw new VoiceError("UNSUPPORTED", "este navegador não oferece reconhecimento de fala");
+    }
+    this.voice = voice;
+    this.running = true;
+    this.turn = "idle";
+    this.hub.emit({ kind: "session.ready", data: this.snapshot() });
+    void this.listenLoop(voice);
+  }
+  async exit() {
+    this.running = false;
+    this.turn = "idle";
+    this.voice?.stopListening();
+    this.voice?.stopSpeaking();
+    this.unmute?.();
+    this.hub.close();
+  }
+  snapshot() {
+    return {
+      mode: "local",
+      channel: "voice",
+      state: this.turn,
+      muted: this.muted,
+      sessionId: this.settings.sessionId,
+      messageCount: 0,
+      ...this.lastError ? { error: this.lastError } : {}
+    };
+  }
+  setMuted(muted) {
+    if (this.muted === muted) return;
+    this.muted = muted;
+    if (muted) this.voice?.stopListening();
+    else this.unmute?.();
+  }
+  submit(text) {
+    if (!this.running) throw new VoiceError("CLOSED", "o motor local está fechado");
+    const clean = text.trim();
+    if (clean) this.hub.emit({ kind: "turn.heard", data: { text: clean, channel: "chat" } });
+  }
+  /** Fala um texto com a síntese do navegador (a resposta do agente, por exemplo). */
+  speak(text) {
+    this.voice?.speak(text);
+  }
+  events() {
+    return this.hub.subscribe();
+  }
+  waitUnmuted() {
+    return new Promise((resolve) => {
+      this.unmute = () => {
+        this.unmute = void 0;
+        resolve();
+      };
+    });
+  }
+  async listenLoop(voice) {
+    while (this.running) {
+      if (this.muted) {
+        this.turn = "idle";
+        await this.waitUnmuted();
+        continue;
+      }
+      try {
+        this.turn = "listening";
+        const text = await voice.listen();
+        if (!this.running) return;
+        if (this.muted) continue;
+        if (text) {
+          this.hub.emit({ kind: "user.started", data: { channel: "voice" } });
+          this.hub.emit({ kind: "turn.heard", data: { text } });
+        } else {
+          await new Promise((resolve) => setTimeout(resolve, IDLE_PAUSE_MS));
+        }
+      } catch (error) {
+        if (!this.running) return;
+        this.lastError = error instanceof Error ? error.message : "erro de reconhecimento de voz";
+        this.hub.emit({
+          kind: "error",
+          data: { message: this.lastError, code: error instanceof VoiceError ? error.code : "AUDIO_ERROR" }
+        });
+        this.running = false;
+        this.turn = "idle";
+        this.hub.close();
+        return;
+      }
+    }
+  }
+}
+const CAPTURE_RATE = 16e3;
+const CAPTURE_BLOCK = 512;
+const CAPTURE_WORKLET = `
+class OmnivoiceCapture extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.block = 0;
+    this.samples = new Float32Array(${CAPTURE_BLOCK});
+    this.used = 0;
+  }
+  process(inputs) {
+    const input = inputs[0] && inputs[0][0];
+    if (!input) return true;
+    let offset = 0;
+    while (offset < input.length) {
+      const take = Math.min(input.length - offset, ${CAPTURE_BLOCK} - this.used);
+      this.samples.set(input.subarray(offset, offset + take), this.used);
+      this.used += take;
+      offset += take;
+      if (this.used === ${CAPTURE_BLOCK}) {
+        const pcm = new Int16Array(${CAPTURE_BLOCK});
+        for (let i = 0; i < ${CAPTURE_BLOCK}; i++) {
+          pcm[i] = Math.max(-32768, Math.min(32767, Math.round(this.samples[i] * 32768)));
+        }
+        this.port.postMessage({ block: this.block++, pcm: pcm.buffer, at: currentTime * 1000 }, [pcm.buffer]);
+        this.samples = new Float32Array(${CAPTURE_BLOCK});
+        this.used = 0;
+      }
+    }
+    return true;
+  }
+}
+registerProcessor("omnivoice-capture", OmnivoiceCapture);
+`;
+const PLAYBACK_WORKLET = `
+class OmnivoicePlayback extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.queue = [];
+    this.offset = 0;
+    this.rendered = 0;
+    this.marks = [];
+    this.port.onmessage = (event) => {
+      const message = event.data || {};
+      if (message.type === "audio") this.queue.push(new Float32Array(message.samples));
+      if (message.type === "mark") this.marks.push({ id: message.id, label: message.label, offset: message.offset });
+      if (message.type === "clear") { this.queue = []; this.offset = 0; this.marks = []; }
+    };
+  }
+  process(_inputs, outputs) {
+    const out = outputs[0][0];
+    out.fill(0);
+    let written = 0;
+    while (written < out.length && this.queue.length) {
+      const current = this.queue[0];
+      const take = Math.min(out.length - written, current.length - this.offset);
+      out.set(current.subarray(this.offset, this.offset + take), written);
+      written += take;
+      this.offset += take;
+      if (this.offset === current.length) { this.queue.shift(); this.offset = 0; }
+    }
+    const before = this.rendered;
+    this.rendered += written;
+    while (this.marks.length && this.marks[0].offset < this.rendered) {
+      const mark = this.marks.shift();
+      this.port.postMessage({ type: "reached", id: mark.id, label: mark.label, at: currentTime * 1000 });
+    }
+    if (this.rendered - before || written < out.length) {
+      this.port.postMessage({ type: "rendered", samples: this.rendered, at: currentTime * 1000 });
+    }
+    if (written < out.length && this.queue.length === 0) {
+      this.port.postMessage({ type: "underrun", samples: out.length - written });
+    }
+    return true;
+  }
+}
+registerProcessor("omnivoice-playback", OmnivoicePlayback);
+`;
+async function loadWorklet(context, source) {
+  const url = URL.createObjectURL(new Blob([source], { type: "text/javascript" }));
+  try {
+    await context.audioWorklet.addModule(url);
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+function requireAudioSupport() {
+  if (typeof AudioContext === "undefined" || typeof AudioWorkletNode === "undefined") {
+    throw new VoiceError("UNSUPPORTED", "este navegador não oferece AudioContext/AudioWorklet");
+  }
+}
+function isCaptureMessage(data) {
+  if (typeof data !== "object" || data === null) return false;
+  const message = data;
+  return typeof message["block"] === "number" && message["pcm"] instanceof ArrayBuffer && typeof message["at"] === "number";
+}
+function isPlaybackReport(data) {
+  return typeof data === "object" && data !== null && typeof data["type"] === "string";
+}
+const startBrowserMicrophone = async (onFrame) => {
+  requireAudioSupport();
+  if (!navigator.mediaDevices?.getUserMedia) {
+    throw new VoiceError("UNSUPPORTED", "este navegador não oferece getUserMedia (precisa de https ou localhost)");
+  }
+  const context = new AudioContext({ sampleRate: CAPTURE_RATE, latencyHint: "interactive" });
+  let stream;
+  try {
+    await loadWorklet(context, CAPTURE_WORKLET);
+    stream = await navigator.mediaDevices.getUserMedia({
+      audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true }
+    });
+    const source = context.createMediaStreamSource(stream);
+    const node = new AudioWorkletNode(context, "omnivoice-capture");
+    node.port.onmessage = (event) => {
+      if (!isCaptureMessage(event.data)) return;
+      onFrame({ block: event.data.block, pcm: new Int16Array(event.data.pcm), at: event.data.at });
+    };
+    source.connect(node);
+    node.connect(context.destination);
+    await context.resume();
+    const tracks = stream.getTracks();
+    return {
+      async stop() {
+        node.port.onmessage = null;
+        source.disconnect();
+        node.disconnect();
+        for (const track of tracks) track.stop();
+        await context.close();
+      }
+    };
+  } catch (error) {
+    stream?.getTracks().forEach((track) => track.stop());
+    await context.close().catch(() => void 0);
+    if (error instanceof VoiceError) throw error;
+    throw new VoiceError("MICROPHONE", error instanceof Error ? error.message : "não foi possível abrir o microfone", {
+      cause: error
+    });
+  }
+};
+const startBrowserPlayback = async (rate, onReport) => {
+  requireAudioSupport();
+  const context = new AudioContext({ sampleRate: rate, latencyHint: "interactive" });
+  try {
+    await loadWorklet(context, PLAYBACK_WORKLET);
+    const node = new AudioWorkletNode(context, "omnivoice-playback");
+    node.port.onmessage = (event) => {
+      if (isPlaybackReport(event.data)) onReport(event.data);
+    };
+    node.connect(context.destination);
+    await context.resume();
+    return {
+      push(pcm16) {
+        const samples = new Float32Array(pcm16.length);
+        for (let i = 0; i < pcm16.length; i++) samples[i] = (pcm16[i] ?? 0) / 32768;
+        node.port.postMessage({ type: "audio", samples: samples.buffer }, [samples.buffer]);
+      },
+      mark(mark) {
+        node.port.postMessage({ type: "mark", id: mark.id, label: mark.label, offset: mark.offset });
+      },
+      clear() {
+        node.port.postMessage({ type: "clear" });
+      },
+      async close() {
+        node.port.onmessage = null;
+        node.disconnect();
+        await context.close();
+      }
+    };
+  } catch (error) {
+    await context.close().catch(() => void 0);
+    throw error;
+  }
+};
+const VOICE_DEFAULTS = Object.freeze({
+  speechMode: "local",
+  language: "pt-BR",
+  proxyServerUrl: "http://localhost:8765",
+  proxyLeaseEndpoint: "/lease",
+  proxyWebSocketEndpoint: "/ws",
+  proxySessionId: "",
+  connectTimeoutMs: 1e4,
+  mic: true,
+  trace: false
+});
+function createVoiceSettings(overrides = {}) {
+  return Object.freeze({
+    ...VOICE_DEFAULTS,
+    sessionId: `session-${Date.now()}`,
+    ...overrides
+  });
+}
+function readVoiceSettings(env) {
+  const text = (key, fallback) => {
+    const value = env[key];
+    return value === void 0 || value === "" ? fallback : value;
+  };
+  const flag = (key, fallback) => {
+    const value = env[key];
+    if (value === "1" || value === "true") return true;
+    if (value === "0" || value === "false") return false;
+    return fallback;
+  };
+  const positiveInt = (key, fallback) => {
+    const parsed = Number.parseInt(env[key] ?? "", 10);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+  };
+  return createVoiceSettings({
+    speechMode: parseSpeechMode(text("SPEECH_MODE", text("SPEECH", VOICE_DEFAULTS.speechMode))),
+    language: text("VOICE_LANGUAGE", VOICE_DEFAULTS.language),
+    proxyServerUrl: text("PROXY_SERVER_URL", VOICE_DEFAULTS.proxyServerUrl),
+    proxyLeaseEndpoint: text("PROXY_LEASE_ENDPOINT", VOICE_DEFAULTS.proxyLeaseEndpoint),
+    proxyWebSocketEndpoint: text("PROXY_WEBSOCKET_ENDPOINT", VOICE_DEFAULTS.proxyWebSocketEndpoint),
+    proxySessionId: text("PROXY_SESSION_ID", VOICE_DEFAULTS.proxySessionId),
+    connectTimeoutMs: positiveInt("CONNECT_TIMEOUT_MS", VOICE_DEFAULTS.connectTimeoutMs),
+    mic: flag("MIC", VOICE_DEFAULTS.mic),
+    trace: flag("TRACE", VOICE_DEFAULTS.trace),
+    ...env["SESSION_ID"] ? { sessionId: env["SESSION_ID"] } : {}
+  });
+}
+function parseSpeechMode(choice) {
+  const normalized = choice.trim().toLowerCase();
+  if (normalized === "2" || normalized === "realtime") return "realtime";
+  return "local";
+}
+function validateSettings(settings) {
+  if (settings.speechMode !== "realtime") return void 0;
+  let origin;
+  try {
+    origin = new URL(settings.proxyServerUrl);
+  } catch {
+    return `proxyServerUrl inválida: ${settings.proxyServerUrl}`;
+  }
+  if (origin.protocol !== "http:" && origin.protocol !== "https:") {
+    return `proxyServerUrl deve usar http: ou https: (recebido ${origin.protocol})`;
+  }
+  if (!settings.proxyWebSocketEndpoint) return "proxyWebSocketEndpoint vazio";
+  if (!settings.proxySessionId && !settings.proxyLeaseEndpoint) {
+    return "defina proxyLeaseEndpoint ou proxySessionId";
+  }
+  return void 0;
+}
+const OPEN = 1;
+const browserSocket = (url, handlers) => {
+  const socket = new WebSocket(url);
+  socket.binaryType = "arraybuffer";
+  socket.addEventListener("open", () => handlers.onOpen());
+  socket.addEventListener("error", () => handlers.onError());
+  socket.addEventListener("close", (event) => handlers.onClose(event.code, event.reason));
+  socket.addEventListener("message", (event) => {
+    const data = event.data;
+    if (typeof data === "string" || data instanceof ArrayBuffer) handlers.onMessage(data);
+  });
+  return {
+    get isOpen() {
+      return socket.readyState === OPEN;
+    },
+    send(data) {
+      socket.send(typeof data === "string" ? data : new Uint8Array(data));
+    },
+    close(code, reason) {
+      socket.close(code, reason);
+    }
+  };
+};
+function joinServerUrl(base, endpoint) {
+  const url = new URL(base);
+  const prefix = url.pathname.replace(/\/+$/, "");
+  url.pathname = `${prefix}/${endpoint.replace(/^\/+/, "")}`;
+  url.search = "";
+  url.hash = "";
+  return url;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function turnStateFrom(serverState, fallback) {
+  switch (serverState) {
+    case "LISTENING":
+    case "INTERRUPTED":
+      return "listening";
+    case "TRANSCRIBING":
+    case "THINKING":
+    case "EXPLAINING":
+      return "processing";
+    case "SPEAKING":
+      return "speaking";
+    default:
+      return fallback;
+  }
+}
+class RealtimeEngine {
+  constructor(settings, deps = {}) {
+    this.capabilities = /* @__PURE__ */ new Set([MUTE]);
+    this.hub = new EventHub();
+    this.playbackRate = 0;
+    this.opened = false;
+    this.ready = false;
+    this.closing = false;
+    this.turn = "idle";
+    this.proxySessionId = "";
+    this.settings = settings;
+    this.deps = deps;
+    this.muted = !settings.mic;
+  }
+  async enter() {
+    if (this.opened) throw new VoiceError("CONNECTION_FAILED", "o motor realtime já foi aberto");
+    const problem = validateSettings(this.settings);
+    if (problem) throw new VoiceError("INVALID_SETTINGS", problem);
+    this.opened = true;
+    try {
+      this.proxySessionId = this.settings.proxySessionId || await this.lease();
+      const url = joinServerUrl(this.settings.proxyServerUrl, this.settings.proxyWebSocketEndpoint);
+      url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+      url.searchParams.set("session", this.proxySessionId);
+      const ready = new Promise((resolve, reject) => {
+        this.settle = { resolve, reject };
+      });
+      const timer = setTimeout(() => {
+        this.settle?.reject(new VoiceError("TIMEOUT", `o servidor de áudio não respondeu em ${this.settings.connectTimeoutMs} ms`));
+      }, this.settings.connectTimeoutMs);
+      const open = this.deps.socket ?? browserSocket;
+      this.socket = open(url.href, {
+        onOpen: () => this.trace("socket aberto"),
+        onMessage: (data) => void this.onMessage(data),
+        onError: () => this.fail(new VoiceError("CONNECTION_FAILED", `não foi possível conectar a ${url.origin}${url.pathname}`)),
+        onClose: (code, reason) => this.onClose(code, reason)
+      });
+      try {
+        await ready;
+      } finally {
+        clearTimeout(timer);
+      }
+    } catch (error) {
+      await this.teardown();
+      throw error;
+    }
+  }
+  async exit() {
+    this.closing = true;
+    await this.teardown();
+  }
+  snapshot() {
+    return {
+      mode: "realtime",
+      channel: "voice",
+      state: this.turn,
+      muted: this.muted,
+      sessionId: this.proxySessionId || this.settings.sessionId,
+      messageCount: 0,
+      ...this.lastError ? { error: this.lastError } : {}
+    };
+  }
+  setMuted(muted) {
+    if (this.muted === muted) return;
+    this.muted = muted;
+    this.sendJson({ type: "mute", on: muted });
+    if (!muted && this.ready) void this.ensureMicrophone();
+  }
+  submit(_text) {
+    throw new VoiceError("UNSUPPORTED", "o motor realtime não aceita texto digitado: fale pelo microfone");
+  }
+  events() {
+    return this.hub.subscribe();
+  }
+  async lease() {
+    const doFetch = this.deps.fetch ?? globalThis.fetch;
+    if (typeof doFetch !== "function") throw new VoiceError("UNSUPPORTED", "fetch não está disponível neste ambiente");
+    const url = joinServerUrl(this.settings.proxyServerUrl, this.settings.proxyLeaseEndpoint);
+    let response;
+    try {
+      response = await doFetch(url.href, { credentials: "include" });
+    } catch (error) {
+      throw new VoiceError("LEASE_FAILED", `não foi possível alcançar ${url.origin}${url.pathname}`, { cause: error });
+    }
+    const body = asRecord(await response.json().catch(() => void 0));
+    if (!response.ok) {
+      const reason = typeof body?.["error"] === "string" ? body["error"] : `HTTP ${response.status}`;
+      throw new VoiceError("LEASE_FAILED", `sessão de voz recusada: ${reason}`);
+    }
+    const id = body?.["session_id"];
+    if (typeof id !== "string" || id === "") throw new VoiceError("LEASE_FAILED", "o servidor não devolveu session_id");
+    return id;
+  }
+  async onMessage(data) {
+    if (typeof data !== "string") {
+      if (this.playback && data.byteLength >= 2) this.playback.push(new Int16Array(data, 0, Math.floor(data.byteLength / 2)));
+      return;
+    }
+    let message;
+    try {
+      message = asRecord(JSON.parse(data));
+    } catch {
+      return;
+    }
+    const rate = typeof message?.["rate"] === "number" ? message["rate"] : 0;
+    switch (message?.["type"]) {
+      case "ready":
+        try {
+          await this.startAudio(rate);
+          this.ready = true;
+          this.turn = "listening";
+          this.emit({ kind: "session.ready", data: this.snapshot() });
+          this.settle?.resolve();
+        } catch (error) {
+          this.fail(error instanceof VoiceError ? error : new VoiceError("CONNECTION_FAILED", "falha ao iniciar o áudio", { cause: error }));
+        }
+        return;
+      case "rate":
+        if (this.ready) await this.startPlayback(rate).catch((error) => this.report(error));
+        return;
+      case "state":
+        this.onState(message);
+        return;
+      case "mark": {
+        const { id, label, offset } = message;
+        if (typeof id === "number" && typeof label === "string" && typeof offset === "number") this.playback?.mark({ id, label, offset });
+        return;
+      }
+      case "clear":
+        this.playback?.clear();
+        return;
+      case "refused": {
+        const reason = typeof message["reason"] === "string" ? message["reason"] : "sem motivo informado";
+        this.fail(new VoiceError("REFUSED", `o servidor recusou a sessão: ${reason}`));
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  onState(message) {
+    this.turn = turnStateFrom(message["state"], this.turn);
+    const detail = typeof message["detail"] === "string" ? message["detail"] : "";
+    switch (message["event"]) {
+      case "user.started":
+        this.emit({ kind: "user.started", data: { channel: "voice" } });
+        return;
+      case "agent.started":
+        this.emit({ kind: "agent.started", data: { turn: this.turn } });
+        return;
+      case "sound.started":
+        this.emit({ kind: "sound.started", data: {} });
+        return;
+      case "speaker.idle":
+        this.emit({ kind: "speaker.idle", data: {} });
+        return;
+      case "error":
+        this.lastError = detail || "erro no servidor de áudio";
+        this.emit({ kind: "error", data: { message: this.lastError, code: "SERVER_ERROR" } });
+        return;
+      default:
+        return;
+    }
+  }
+  async startAudio(rate) {
+    await this.startPlayback(rate);
+    if (!this.muted) await this.ensureMicrophone();
+  }
+  async startPlayback(rate) {
+    if (!Number.isFinite(rate) || rate <= 0) throw new VoiceError("CONNECTION_FAILED", `taxa de áudio inválida: ${rate}`);
+    if (this.playback && this.playbackRate === rate) return;
+    const previous = this.playback;
+    this.playback = void 0;
+    await previous?.close();
+    const open = this.deps.playback ?? startBrowserPlayback;
+    this.playback = await open(rate, (report) => this.sendPlaybackReport(report));
+    this.playbackRate = rate;
+  }
+  ensureMicrophone() {
+    if (this.microphone) return Promise.resolve();
+    this.microphoneStarting ??= (async () => {
+      const open = this.deps.microphone ?? startBrowserMicrophone;
+      try {
+        this.microphone = await open((frame) => this.sendFrame(frame));
+        if (this.closing) await this.stopMicrophone();
+      } finally {
+        this.microphoneStarting = void 0;
+      }
+    })();
+    return this.microphoneStarting;
+  }
+  async stopMicrophone() {
+    const microphone = this.microphone;
+    this.microphone = void 0;
+    await microphone?.stop();
+  }
+  sendFrame(frame) {
+    if (this.muted || !this.socket?.isOpen || frame.pcm.length !== CAPTURE_BLOCK) return;
+    const bytes = new Uint8Array(4 + frame.pcm.byteLength);
+    new DataView(bytes.buffer).setUint32(0, frame.block, true);
+    bytes.set(new Uint8Array(frame.pcm.buffer, frame.pcm.byteOffset, frame.pcm.byteLength), 4);
+    this.socket.send(bytes);
+  }
+  sendPlaybackReport(report) {
+    this.sendJson(report);
+  }
+  sendJson(message) {
+    if (this.socket?.isOpen) this.socket.send(JSON.stringify(message));
+  }
+  onClose(code, reason) {
+    if (this.closing) return;
+    const error = new VoiceError("CONNECTION_FAILED", `conexão encerrada pelo servidor (código ${code}${reason ? `: ${reason}` : ""})`);
+    if (!this.ready) {
+      this.settle?.reject(error);
+      return;
+    }
+    this.lastError = error.message;
+    this.emit({ kind: "error", data: { message: error.message, code: "CLOSED" } });
+    void this.teardown();
+  }
+  /** Falha durante a abertura rejeita `enter()`; depois dela vira evento de erro. */
+  fail(error) {
+    if (!this.ready) {
+      this.settle?.reject(error);
+      return;
+    }
+    this.report(error);
+  }
+  report(error) {
+    const message = error instanceof Error ? error.message : "erro de áudio";
+    this.lastError = message;
+    this.emit({ kind: "error", data: { message, code: error instanceof VoiceError ? error.code : "AUDIO_ERROR" } });
+  }
+  emit(event) {
+    this.hub.emit(event);
+  }
+  trace(message) {
+    if (this.settings.trace) console.debug(`[RealtimeEngine] ${message}`);
+  }
+  async teardown() {
+    this.closing = true;
+    this.ready = false;
+    this.turn = "idle";
+    const socket = this.socket;
+    const playback = this.playback;
+    this.socket = void 0;
+    this.playback = void 0;
+    await this.stopMicrophone().catch(() => void 0);
+    await playback?.close().catch(() => void 0);
+    if (socket?.isOpen) socket.close(1e3, "fim da sessão");
+    this.hub.close();
+  }
+}
+function createEngine(settings, deps = {}) {
+  return settings.speechMode === "realtime" ? new RealtimeEngine(settings, deps.realtime) : new LocalEngine(settings, deps.local);
+}
+const FORWARDED_EVENTS = /* @__PURE__ */ new Set([
+  "user.started",
+  "agent.started",
+  "agent.finished",
+  "sound.started",
+  "speaker.idle",
+  "error"
+]);
+class VoiceSession {
+  constructor(settings, allowMutations = true) {
+    this.engine = null;
+    this.inputQueue = [];
+    this.hub = new EventHub();
+    this.isClosed = false;
+    this.settings = settings;
+    this.sessionId = settings.sessionId;
+    this.allowMutations = allowMutations;
+    this.context = {
+      mode: settings.speechMode,
+      channel: "voice",
+      turn: "idle",
+      sessionId: this.sessionId,
+      conversationHistory: [],
+      muted: !settings.mic,
+      lastTurnTime: void 0
+    };
+  }
+  /** Abre a sessão: abre a engine e passa a repassar os eventos dela. */
+  async abrir(engine) {
+    if (this.engine) throw new Error("sessão já está aberta");
+    const engineEvents = engine.events();
+    this.engine = engine;
+    this.isClosed = false;
+    try {
+      await engine.enter();
+    } catch (error) {
+      this.engine = null;
+      throw error;
+    }
+    this.emitPublic({ kind: "session.ready", data: this.snapshot() });
+    void this.processEngineEvents(engineEvents);
+  }
+  /** Fecha a sessão. */
+  async fechar() {
+    this.isClosed = true;
+    const engine = this.engine;
+    this.engine = null;
+    if (engine) {
+      try {
+        await engine.exit();
+      } catch (error) {
+        console.error("[VoiceSession.fechar]", error);
+      }
+    }
+    this.hub.close();
+  }
+  /** Snapshot atual para o painel. */
+  snapshot() {
+    return {
+      mode: this.context.mode,
+      channel: this.context.channel,
+      state: this.context.turn,
+      muted: this.context.muted,
+      sessionId: this.sessionId,
+      messageCount: this.context.conversationHistory.length,
+      lastMessageTime: this.context.lastTurnTime
+    };
+  }
+  /** Habilita/desabilita mutação de estado. Padrão: true (ativado). false = modo auditoria (read-only). */
+  setMutationsAllowed(allowed) {
+    this.allowMutations = allowed;
+  }
+  /** Enfileira entrada do usuário (voz transcrita ou texto). Sem efeito se mutações desabilitadas. */
+  enqueueInput(input) {
+    if (!this.allowMutations) return;
+    this.inputQueue.push(input);
+    this.processNextInput();
+  }
+  /** Muta/desmuta o microfone. Sem efeito se mutações desabilitadas. */
+  setMuted(muted) {
+    if (!this.allowMutations) return;
+    this.context.muted = muted;
+    this.engine?.setMuted(muted);
+  }
+  /** Eventos públicos a partir de agora, até a sessão fechar. Cada chamada tem a sua fila. */
+  events() {
+    return this.hub.subscribe();
+  }
+  /**
+   * Alterna entre voz e chat.
+   * O histórico é preservado; apenas a origem do próximo input muda.
+   * Sem efeito se mutações desabilitadas.
+   */
+  switchToChannel(channel) {
+    if (!this.allowMutations) return;
+    if (this.context.channel === channel) return;
+    const from = this.context.channel;
+    this.context.channel = channel;
+    this.emitPublic({ kind: "channel.switched", data: { from, to: channel } });
+  }
+  /** Processa a fila: atualiza histórico e avisa o bridge. */
+  processNextInput() {
+    if (!this.allowMutations) return;
+    const input = this.inputQueue.shift();
+    if (!input) return;
+    this.context.turn = "listening";
+    this.context.channel = input.channel;
+    this.context.lastTurnTime = input.timestamp;
+    this.context.conversationHistory.push({
+      role: "user",
+      content: input.utterance,
+      timestamp: input.timestamp,
+      channel: input.channel,
+      confidence: input.confidence
+    });
+    this.emitPublic({
+      kind: "turn.heard",
+      data: { text: input.utterance, confidence: input.confidence, channel: input.channel }
+    });
+    this.context.turn = "processing";
+  }
+  /** Repassa os eventos da engine enquanto a sessão estiver aberta. */
+  async processEngineEvents(stream) {
+    try {
+      for await (const engineEvent of stream) {
+        if (this.isClosed) break;
+        this.handleEngineEvent(engineEvent);
+      }
+    } catch (error) {
+      this.emitPublic({
+        kind: "error",
+        data: { message: error instanceof Error ? error.message : "erro desconhecido", code: "ENGINE_ERROR" }
+      });
+    }
+  }
+  handleEngineEvent(event) {
+    if (event.kind === "turn.heard") {
+      this.enqueueInput({
+        utterance: event.data.text,
+        channel: event.data.channel ?? "voice",
+        confidence: event.data.confidence,
+        timestamp: Date.now()
+      });
+      return;
+    }
+    if (FORWARDED_EVENTS.has(event.kind)) this.emitPublic(event);
+    if (event.kind === "agent.finished") {
+      this.context.conversationHistory.push({
+        role: "assistant",
+        content: event.data.text,
+        timestamp: Date.now(),
+        channel: this.context.channel
+      });
+      this.context.turn = "idle";
+    }
+    if (event.kind === "agent.started") this.context.turn = "speaking";
+  }
+  emitPublic(event) {
+    this.hub.emit(event);
+  }
+}
+async function createVoiceSession(settings, deps = {}) {
+  const session = new VoiceSession(settings);
+  await session.abrir(createEngine(settings, deps));
+  return session;
+}
+class VoiceBridge {
+  constructor(session) {
+    this.messageBuffer = [];
+    this.session = session;
+  }
+  /**
+   * Entrada de texto do usuário (chat): vira UserInput e é enfileirada na sessão.
+   * O registro no histórico da ponte acontece quando a sessão publicar o `turn.heard` correspondente.
+   */
+  onUserText(text) {
+    if (!text.trim()) return;
+    this.session.enqueueInput({
+      utterance: text.trim(),
+      channel: "chat",
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Evento público da sessão. `turn.heard` e `agent.finished` entram no histórico da ponte;
+   * nenhum evento aqui cria entrada nova na sessão.
+   */
+  onVoiceEvent(event) {
+    if (event.kind === "turn.heard") {
+      const { text, confidence, channel } = event.data;
+      if (!text.trim()) return;
+      this.recordMessage({
+        role: "user",
+        content: text,
+        channel: channel ?? "voice",
+        confidence,
+        timestamp: Date.now()
+      });
+    }
+    if (event.kind === "agent.finished") {
+      const { text } = event.data;
+      this.recordMessage({
+        role: "assistant",
+        content: text,
+        channel: this.session.context.channel,
+        timestamp: Date.now()
+      });
+    }
+    if (event.kind === "channel.switched") {
+      const { from, to } = event.data;
+      console.debug(`[VoiceBridge] canais alternados: ${from} → ${to}`);
+    }
+  }
+  /**
+   * Contexto atual: tudo o que o page-agent precisa saber sobre voz.
+   * Leitura apenas; nunca muta.
+   */
+  get context() {
+    return this.session.context;
+  }
+  /**
+   * Snapshot para o painel.
+   */
+  get snapshot() {
+    return this.session.snapshot();
+  }
+  /**
+   * Histórico de mensagens: construído incrementalmente
+   * conforme entradas chegam e respostas são produzidas.
+   */
+  get messages() {
+    return this.messageBuffer;
+  }
+  /**
+   * Muta/desmuta o microfone.
+   */
+  setMuted(muted) {
+    this.session.setMuted(muted);
+  }
+  /**
+   * Registra uma mensagem no histórico local do bridge.
+   * Não persiste (isso é job do store se necessário).
+   */
+  recordMessage(msg) {
+    this.messageBuffer.push(msg);
+    const cutoff = Date.now() - 2 * 60 * 60 * 1e3;
+    this.messageBuffer = this.messageBuffer.filter((m) => m.timestamp > cutoff);
+  }
+  /**
+   * Reset para testes ou novo começo de conversa.
+   */
+  clearHistory() {
+    this.messageBuffer = [];
+  }
+}
+class VoiceSessionController {
+  constructor(session, bridge) {
+    this.session = session;
+    this.bridge = bridge;
+  }
+  /**
+   * Muda de canal (voz → chat ou chat → voz).
+   * O contexto é preservado: histórico segue intacto.
+   * Só muda a ORIGEM do próximo input.
+   *
+   * Implementação: sinaliza à sessão e deixa ela gerir o event loop.
+   */
+  switchChannel(to) {
+    const from = this.session.context.channel;
+    if (from === to) return;
+    console.debug(`[Controller] solicitando mudança: ${from} → ${to}`);
+  }
+  /**
+   * Contexto atual (apenas leitura).
+   */
+  get context() {
+    return this.session.context;
+  }
+  /**
+   * Muta/desmuta.
+   */
+  setMuted(muted) {
+    this.bridge.setMuted(muted);
+  }
+}
+export {
+  CAPTURE_BLOCK,
+  CAPTURE_RATE,
+  EventHub,
+  LocalEngine,
+  MUTE,
+  REPLAY,
+  RealtimeEngine,
+  TEXT_INPUT,
+  VOICE_DEFAULTS,
+  VoiceBridge,
+  VoiceError,
+  VoiceSession,
+  VoiceSessionController,
+  browserSocket,
+  createBrowserVoice,
+  createEngine,
+  createVoiceSession,
+  createVoiceSettings,
+  joinServerUrl,
+  parseSpeechMode,
+  readVoiceSettings,
+  startBrowserMicrophone,
+  startBrowserPlayback,
+  validateSettings
+};
+//# sourceMappingURL=index.js.map