@ouro.bot/cli 0.1.0-alpha.560 → 0.1.0-alpha.562

package/dist/senses/voice/golden-path.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVoiceGoldenPath = runVoiceGoldenPath;
+const runtime_1 = require("../../nerves/runtime");
+const audio_routing_1 = require("./audio-routing");
+const meeting_1 = require("./meeting");
+const playback_1 = require("./playback");
+const turn_1 = require("./turn");
+const defaultVoiceMeetingJoiner = {
+    async join(request) {
+        const result = {
+            status: "manual_required",
+            detail: `Open ${request.meeting.redactedUrl} in a browser profile whose meeting audio is routed through Multi-Output Device.`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_meeting_join_manual_required",
+            message: "voice meeting join requires browser handoff",
+            meta: {
+                provider: request.meeting.provider,
+                sessionKey: request.meeting.sessionKey,
+                routingStatus: request.audioRouting.status,
+            },
+        });
+        return result;
+    },
+};
+function defaultUtteranceId() {
+    return `voice-${Date.now().toString(36)}`;
+}
+function playbackSkipped() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_golden_path_playback_skipped",
+        message: "voice golden path skipped playback because TTS failed",
+        meta: { reason: "tts_failed" },
+    });
+    return {
+        status: "skipped",
+        reason: "tts_failed",
+        playbackAttempted: false,
+    };
+}
+async function runVoiceGoldenPath(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_golden_path_start",
+        message: "starting voice golden path",
+        meta: { agentName: options.agentName, friendId: options.friendId },
+    });
+    try {
+        const meeting = (0, meeting_1.parseVoiceMeetingUrl)(options.meetingUrl);
+        const audioRouting = await (options.inspectAudioRouting ?? audio_routing_1.inspectVoiceAudioRouting)();
+        const joiner = options.meetingJoiner ?? defaultVoiceMeetingJoiner;
+        const join = await joiner.join({ meeting, audioRouting });
+        const utteranceId = options.utteranceId ?? defaultUtteranceId();
+        const transcript = await options.transcriber.transcribe({
+            utteranceId,
+            audioPath: options.audioPath,
+            language: options.language,
+        });
+        const sessionKey = options.sessionKey ?? meeting.sessionKey;
+        const runSenseTurn = options.runSenseTurn;
+        const turn = await (0, turn_1.runVoiceLoopbackTurn)({
+            agentName: options.agentName,
+            friendId: options.friendId,
+            sessionKey,
+            transcript,
+            tts: options.tts,
+            runSenseTurn,
+        });
+        const writePlaybackArtifact = options.writePlaybackArtifact ?? playback_1.writeVoicePlaybackArtifact;
+        const playback = turn.tts.status === "delivered"
+            ? await writePlaybackArtifact({
+                utteranceId,
+                delivery: turn.tts,
+                outputDir: options.outputDir,
+                playAudio: options.playAudio ?? false,
+            })
+            : playbackSkipped();
+        const result = {
+            meeting,
+            audioRouting,
+            join,
+            transcript,
+            responseText: turn.responseText,
+            ponderDeferred: turn.ponderDeferred,
+            tts: turn.tts,
+            playback,
+            sessionKey,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_golden_path_end",
+            message: "finished voice golden path",
+            meta: {
+                sessionKey,
+                joinStatus: join.status,
+                ttsStatus: turn.tts.status,
+                playbackStatus: playback.status,
+            },
+        });
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_golden_path_error",
+            message: "voice golden path failed",
+            meta: { error: message },
+        });
+        throw new Error(`voice golden path failed: ${message}`);
+    }
+}

package/dist/senses/voice/index.js

@@ -20,3 +20,8 @@ __exportStar(require("./transcript"), exports);
 __exportStar(require("./whisper"), exports);
 __exportStar(require("./elevenlabs"), exports);
 __exportStar(require("./turn"), exports);
+__exportStar(require("./meeting"), exports);
+__exportStar(require("./audio-routing"), exports);
+__exportStar(require("./playback"), exports);
+__exportStar(require("./golden-path"), exports);
+__exportStar(require("./twilio-phone"), exports);

package/dist/senses/voice/meeting.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactVoiceMeetingUrl = redactVoiceMeetingUrl;
+exports.parseVoiceMeetingUrl = parseVoiceMeetingUrl;
+const crypto_1 = require("crypto");
+const runtime_1 = require("../../nerves/runtime");
+function isRiversideHost(host) {
+    return host === "riverside.fm" || host === "riverside.com";
+}
+function stableMeetingHash(provider, url) {
+    return (0, crypto_1.createHash)("sha256")
+        .update(`${provider}:${url.protocol}//${url.host}${url.pathname}`)
+        .digest("hex")
+        .slice(0, 12);
+}
+function redactPath(pathname) {
+    const parts = pathname.split("/").filter(Boolean);
+    if (parts.length === 0)
+        return "/";
+    if (parts.length === 1)
+        return "/:redacted";
+    return `/${parts[0]}/:redacted`;
+}
+function redactVoiceMeetingUrl(input) {
+    try {
+        const url = new URL(input);
+        return `${url.protocol}//${url.host}${redactPath(url.pathname)}`;
+    }
+    catch {
+        return ":invalid";
+    }
+}
+function parseVoiceMeetingUrl(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "voice meeting URL is empty",
+            meta: { reason: "empty" },
+        });
+        throw new Error("voice meeting URL is empty");
+    }
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "voice meeting URL is invalid",
+            meta: { reason: "invalid_url" },
+        });
+        throw new Error("voice meeting URL is invalid");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "voice meeting URL must be http or https",
+            meta: { protocol: url.protocol },
+        });
+        throw new Error("voice meeting URL must be http or https");
+    }
+    const host = url.hostname.toLowerCase();
+    const provider = isRiversideHost(host) ? "riverside" : "generic";
+    if (provider === "riverside" && !url.pathname.startsWith("/studio/")) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "Riverside voice meeting URLs must use /studio/",
+            meta: { host, redactedUrl: redactVoiceMeetingUrl(trimmed) },
+        });
+        throw new Error("Riverside voice meeting URLs must use /studio/");
+    }
+    if (provider === "generic" && url.protocol !== "https:") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "generic voice meeting URLs must use https",
+            meta: { host, redactedUrl: redactVoiceMeetingUrl(trimmed) },
+        });
+        throw new Error("generic voice meeting URLs must use https");
+    }
+    const hash = stableMeetingHash(provider, url);
+    const meeting = {
+        originalUrl: trimmed,
+        provider,
+        host,
+        pathname: url.pathname,
+        redactedUrl: redactVoiceMeetingUrl(trimmed),
+        sessionKey: `voice-${provider}-${hash}`,
+        requiresBrowserJoin: true,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_meeting_parsed",
+        message: "voice meeting URL parsed",
+        meta: {
+            provider: meeting.provider,
+            host: meeting.host,
+            sessionKey: meeting.sessionKey,
+            redactedUrl: meeting.redactedUrl,
+        },
+    });
+    return meeting;
+}

package/dist/senses/voice/playback.js

@@ -0,0 +1,139 @@
+"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.writeVoicePlaybackArtifact = writeVoicePlaybackArtifact;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const audio_routing_1 = require("./audio-routing");
+function audioExtension(mimeType) {
+    if (mimeType === "audio/mpeg")
+        return "mp3";
+    if (mimeType === "audio/wav" || mimeType === "audio/x-wav")
+        return "wav";
+    if (mimeType.startsWith("audio/pcm"))
+        return "pcm";
+    return "audio";
+}
+function safeFileStem(input) {
+    const stem = input
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return stem || "utterance";
+}
+function commandFailureMessage(exitCode, result) {
+    const stderr = result.stderr?.trim();
+    if (stderr)
+        return `exit ${exitCode}: ${stderr}`;
+    const stdout = result.stdout?.trim();
+    if (stdout)
+        return `exit ${exitCode}: ${stdout}`;
+    return `exit ${exitCode}`;
+}
+async function writeVoicePlaybackArtifact(request) {
+    const mkdir = request.mkdir ?? fs.mkdir;
+    const writeFile = request.writeFile ?? fs.writeFile;
+    const commandRunner = request.commandRunner ?? (0, audio_routing_1.createNodeVoiceCommandRunner)();
+    const timeoutMs = request.timeoutMs ?? 30_000;
+    const playbackCommandPath = request.playbackCommandPath ?? "afplay";
+    const audioPath = path.join(request.outputDir, `${safeFileStem(request.utteranceId)}.${audioExtension(request.delivery.mimeType)}`);
+    await mkdir(request.outputDir, { recursive: true });
+    await writeFile(audioPath, request.delivery.audio);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_playback_artifact_written",
+        message: "voice playback artifact written",
+        meta: {
+            utteranceId: request.utteranceId,
+            audioPath,
+            byteLength: request.delivery.byteLength,
+            mimeType: request.delivery.mimeType,
+        },
+    });
+    if (request.playAudio !== true) {
+        return {
+            status: "written",
+            audioPath,
+            byteLength: request.delivery.byteLength,
+            mimeType: request.delivery.mimeType,
+            playbackAttempted: false,
+        };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_playback_start",
+        message: "starting voice playback",
+        meta: { utteranceId: request.utteranceId, audioPath, playbackCommandPath },
+    });
+    try {
+        const result = await commandRunner(playbackCommandPath, [audioPath], { timeoutMs });
+        if (typeof result.exitCode === "number" && result.exitCode !== 0) {
+            throw new Error(commandFailureMessage(result.exitCode, result));
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_playback_end",
+            message: "finished voice playback",
+            meta: { utteranceId: request.utteranceId, audioPath },
+        });
+        return {
+            status: "played",
+            audioPath,
+            byteLength: request.delivery.byteLength,
+            mimeType: request.delivery.mimeType,
+            playbackAttempted: true,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_playback_error",
+            message: "voice playback failed",
+            meta: { utteranceId: request.utteranceId, audioPath, error: message },
+        });
+        return {
+            status: "failed",
+            audioPath,
+            byteLength: request.delivery.byteLength,
+            mimeType: request.delivery.mimeType,
+            playbackAttempted: true,
+            error: message,
+        };
+    }
+}