@ouro.bot/cli 0.1.0-alpha.58 → 0.1.0-alpha.580

package/dist/senses/trust-gate.js

@@ -93,6 +93,91 @@ function writeInnerPendingNotice(bundleRoot, noticeContent, nowIso) {
     fs.mkdirSync(innerPendingDir, { recursive: true });
     fs.writeFileSync(filePath, JSON.stringify(payload), "utf-8");
 }
+const ACKNOWLEDGED_GROUPS_FILENAME = "acknowledged-auto-groups.json";
+function acknowledgedGroupsPath(bundleRoot) {
+    return path.join(bundleRoot, "state", ACKNOWLEDGED_GROUPS_FILENAME);
+}
+function loadAcknowledgedGroupsState(bundleRoot) {
+    try {
+        const raw = fs.readFileSync(acknowledgedGroupsPath(bundleRoot), "utf-8");
+        if (!raw.trim())
+            return {};
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+function persistAcknowledgedGroupsState(bundleRoot, state) {
+    const target = acknowledgedGroupsPath(bundleRoot);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+}
+/**
+ * For BlueBubbles group chats that were auto-created at stranger trust (no
+ * explicit operator/agent action ever bound the harness to this group), the
+ * gate's family-member bypass would otherwise let messages flow through
+ * silently and the agent would accumulate a session it has no mental model
+ * for. Surface the relationship as an inner-pending notice exactly once so
+ * the agent can categorize / rename / dismiss the group on its next turn.
+ *
+ * Returns true if a notice was written so callers can emit a telemetry event.
+ */
+function maybeSurfaceAutoCreatedGroup(input, bundleRoot, nowIso) {
+    // Caller guarantees isGroupChat = true (only invoked from the family-member
+    // bypass branch); skip a redundant guard here.
+    if (input.friend.trustLevel !== "stranger")
+        return false;
+    if (!input.friend.notes?.["autoCreatedGroup"])
+        return false;
+    // loadAcknowledgedGroupsState is defensive (its own try/catch returns {})
+    // so we don't wrap it in another try here.
+    const state = loadAcknowledgedGroupsState(bundleRoot);
+    if (state[input.friend.id])
+        return false;
+    const noticeContent = `New BlueBubbles group "${input.friend.name}" became active without explicit acknowledgment. ` +
+        `It was auto-created at stranger trust the first time a message routed through it. ` +
+        `If you recognize the group, label or rename it (and consider promoting trust); if not, you can leave it as a stranger group or rename it for clarity. ` +
+        `external id: ${input.externalId}; friend id: ${input.friend.id}.`;
+    try {
+        writeInnerPendingNotice(bundleRoot, noticeContent, nowIso);
+        persistAcknowledgedGroupsState(bundleRoot, {
+            ...state,
+            [input.friend.id]: { surfacedAt: nowIso },
+        });
+        (0, runtime_1.emitNervesEvent)({
+            level: "info",
+            component: "senses",
+            event: "senses.trust_gate_group_acknowledgment_surfaced",
+            message: "auto-created group surfaced for agent acknowledgment",
+            meta: {
+                friendId: input.friend.id,
+                friendName: input.friend.name,
+                externalId: input.externalId,
+                provider: input.provider,
+            },
+        });
+        return true;
+        /* v8 ignore start -- defensive: surfacing failure must not block the gate decision @preserve */
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.trust_gate_error",
+            message: "failed to surface auto-created group for acknowledgment",
+            meta: {
+                friendId: input.friend.id,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return false;
+    }
+    /* v8 ignore stop */
+}
 function enforceTrustGate(input) {
     const { senseType } = input;
     // Local (CLI) and internal (inner dialog) — always allow
@@ -104,6 +189,20 @@ function enforceTrustGate(input) {
         return { allowed: true };
     }
     // Open senses (BlueBubbles/iMessage) — enforce trust rules
+    // Group chat with a family member present — allow regardless of trust level.
+    // BUT if this is an auto-created stranger group (the harness picked it up
+    // silently via the family-member shortcut and the agent never explicitly
+    // acknowledged it), surface a one-time inner-pending notice so the agent
+    // gets a chance to categorize / rename / dismiss the relationship instead
+    // of accumulating activity invisibly.
+    if (input.isGroupChat && input.groupHasFamilyMember) {
+        /* v8 ignore start -- defaults shared with the rest of the gate; tested via the stranger-trust path */
+        const bundleRoot = input.bundleRoot ?? (0, identity_1.getAgentRoot)();
+        const nowIso = (input.now ?? (() => new Date()))().toISOString();
+        /* v8 ignore stop */
+        maybeSurfaceAutoCreatedGroup(input, bundleRoot, nowIso);
+        return { allowed: true };
+    }
     const trustLevel = input.friend.trustLevel ?? "friend";
     // Family and friend — always allow on open
     if ((0, types_1.isTrustedLevel)(trustLevel)) {
@@ -119,11 +218,7 @@ function enforceTrustGate(input) {
     return handleStranger(input, bundleRoot, nowIso);
 }
 function handleAcquaintance(input, bundleRoot, nowIso) {
-    const { isGroupChat, groupHasFamilyMember, hasExistingGroupWithFamily } = input;
-    // Group chat with family member present — allow
-    if (isGroupChat && groupHasFamilyMember) {
-        return { allowed: true };
-    }
+    const { isGroupChat, hasExistingGroupWithFamily } = input;
     let result;
     let noticeDetail;
     if (isGroupChat) {

package/dist/senses/voice/audio-playback.js

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareVoiceCallAudio = prepareVoiceCallAudio;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("fs/promises"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const SAMPLE_RATE = 8_000;
+const DEFAULT_TONE_MS = 700;
+const DEFAULT_CLIP_MS = 5_000;
+const MAX_AUDIO_MS = 20_000;
+const MAX_AUDIO_BYTES = 10 * 1024 * 1024;
+function clampDuration(value, fallback) {
+    if (value === undefined || !Number.isFinite(value))
+        return fallback;
+    return Math.min(MAX_AUDIO_MS, Math.max(80, Math.round(value)));
+}
+function clampToneHz(value) {
+    if (value === undefined || !Number.isFinite(value))
+        return 660;
+    return Math.min(3_000, Math.max(80, value));
+}
+function pcm16ToMulaw(sample) {
+    const BIAS = 0x84;
+    const CLIP = 32635;
+    let sign = 0;
+    let magnitude = Math.round(sample);
+    if (magnitude < 0) {
+        magnitude = -magnitude;
+        sign = 0x80;
+    }
+    magnitude = Math.min(CLIP, magnitude) + BIAS;
+    let exponent = 7;
+    for (let mask = 0x4000; exponent > 0 && (magnitude & mask) === 0; mask >>= 1) {
+        exponent -= 1;
+    }
+    const mantissa = (magnitude >> (exponent + 3)) & 0x0f;
+    return (~(sign | (exponent << 4) | mantissa)) & 0xff;
+}
+function generateToneMulaw(toneHz, durationMs) {
+    const sampleCount = Math.max(1, Math.round((SAMPLE_RATE * durationMs) / 1000));
+    const out = new Uint8Array(sampleCount);
+    for (let i = 0; i < sampleCount; i += 1) {
+        const envelope = Math.min(1, i / 160, (sampleCount - i) / 160);
+        const sample = Math.sin((2 * Math.PI * toneHz * i) / SAMPLE_RATE) * 9000 * Math.max(0, envelope);
+        out[i] = pcm16ToMulaw(sample);
+    }
+    return out;
+}
+function execFileText(file, args, timeout = 30_000) {
+    return new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(file, args, { timeout }, (error, stdout = "", stderr = "") => {
+            if (error) {
+                const message = stderr.toString().trim() || error.message;
+                reject(new Error(message));
+                return;
+            }
+            resolve(stdout.toString());
+        });
+    });
+}
+async function convertWithFfmpeg(input, durationMs, options) {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "ouro-voice-audio-"));
+    const inputPath = path.join(tmpDir, "input.audio");
+    const outputPath = path.join(tmpDir, "output.ulaw");
+    await fs.writeFile(inputPath, input);
+    const args = [
+        "-hide_banner",
+        "-loglevel",
+        "error",
+        "-y",
+        "-t",
+        (durationMs / 1000).toFixed(3),
+        "-i",
+        inputPath,
+        "-ac",
+        "1",
+        "-ar",
+        String(SAMPLE_RATE),
+        "-f",
+        "mulaw",
+        outputPath,
+    ];
+    const candidates = [
+        ...(options.ffmpegCandidates ?? [
+            options.ffmpegPath,
+            "ffmpeg",
+            "/opt/homebrew/bin/ffmpeg",
+            "/usr/local/bin/ffmpeg",
+            "/usr/bin/ffmpeg",
+        ]),
+    ].filter((value) => typeof value === "string" && value.trim().length > 0);
+    let lastError = null;
+    try {
+        for (const candidate of candidates) {
+            try {
+                await execFileText(candidate, args);
+                return await fs.readFile(outputPath);
+            }
+            catch (error) {
+                /* v8 ignore next -- child_process errors are Error instances in supported Node runtimes @preserve */
+                lastError = error instanceof Error ? error : new Error(String(error));
+            }
+        }
+        /* v8 ignore next -- either a candidate error or an empty candidate list is covered; v8 counts the nullish join as a branch @preserve */
+        throw lastError ?? new Error("ffmpeg unavailable");
+    }
+    finally {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+}
+async function readUrlAudio(url, fetchImpl) {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+        throw new Error("voice audio URL must be http(s)");
+    }
+    const response = await fetchImpl(parsed.toString());
+    if (!response.ok)
+        throw new Error(`voice audio URL fetch failed: ${response.status}`);
+    const contentLength = Number(response.headers.get("content-length") ?? "0");
+    if (Number.isFinite(contentLength) && contentLength > MAX_AUDIO_BYTES) {
+        throw new Error("voice audio URL is too large");
+    }
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    /* v8 ignore next -- oversized response bodies are covered; v8 under-reports the positive branch for arrayBuffer-backed Response @preserve */
+    if (bytes.byteLength > MAX_AUDIO_BYTES)
+        throw new Error("voice audio URL is too large");
+    return bytes;
+}
+async function readFileAudio(inputPath, agentRoot) {
+    const resolved = path.resolve(inputPath);
+    const allowedRoots = [
+        agentRoot ? path.resolve(agentRoot) : "",
+        path.resolve(os.tmpdir()),
+    ].filter(Boolean);
+    if (!allowedRoots.some((root) => resolved === root || resolved.startsWith(`${root}${path.sep}`))) {
+        throw new Error("voice audio files must live under the agent bundle or temp directory");
+    }
+    const stat = await fs.stat(resolved);
+    if (!stat.isFile())
+        throw new Error("voice audio path is not a file");
+    if (stat.size > MAX_AUDIO_BYTES)
+        throw new Error("voice audio file is too large");
+    return fs.readFile(resolved);
+}
+async function prepareVoiceCallAudio(request, options = {}) {
+    const source = request.source ?? "tone";
+    const label = request.label?.trim() || (source === "tone" ? "tone" : "audio clip");
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_audio_prepare_start",
+        message: "preparing voice call audio clip",
+        meta: { source, label },
+    });
+    try {
+        if (source === "tone") {
+            const durationMs = clampDuration(request.durationMs, DEFAULT_TONE_MS);
+            const prepared = {
+                label,
+                durationMs,
+                mimeType: "audio/x-mulaw;rate=8000",
+                audio: generateToneMulaw(clampToneHz(request.toneHz), durationMs),
+            };
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.voice_audio_prepare_end",
+                message: "prepared voice call audio clip",
+                meta: { source, label, durationMs: String(prepared.durationMs), byteLength: String(prepared.audio.byteLength) },
+            });
+            return prepared;
+        }
+        const durationMs = clampDuration(request.durationMs, DEFAULT_CLIP_MS);
+        /* v8 ignore next 3 -- URL and file branches are both covered; optional missing-field fallbacks are defensive @preserve */
+        const input = source === "url"
+            ? await readUrlAudio(request.url?.trim() || "", options.fetchImpl ?? fetch)
+            : await readFileAudio(request.path?.trim() || "", options.agentRoot);
+        const audio = await convertWithFfmpeg(input, durationMs, options);
+        const prepared = {
+            label,
+            durationMs: Math.min(durationMs, Math.round((audio.byteLength / SAMPLE_RATE) * 1000)),
+            mimeType: "audio/x-mulaw;rate=8000",
+            audio,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_audio_prepare_end",
+            message: "prepared voice call audio clip",
+            meta: { source, label, durationMs: String(prepared.durationMs), byteLength: String(prepared.audio.byteLength) },
+        });
+        return prepared;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_audio_prepare_error",
+            message: "failed to prepare voice call audio clip",
+            /* v8 ignore next -- catches in this module throw Error objects @preserve */
+            meta: { source, label, error: error instanceof Error ? error.message : String(error) },
+        });
+        throw error;
+    }
+}

package/dist/senses/voice/audio-routing.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodeVoiceCommandRunner = createNodeVoiceCommandRunner;
+exports.inspectVoiceAudioRouting = inspectVoiceAudioRouting;
+const child_process_1 = require("child_process");
+const runtime_1 = require("../../nerves/runtime");
+function createNodeVoiceCommandRunner() {
+    return (command, args, options) => new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+        const stdout = [];
+        const stderr = [];
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new Error(`command timed out after ${options.timeoutMs}ms`));
+        }, options.timeoutMs);
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (exitCode) => {
+            clearTimeout(timer);
+            resolve({
+                stdout: Buffer.concat(stdout).toString("utf8"),
+                stderr: Buffer.concat(stderr).toString("utf8"),
+                exitCode: exitCode ?? 0,
+            });
+        });
+    });
+}
+function parseDeviceLines(output) {
+    return output
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function commandFailureMessage(exitCode, result) {
+    const stderr = result.stderr?.trim();
+    if (stderr)
+        return stderr;
+    const stdout = result.stdout?.trim();
+    if (stdout)
+        return stdout;
+    return `exit ${exitCode}`;
+}
+function setupGuidance(missing, currentOutput, outputDeviceName) {
+    const guidance = missing.map((device) => `Install or configure the local audio device: ${device}.`);
+    if (currentOutput && currentOutput !== outputDeviceName) {
+        guidance.push(`Browser meeting audio should be routed through ${outputDeviceName}; current output is ${currentOutput}.`);
+    }
+    return guidance;
+}
+async function inspectVoiceAudioRouting(options = {}) {
+    const commandRunner = options.commandRunner ?? createNodeVoiceCommandRunner();
+    const switchAudioSourcePath = options.switchAudioSourcePath ?? "SwitchAudioSource";
+    const captureDeviceName = options.captureDeviceName ?? "BlackHole 2ch";
+    const outputDeviceName = options.outputDeviceName ?? "Multi-Output Device";
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    try {
+        const devicesResult = await commandRunner(switchAudioSourcePath, ["-a"], { timeoutMs });
+        if (typeof devicesResult.exitCode === "number" && devicesResult.exitCode !== 0) {
+            throw new Error(commandFailureMessage(devicesResult.exitCode, devicesResult));
+        }
+        const currentResult = await commandRunner(switchAudioSourcePath, ["-c"], { timeoutMs });
+        if (typeof currentResult.exitCode === "number" && currentResult.exitCode !== 0) {
+            throw new Error(commandFailureMessage(currentResult.exitCode, currentResult));
+        }
+        const devices = parseDeviceLines(devicesResult.stdout ?? "");
+        const currentOutput = parseDeviceLines(currentResult.stdout ?? "")[0] ?? null;
+        const hasCaptureDevice = devices.includes(captureDeviceName);
+        const hasOutputDevice = devices.includes(outputDeviceName);
+        const missing = [
+            ...(hasCaptureDevice ? [] : [captureDeviceName]),
+            ...(hasOutputDevice ? [] : [outputDeviceName]),
+        ];
+        const result = {
+            status: missing.length === 0 ? "ready" : "needs_setup",
+            hasCaptureDevice,
+            hasOutputDevice,
+            currentOutput,
+            missing,
+            guidance: setupGuidance(missing, currentOutput, outputDeviceName),
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_audio_routing_checked",
+            message: "voice audio routing readiness checked",
+            meta: {
+                status: result.status,
+                hasCaptureDevice,
+                hasOutputDevice,
+                currentOutput,
+                missing,
+            },
+        });
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const result = {
+            status: "unknown",
+            hasCaptureDevice: false,
+            hasOutputDevice: false,
+            currentOutput: null,
+            missing: [captureDeviceName, outputDeviceName],
+            guidance: setupGuidance([captureDeviceName, outputDeviceName], null, outputDeviceName),
+            error: message,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_audio_routing_error",
+            message: "voice audio routing readiness check failed",
+            meta: { error: message, missing: result.missing },
+        });
+        return result;
+    }
+}

package/dist/senses/voice/elevenlabs.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ELEVENLABS_MIME_TYPE = exports.DEFAULT_ELEVENLABS_OUTPUT_FORMAT = exports.DEFAULT_ELEVENLABS_MODEL_ID = void 0;
+exports.createNodeElevenLabsSocketFactory = createNodeElevenLabsSocketFactory;
+exports.createElevenLabsTtsClient = createElevenLabsTtsClient;
+const runtime_1 = require("../../nerves/runtime");
+exports.DEFAULT_ELEVENLABS_MODEL_ID = "eleven_flash_v2_5";
+exports.DEFAULT_ELEVENLABS_OUTPUT_FORMAT = "pcm_16000";
+exports.DEFAULT_ELEVENLABS_MIME_TYPE = "audio/pcm;rate=16000";
+function cleanTtsText(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function elevenLabsStreamUrl(voiceId, modelId, outputFormat, autoMode) {
+    const params = new URLSearchParams({ model_id: modelId, output_format: outputFormat });
+    if (autoMode)
+        params.set("auto_mode", "true");
+    return `wss://api.elevenlabs.io/v1/text-to-speech/${encodeURIComponent(voiceId)}/stream-input?${params.toString()}`;
+}
+function mimeTypeForOutputFormat(outputFormat) {
+    if (outputFormat === "pcm_16000")
+        return "audio/pcm;rate=16000";
+    if (outputFormat === "ulaw_8000")
+        return "audio/x-mulaw;rate=8000";
+    if (outputFormat.startsWith("pcm_")) {
+        const rate = outputFormat.slice("pcm_".length);
+        return /^\d+$/.test(rate) ? `audio/pcm;rate=${rate}` : "audio/pcm";
+    }
+    return "audio/mpeg";
+}
+function payloadText(payload) {
+    if (payload && typeof payload === "object" && "data" in payload) {
+        return payloadText(payload.data);
+    }
+    if (typeof payload === "string")
+        return payload;
+    if (Buffer.isBuffer(payload))
+        return payload.toString("utf8");
+    return String(payload ?? "");
+}
+function createNodeElevenLabsSocketFactory(webSocketConstructor) {
+    const WebSocketConstructor = webSocketConstructor
+        ?? globalThis.WebSocket;
+    if (!WebSocketConstructor) {
+        throw new Error("global WebSocket is unavailable; inject an ElevenLabs socketFactory");
+    }
+    return (url) => {
+        const socket = new WebSocketConstructor(url);
+        const handlers = {
+            open: [],
+            message: [],
+            error: [],
+            close: [],
+        };
+        const emit = (event, payload) => {
+            for (const handler of handlers[event]) {
+                handler(payload);
+            }
+        };
+        const attach = (event) => {
+            const listener = (payload) => emit(event, payload);
+            if (typeof socket.addEventListener === "function") {
+                socket.addEventListener(event, listener);
+            }
+            else if (typeof socket.on === "function") {
+                socket.on(event, listener);
+            }
+            else {
+                socket[`on${event}`] = listener;
+            }
+        };
+        attach("open");
+        attach("message");
+        attach("error");
+        attach("close");
+        return {
+            on(event, handler) {
+                handlers[event].push(handler);
+            },
+            send(payload) {
+                socket.send(payload);
+            },
+            close() {
+                socket.close();
+            },
+        };
+    };
+}
+function createElevenLabsTtsClient(options) {
+    const modelId = options.modelId ?? exports.DEFAULT_ELEVENLABS_MODEL_ID;
+    const outputFormat = options.outputFormat ?? exports.DEFAULT_ELEVENLABS_OUTPUT_FORMAT;
+    const autoMode = options.autoMode ?? true;
+    const socketFactory = options.socketFactory ?? createNodeElevenLabsSocketFactory();
+    const mimeType = mimeTypeForOutputFormat(outputFormat);
+    return {
+        async synthesize(request) {
+            const text = cleanTtsText(request.text);
+            if (!text) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.voice_tts_error",
+                    message: "voice TTS text is empty",
+                    meta: { utteranceId: request.utteranceId },
+                });
+                throw new Error("voice TTS text is empty");
+            }
+            const url = elevenLabsStreamUrl(options.voiceId, modelId, outputFormat, autoMode);
+            const socket = socketFactory(url);
+            const chunks = [];
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.voice_tts_start",
+                message: "starting ElevenLabs TTS",
+                meta: { utteranceId: request.utteranceId, modelId, voiceId: options.voiceId },
+            });
+            return new Promise((resolve, reject) => {
+                let settled = false;
+                const fail = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    const message = error instanceof Error ? error.message : String(error);
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "error",
+                        component: "senses",
+                        event: "senses.voice_tts_error",
+                        message: "ElevenLabs TTS failed",
+                        meta: { utteranceId: request.utteranceId, error: message },
+                    });
+                    reject(new Error(`ElevenLabs TTS failed: ${message}`));
+                };
+                const finish = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    const audio = Buffer.concat(chunks);
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "senses",
+                        event: "senses.voice_tts_end",
+                        message: "finished ElevenLabs TTS",
+                        meta: { utteranceId: request.utteranceId, chunkCount: chunks.length, byteLength: audio.byteLength },
+                    });
+                    socket.close();
+                    resolve({
+                        utteranceId: request.utteranceId,
+                        audio,
+                        byteLength: audio.byteLength,
+                        chunkCount: chunks.length,
+                        modelId,
+                        voiceId: options.voiceId,
+                        mimeType,
+                    });
+                };
+                socket.on("open", () => {
+                    socket.send(JSON.stringify({
+                        text: " ",
+                        xi_api_key: options.apiKey,
+                        voice_settings: {
+                            stability: 0.5,
+                            similarity_boost: 0.8,
+                            use_speaker_boost: true,
+                        },
+                    }));
+                    socket.send(JSON.stringify({ text, try_trigger_generation: true }));
+                    socket.send(JSON.stringify({ text: "" }));
+                });
+                socket.on("message", (payload) => {
+                    try {
+                        const parsed = JSON.parse(payloadText(payload));
+                        if (typeof parsed.audio === "string" && parsed.audio.length > 0) {
+                            const chunk = Buffer.from(parsed.audio, "base64");
+                            chunks.push(chunk);
+                            if (request.onAudioChunk) {
+                                try {
+                                    const chunkResult = request.onAudioChunk(chunk);
+                                    if (chunkResult && typeof chunkResult.then === "function") {
+                                        void chunkResult.catch(fail);
+                                    }
+                                }
+                                catch (error) {
+                                    fail(error);
+                                }
+                            }
+                        }
+                        if (parsed.isFinal === true) {
+                            finish();
+                        }
+                    }
+                    catch (error) {
+                        fail(error);
+                    }
+                });
+                socket.on("error", fail);
+                socket.on("close", () => {
+                    if (!settled) {
+                        fail(new Error("socket closed before final audio"));
+                    }
+                });
+            });
+        },
+    };
+}