@olares/lares-core 0.15.11 → 0.15.13

package/voice/browser-capture.js

@@ -0,0 +1,274 @@
+import {
+  formatElapsed,
+  isRecordingTooShort,
+  pickRecordingMime,
+} from "./recorder.js";
+
+export { formatElapsed };
+
+/** Phone mic. Bare booleans are exact and iOS rejects the headset profile. */
+const DEVICE_AUDIO = {
+  channelCount: { ideal: 1 },
+  echoCancellation: { ideal: true },
+  noiseSuppression: { ideal: true },
+  autoGainControl: { ideal: true },
+};
+
+const CHUNK_MS = 250;
+
+function micFailure(err) {
+  const name = err?.name || "";
+  if (name === "NotAllowedError" || name === "PermissionDeniedError") return "voice_permission_denied";
+  if (name === "SecurityError") return "voice_unsupported";
+  return "voice_failed";
+}
+
+async function openDeviceMic(mediaDevices) {
+  try {
+    return await mediaDevices.getUserMedia({ audio: DEVICE_AUDIO });
+  } catch (err) {
+    if (micFailure(err) !== "voice_failed") throw err;
+    return mediaDevices.getUserMedia({ audio: true });
+  }
+}
+
+export function createVoiceCapture({
+  transcribe,
+  submit,
+  onStream,
+  onPhase,
+  onTrace,
+  now = Date.now,
+  media,
+}) {
+  const mediaDevices = media?.mediaDevices ?? globalThis.navigator?.mediaDevices;
+  const Recorder = media?.MediaRecorder ?? globalThis.MediaRecorder;
+  let recorder = null;
+  let detector = null;
+  let stream = null;
+  let chunks = [];
+  let started = 0;
+  let timer = 0;
+  let errorTimer = 0;
+  let finishTimer = 0;
+  let cancel = false;
+  let released = false;
+  let finished = false;
+  let dead = false;
+  let abort = null;
+  let phase = "idle";
+
+  const emit = (next, extra = {}) => {
+    phase = next;
+    onPhase?.(next, extra);
+  };
+
+  const trace = (event, fields) => {
+    try {
+      onTrace?.(event, fields);
+    } catch {
+      /* a trace must not change the take */
+    }
+  };
+
+  const stopTimer = () => {
+    if (timer) {
+      clearInterval(timer);
+      timer = 0;
+    }
+  };
+
+  const release = () => {
+    detector?.stop?.();
+    detector = null;
+    stream?.getTracks().forEach((track) => track.stop());
+    stream = null;
+    recorder = null;
+  };
+
+  const fail = (code) => {
+    if (dead) return;
+    if (errorTimer) clearTimeout(errorTimer);
+    emit("error", { error: code, elapsed: 0 });
+    errorTimer = setTimeout(() => {
+      errorTimer = 0;
+      if (!dead && phase === "error") emit("idle", { error: "", elapsed: 0 });
+    }, 3200);
+  };
+
+  const finish = async () => {
+    if (finished || dead) return;
+    finished = true;
+    stopTimer();
+    const took = now() - started;
+    const type = recorder?.mimeType || chunks[0]?.type || "audio/webm";
+    const blobChunks = chunks;
+    chunks = [];
+    release();
+    if (cancel) {
+      emit("idle", { error: "", elapsed: 0 });
+      return;
+    }
+    const blob = new Blob(blobChunks, { type });
+    trace("blob", { bytes: blob.size, type, ms: took, chunks: blobChunks.length });
+    if (isRecordingTooShort(took, blob.size)) {
+      trace("too-short", { bytes: blob.size, ms: took });
+      fail("voice_too_short");
+      return;
+    }
+    emit("transcribing", { elapsed: took, error: "" });
+    abort = new AbortController();
+    try {
+      const text = String(await transcribe(blob, abort.signal) ?? "").trim();
+      if (dead || cancel) return;
+      if (!text) {
+        trace("no-input", {});
+        fail("voice_no_input");
+        return;
+      }
+      trace("transcript", { chars: text.length });
+      emit("idle", { error: "", elapsed: 0 });
+      await submit?.(text);
+    } catch (err) {
+      if (dead || abort.signal.aborted || cancel) return;
+      const code = err instanceof Error ? err.message : "voice_failed";
+      trace("transcribe-error", { code });
+      fail(code);
+    } finally {
+      abort = null;
+    }
+  };
+
+  const scheduleFinish = () => {
+    if (finishTimer) clearTimeout(finishTimer);
+    finishTimer = setTimeout(() => {
+      finishTimer = 0;
+      void finish();
+    }, 30);
+  };
+
+  const endRecorder = () => {
+    if (!recorder || recorder.state === "inactive") {
+      scheduleFinish();
+      return;
+    }
+    try {
+      recorder.requestData?.();
+    } catch {
+      /* the final dataavailable still arrives from stop() */
+    }
+    try {
+      recorder.stop();
+    } catch {
+      scheduleFinish();
+    }
+  };
+
+  return {
+    get phase() {
+      return phase;
+    },
+    async start() {
+      if (dead || phase === "preparing" || phase === "recording" || phase === "transcribing") return;
+      if (typeof Recorder === "undefined" || !mediaDevices?.getUserMedia) {
+        fail("voice_unsupported");
+        return;
+      }
+      cancel = false;
+      released = false;
+      finished = false;
+      trace("open", {});
+      emit("preparing", { elapsed: 0, error: "" });
+      let next;
+      try {
+        next = await openDeviceMic(mediaDevices);
+      } catch (err) {
+        const code = micFailure(err);
+        trace("mic-fail", { code, name: err?.name || "" });
+        if (!dead) fail(code);
+        return;
+      }
+      if (dead || cancel) {
+        next.getTracks().forEach((track) => track.stop());
+        if (!dead && phase === "preparing") emit("idle", { error: "", elapsed: 0 });
+        return;
+      }
+      stream = next;
+      chunks = [];
+      const mime = pickRecordingMime(Recorder);
+      try {
+        recorder = new Recorder(stream, mime ? { mimeType: mime } : undefined);
+      } catch {
+        release();
+        fail("voice_unsupported");
+        return;
+      }
+      recorder.ondataavailable = (event) => {
+        if (event.data?.size) chunks.push(event.data);
+        if (recorder?.state === "inactive") scheduleFinish();
+      };
+      recorder.onstop = () => scheduleFinish();
+      try { detector = await onStream?.(stream); } catch { release(); fail("voice_unsupported"); return; }
+      started = now();
+      try {
+        recorder.start(CHUNK_MS);
+      } catch {
+        trace("record-fail", { mime });
+        release();
+        fail("voice_unsupported");
+        return;
+      }
+      trace("recording", { mime: recorder.mimeType || mime || "" });
+      if (released || cancel) {
+        endRecorder();
+        return;
+      }
+      emit("recording", { elapsed: 0, error: "" });
+      timer = setInterval(() => emit("recording", { elapsed: now() - started, error: "" }), 200);
+    },
+    /**
+     * Finger-up finishes the take. The mic opens asynchronously, so the finger
+     * often lifts while still preparing — that is not a cancel.
+     */
+    stop(aborting = false) {
+      if (phase === "transcribing") {
+        if (aborting) {
+          cancel = true;
+          abort?.abort();
+        }
+        return;
+      }
+      if (phase !== "preparing" && phase !== "recording") {
+        trace("stop-ignored", { aborting: Boolean(aborting), phase });
+        return;
+      }
+      trace("stop", {
+        aborting: Boolean(aborting),
+        phase,
+        recorder: recorder?.state || "none",
+      });
+      if (aborting) {
+        cancel = true;
+        released = false;
+        if (recorder && recorder.state !== "inactive") recorder.stop();
+        return;
+      }
+      released = true;
+      stopTimer();
+      if (recorder && recorder.state !== "inactive") {
+        emit("transcribing", { elapsed: now() - started, error: "" });
+        endRecorder();
+      }
+    },
+    dispose() {
+      dead = true;
+      cancel = true;
+      if (errorTimer) clearTimeout(errorTimer);
+      if (finishTimer) clearTimeout(finishTimer);
+      stopTimer();
+      abort?.abort();
+      if (recorder && recorder.state !== "inactive") recorder.stop();
+      release();
+    },
+  };
+}

package/voice/browser-playback.js

@@ -0,0 +1,30 @@
+export function createBrowserPlayer() {
+  let element = null;
+  let finish = null;
+  const stop = () => {
+    element?.pause();
+    finish?.();
+  };
+  return {
+    play(blob) {
+      stop();
+      return new Promise((resolve) => {
+        const url = URL.createObjectURL(blob);
+        const audio = new Audio(url);
+        const done = () => {
+          if (finish !== done) return;
+          finish = null;
+          element = null;
+          URL.revokeObjectURL(url);
+          resolve();
+        };
+        element = audio;
+        finish = done;
+        audio.addEventListener("ended", done, { once: true });
+        audio.addEventListener("error", done, { once: true });
+        audio.play().catch(done);
+      });
+    },
+    stop,
+  };
+}

package/voice/capture.js

@@ -7,6 +7,8 @@ const FRAME_MS = 32;
 const NO_INPUT_MS = 10_000;
 const POLL_MS = 40;
 const CLIENT_LOST_MS = 5000;
+const MAX_CAPTURE_MS = 60_000;
+const MAX_CAPTURE_BYTES = 16_000 * 2 * MAX_CAPTURE_MS / 1000;
 const HOST_RATE = 16_000;
 const PLAYBACK_SETTLE_MS = 320;
 const PLAYBACK_LEADING_MS = 2500;
@@ -125,7 +127,13 @@ export function createCaptureSession(io) {
       controller: new AbortController(),
     };
     job = run;
-    const opened = await io.open();
+    let opened;
+    try { opened = await io.open(); }
+    catch (error) {
+      run.phase = "error";
+      run.error = error?.code || "voice_failed";
+      throw error;
+    }
     if (run.cancel) {
       await io.close?.();
       run.phase = "idle";
@@ -161,7 +169,9 @@ export function createCaptureSession(io) {
       try {
         while (run === job && run.phase !== "done" && run.phase !== "error" && run.phase !== "idle") {
           if (run.phase === "recording" && now() - run.seen > CLIENT_LOST_MS) run.cancel = true;
-          const fresh = await io.read(offset);
+          const available = await io.read(offset);
+          const fresh = available.subarray(0, Math.max(0, MAX_CAPTURE_BYTES - pcm.length));
+          if (fresh.length < available.length || now() - started >= MAX_CAPTURE_MS) run.stop = true;
           offset += fresh.length;
           if (fresh.length) {
             pcm = Buffer.concat([pcm, fresh]);

package/voice/client.js

@@ -1,8 +1,14 @@
+import { mintRpcId } from "../larepass/rpc.js";
 import { createSnapshotStore } from "../tools/async.js";
 
 export const API = "/api/lares/voice";
 
 const settings = createSnapshotStore();
+export const voiceClientId = mintRpcId();
+export function voiceHeaders(device) {
+  const selected = device ?? settings.peek()?.config?.device;
+  return { "x-lares-voice-id": voiceClientId, "x-lares-voice-device": selected === "device" ? "device" : "headset" };
+}
 
 export function rememberedVoiceSettings() {
   return settings.peek();
@@ -21,6 +27,9 @@ export async function loadVoiceSettings(options = {}) {
       status,
       sttModels: Array.isArray(models.stt) ? models.stt : [],
       ttsModels: Array.isArray(models.tts) ? models.tts : [],
+      chatModels: Array.isArray(models.chat) ? models.chat : [],
+      realtimeModels: Array.isArray(models.realtime) ? models.realtime : [],
+      realtimeReady: Array.isArray(models.realtimeReady) ? models.realtimeReady : [],
       charts: {
         stt: chartView(models.charts?.stt),
         tts: chartView(models.charts?.tts),
@@ -67,7 +76,7 @@ export function wavBlob(base64) {
 export async function postSpeak({ key, text, done, part }) {
   const res = await fetch(`${API}/speak`, {
     method: "POST",
-    headers: { "content-type": "application/json" },
+    headers: { "content-type": "application/json", ...voiceHeaders() },
     body: JSON.stringify(Number.isInteger(part) ? { key, text, done, part } : { key, text, done }),
   });
   let body = null;
@@ -88,7 +97,7 @@ export async function postSpeak({ key, text, done, part }) {
 }
 
 export async function postPlaybackStop(signal) {
-  const res = await fetch(`${API}/playback/stop`, { method: "POST", signal });
+  const res = await fetch(`${API}/playback/stop`, { method: "POST", signal, headers: voiceHeaders() });
   if (!res.ok) throw new Error(String(res.status));
   return res.json();
 }
@@ -110,14 +119,24 @@ export async function loadGpuMode() {
   return res.json();
 }
 
+/** A failed GPU request keeps the Host's code and params for gpuProblemText. */
+async function gpuResponse(res) {
+  const payload = await res.json().catch(() => null);
+  if (res.ok) return payload;
+  const error = payload?.error;
+  throw Object.assign(new Error(error?.message || String(res.status)), {
+    code: typeof error?.code === "string" ? error.code : "voice_gpu_failed",
+    params: error?.params && typeof error.params === "object" ? error.params : {},
+  });
+}
+
 export async function switchGpuMode(streaming) {
   const res = await fetch(`${API}/gpu-mode`, {
     method: "POST",
     headers: { "content-type": "application/json" },
     body: JSON.stringify({ streaming }),
   });
-  if (!res.ok) throw new Error(String(res.status));
-  return res.json();
+  return gpuResponse(res);
 }
 
 /** @param {{ app: string, enabled: boolean, memory: number }[]} apps memory in bytes */
@@ -127,9 +146,7 @@ export async function saveSlicePlan(apps) {
     headers: { "content-type": "application/json" },
     body: JSON.stringify({ apps }),
   });
-  const payload = await res.json().catch(() => null);
-  if (!res.ok) throw Object.assign(new Error(payload?.error?.message || String(res.status)), { code: payload?.error?.code });
-  return payload;
+  return gpuResponse(res);
 }
 
 /** @param {string} app @param {"resume" | "stop"} op */
@@ -139,9 +156,7 @@ export async function postGpuApp(app, op) {
     headers: { "content-type": "application/json" },
     body: JSON.stringify({ app, op }),
   });
-  const payload = await res.json().catch(() => null);
-  if (!res.ok) throw new Error(payload?.error?.message || String(res.status));
-  return payload;
+  return gpuResponse(res);
 }
 
 function transcribeErrorCode(payload) {
@@ -187,19 +202,19 @@ async function readVoiceJson(res) {
 
 /** Host recording. `skipped` means the headset microphone is not available. */
 export async function postCaptureStart(signal) {
-  return readVoiceJson(await fetch(`${API}/capture`, { method: "POST", signal }));
+  return readVoiceJson(await fetch(`${API}/capture`, { method: "POST", signal, headers: voiceHeaders() }));
 }
 
 export async function getCapture(signal) {
-  return readVoiceJson(await fetch(`${API}/capture`, { signal }));
+  return readVoiceJson(await fetch(`${API}/capture`, { signal, headers: voiceHeaders() }));
 }
 
 export async function postCaptureStop(signal) {
-  return readVoiceJson(await fetch(`${API}/capture/stop`, { method: "POST", signal }));
+  return readVoiceJson(await fetch(`${API}/capture/stop`, { method: "POST", signal, headers: voiceHeaders() }));
 }
 
 export async function postCaptureCancel(signal) {
-  return readVoiceJson(await fetch(`${API}/capture/cancel`, { method: "POST", signal }));
+  return readVoiceJson(await fetch(`${API}/capture/cancel`, { method: "POST", signal, headers: voiceHeaders() }));
 }
 
 export async function postBluetoothReady(signal) {

package/voice/composite-gateway.js

@@ -0,0 +1,156 @@
+import { randomUUID } from "node:crypto";
+import { WebSocketServer } from "ws";
+import { verifyVoicePrincipal, authorizeVoicePreset } from "./external.js";
+import { createSpeechEndpoint, frameRms } from "./endpoint.js";
+import { pcmSamples } from "./realtime-audio.js";
+
+export const COMPOSITE_CAPABILITIES = Object.freeze({ protocol: "olares-voice-ws-v1", transport: "websocket", input: "pcm16-mono-24000", output: "pcm16-mono-24000", turnDetection: ["manual", "server_vad"], contextResume: true, requiresPlaybackAck: true, clientTools: false, truncation: false, webrtc: false, sip: false, usage: "child-models" });
+
+/** Minimal declared Realtime subset. It never accepts arbitrary client tools or business bindings. */
+export function createCompositeGateway({ service, config, transcribe, synthesize, secret, grants = {}, hostOwner = "", enabled = false }) {
+  const server = new WebSocketServer({ noServer: true, maxPayload: 96 * 1024, perMessageDeflate: false });
+  const clients = new Map();
+  const nonces = new Map();
+  return {
+    capabilities: () => ({ ...COMPOSITE_CAPABILITIES, enabled: enabled && typeof secret === "string" && secret.length >= 32 }),
+    upgrade(req, socket, head) {
+      let identity;
+      let grant;
+      try {
+        if (!enabled) throw new Error("voice_external_disabled");
+        identity = verifyVoicePrincipal(req.headers, secret);
+        const model = new URL(req.url, "http://voice.invalid").searchParams.get("model");
+        grant = authorizeVoicePreset(identity, grants, model);
+        if (["assistant", "direct"].includes(grant.preset) && grant.owner !== hostOwner) throw new Error("voice_external_owner_mismatch");
+        const dependencies = config();
+        if ([dependencies.model, dependencies.chatModel, dependencies.ttsModel, dependencies.realtimeModel].some((id) => id === model || id?.endsWith(`/${model}`))) throw new Error("voice_recursive_model");
+        for (const [nonce, expires] of nonces) if (expires < Date.now()) nonces.delete(nonce);
+        if (nonces.has(identity.nonce) || nonces.size >= 4096 || clients.size >= 64) throw new Error("voice_external_limit");
+        nonces.set(identity.nonce, Date.now() + 120000);
+      } catch {
+        socket.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n"); return;
+      }
+      server.handleUpgrade(req, socket, head, (client) => {
+        clients.set(client, () => close());
+        const scope = { id: randomUUID(), owner: grant.owner, authorizedBinding: grant, device: "device" };
+        let chunks = [], bytes = 0, automatic = false, closed = false, busy = false, generation = 0, seconds = 0;
+        let endpoint = createSpeechEndpoint({ silenceMs: config().endpointSilenceMs || 500 });
+        let lastReply = null;
+        let awaitingPlayback = false;
+        let audioOutput = true;
+        let responseId = null;
+        let speaking = false;
+        let configuring = false;
+        let submittedTurns = 0;
+        let alive = true;
+        const send = (event) => {
+          if (client.readyState !== 1) return;
+          if (client.bufferedAmount > 1024 * 1024) { close(); return; }
+          client.send(JSON.stringify({ event_id: randomUUID(), ...event }));
+        };
+        const reset = () => { chunks = []; bytes = 0; speaking = false; endpoint = createSpeechEndpoint({ silenceMs: config().endpointSilenceMs || 500 }); };
+        const done = (id, status = "completed") => send({ type: "response.done", response: { id, status, output: [] }, voice_usage: { input_audio_seconds: seconds, billing: "child-models" } });
+        const emit = async (text, id, epoch) => {
+          responseId = id;
+          send({ type: "response.created", response: { id, status: "in_progress" } });
+          send({ type: "response.output_audio_transcript.delta", response_id: id, delta: text });
+          if (!audioOutput) { done(id); return; }
+          scope.outputAbort = new AbortController();
+          const audio = await synthesize(text, scope);
+          if (closed || epoch !== generation) return;
+          awaitingPlayback = true;
+          for (let offset = 0; offset < audio.length; offset += 24000) send({ type: "response.output_audio.delta", response_id: id, item_id: id, delta: audio.subarray(offset, offset + 24000).toString("base64") });
+          send({ type: "response.output_audio.done", response_id: id });
+          done(id);
+        };
+        const commit = async () => {
+          if (!bytes || busy) return;
+          const input = Buffer.concat(chunks); reset(); busy = true;
+          const epoch = generation;
+          const id = randomUUID(); submittedTurns++;
+          try {
+            let text = await transcribe(input, scope);
+            if (grant.preset === "dictation") text = await service.clean(scope, text);
+            if (closed || epoch !== generation || !text.trim()) return;
+            send({ type: "conversation.item.input_audio_transcription.completed", item_id: id, content_index: 0, transcript: text });
+            if (grant.preset === "dictation") return;
+            const state = await service.prompt(scope, { text, requestId: id });
+            if (closed || epoch !== generation) return;
+            if (state.utterance?.text && !state.utterance.silent) { lastReply = state.utterance.key; await emit(state.utterance.text, id, epoch); }
+          } catch (cause) { if (!closed && epoch === generation) send({ type: "error", error: { code: cause.code || "voice_failed", message: "Voice operation failed" } }); }
+          finally { busy = false; }
+        };
+        const close = () => {
+          if (closed) return;
+          closed = true; scope.outputAbort?.abort(); generation++; reset(); clearInterval(heartbeat); clearInterval(results); clearTimeout(idle);
+          clients.delete(client); client.close(); void service.close(scope).catch(() => {});
+        };
+        let idle;
+        const touch = () => { clearTimeout(idle); idle = setTimeout(close, config().idleTimeoutMs || 300000); };
+        touch();
+        const heartbeat = setInterval(() => { if (!alive) close(); else { alive = false; client.ping(); } }, 15000);
+        const results = setInterval(() => {
+          if (!scope.active || busy || speaking || awaitingPlayback) return;
+          try {
+            const state = service.state(scope);
+            if (!state.utterance?.text || state.utterance.key === lastReply || state.utterance.silent) return;
+            lastReply = state.utterance.key; busy = true;
+            void emit(state.utterance.text, randomUUID(), generation).catch(() => close()).finally(() => { busy = false; });
+          } catch { close(); }
+        }, 250);
+        client.on("pong", () => { alive = true; });
+        client.on("close", close); client.on("error", close);
+        void service.open(scope, { preset: grant.preset, sessionId: grant.sessionId, readAloud: false }).then(() => {
+          send({ type: "session.created", session: { id: scope.id, voice_context_id: scope.contextId, model: identity.model, type: "realtime", capabilities: COMPOSITE_CAPABILITIES } });
+          client.on("message", async (raw) => {
+            try {
+              if (configuring) throw new Error("voice_not_ready");
+              const event = JSON.parse(raw.toString());
+              if (event.type === "session.update") {
+                touch();
+                const session = event.session || {};
+                if (session.type && session.type !== "realtime") throw new Error("voice_session_forbidden");
+                if (session.audio?.input && Object.keys(session.audio.input).some((key) => !["format", "turn_detection"].includes(key))) throw new Error("voice_audio_unsupported");
+                if (session.audio?.output && Object.keys(session.audio.output).some((key) => key !== "format")) throw new Error("voice_audio_unsupported");
+                if (Object.keys(session).some((key) => !["type", "model", "audio", "output_modalities", "voice_context_id"].includes(key)) || (session.model && session.model !== identity.model)) throw new Error("voice_session_forbidden");
+                if (session.voice_context_id && session.voice_context_id !== scope.contextId) {
+                  if (submittedTurns || bytes || busy) throw new Error("voice_context_locked");
+                  configuring = true;
+                  try {
+                    await service.close(scope);
+                    await service.open(scope, { preset: grant.preset, sessionId: grant.sessionId, contextId: session.voice_context_id, readAloud: false });
+                  } finally { configuring = false; }
+                }
+                const detection = session.audio?.input?.turn_detection;
+                if (detection && (detection.type !== "server_vad" || Object.keys(detection).some((key) => key !== "type"))) throw new Error("voice_turn_detection_unsupported");
+                for (const format of [session.audio?.input?.format, session.audio?.output?.format].filter(Boolean)) if (format.type !== "audio/pcm" || format.rate !== 24000) throw new Error("voice_audio_format");
+                if (session.output_modalities && (!Array.isArray(session.output_modalities) || session.output_modalities.length !== 1 || !["audio", "text"].includes(session.output_modalities[0]))) throw new Error("voice_output_unsupported");
+                audioOutput = !session.output_modalities || session.output_modalities[0] === "audio";
+                automatic = detection?.type === "server_vad";
+                send({ type: "session.updated", session: { id: scope.id, voice_context_id: scope.contextId, model: identity.model, type: "realtime", capabilities: COMPOSITE_CAPABILITIES } });
+              } else if (event.type === "input_audio_buffer.append") {
+                if (awaitingPlayback) throw new Error("voice_waiting_for_playback");
+                if (busy) throw new Error("voice_turn_busy");
+                if (typeof event.audio !== "string" || event.audio.length > 64000 || !/^[A-Za-z0-9+/]*={0,2}$/.test(event.audio)) throw new Error("voice_audio_format");
+                const chunk = Buffer.from(event.audio, "base64");
+                if (chunk.length % 2 || bytes + chunk.length > 2880000) throw new Error("voice_audio_limit");
+                chunks.push(chunk); bytes += chunk.length; seconds += chunk.length / 48000;
+                const samples = pcmSamples(chunk);
+                if (frameRms(samples) >= 0.004) touch();
+                if (frameRms(samples) >= 0.004 && !speaking) { speaking = true; scope.voiceInputActive = true; send({ type: "input_audio_buffer.speech_started" }); }
+                if (automatic && endpoint.push(1, frameRms(samples), chunk.length / 48)) {
+                  scope.voiceInputActive = false; send({ type: "input_audio_buffer.speech_stopped" }); void commit();
+                }
+              } else if (event.type === "input_audio_buffer.commit") { scope.voiceInputActive = false; void commit(); }
+              else if (event.type === "input_audio_buffer.clear") { reset(); scope.voiceInputActive = false; send({ type: "input_audio_buffer.cleared" }); }
+              else if (event.type === "voice.playback.completed") { awaitingPlayback = false; }
+              else if (event.type === "response.cancel") { scope.outputAbort?.abort(); generation++; reset(); awaitingPlayback = false; done(responseId || randomUUID(), "cancelled"); }
+              else throw new Error("voice_event_unsupported");
+            } catch (cause) { send({ type: "error", error: { code: cause.message, message: "Unsupported or invalid voice event" } }); }
+          });
+        }).catch(close);
+      });
+    },
+    close() { for (const close of clients.values()) close(); server.close(); },
+  };
+}