@ouro.bot/cli 0.1.0-alpha.6 → 0.1.0-alpha.600

package/dist/senses/voice/floor-controller.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceFloorController = void 0;
+const runtime_1 = require("../../nerves/runtime");
+const floor_control_1 = require("./floor-control");
+class VoiceFloorController {
+    currentState = (0, floor_control_1.createInitialVoiceFloorState)();
+    transport;
+    agentName;
+    now;
+    callId;
+    listeners = [];
+    constructor(options) {
+        this.transport = options.transport;
+        this.agentName = options.agentName;
+        this.callId = options.callId;
+        this.now = options.now ?? Date.now;
+    }
+    get state() {
+        return this.currentState;
+    }
+    isTerminal() {
+        return this.currentState.terminal || this.currentState.hangupRequested;
+    }
+    summary() {
+        return (0, floor_control_1.summarizeVoiceFloorState)(this.currentState);
+    }
+    onTransition(listener) {
+        this.listeners.push(listener);
+        return () => {
+            const index = this.listeners.indexOf(listener);
+            if (index >= 0)
+                this.listeners.splice(index, 1);
+        };
+    }
+    apply(event) {
+        const transition = (0, floor_control_1.applyVoiceFloorEvent)(this.currentState, event);
+        this.currentState = transition.state;
+        if (event.type === "call.connected" && event.callId)
+            this.callId = event.callId;
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_floor_transition",
+            message: `voice floor transition ${event.type} -> ${transition.state.phase}`,
+            meta: this.meta({
+                eventType: event.type,
+                action: transition.decision.action,
+                reason: transition.decision.reason,
+                allowed: transition.decision.allowed,
+                atMs: event.atMs,
+            }),
+        });
+        for (const listener of [...this.listeners]) {
+            try {
+                listener(transition);
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.voice_floor_listener_error",
+                    message: "voice floor transition listener threw",
+                    meta: this.meta({ error: error instanceof Error ? error.message : String(error) }),
+                });
+            }
+        }
+        return transition;
+    }
+    canRequestResponse(input, atMs) {
+        const decision = (0, floor_control_1.canRequestVoiceResponse)(this.currentState, input);
+        const stamped = { ...decision, atMs: atMs ?? this.now() };
+        this.emitDecision("request", stamped, { responseId: input.responseId, inputReason: input.reason });
+        return stamped;
+    }
+    canSpeakToolHolding(input, atMs) {
+        const decision = (0, floor_control_1.canSpeakToolHolding)(this.currentState, input);
+        const stamped = { ...decision, atMs: atMs ?? this.now() };
+        this.emitDecision("tool_holding", stamped, { toolCallId: input.toolCallId });
+        return stamped;
+    }
+    canSpeakToolResult(input, atMs) {
+        const decision = (0, floor_control_1.canSpeakToolResult)(this.currentState, input);
+        const stamped = { ...decision, atMs: atMs ?? this.now() };
+        this.emitDecision("tool_result", stamped, { toolCallId: input.toolCallId });
+        return stamped;
+    }
+    emitDecision(query, decision, extra) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_floor_decision",
+            message: `voice floor decision ${query} ${decision.action} (${decision.reason})`,
+            meta: this.meta({
+                query,
+                action: decision.action,
+                reason: decision.reason,
+                allowed: decision.allowed,
+                atMs: decision.atMs,
+                ...extra,
+            }),
+        });
+    }
+    meta(extra) {
+        const base = {
+            phase: this.currentState.phase,
+            floorOwner: this.currentState.floorOwner,
+            transport: this.transport,
+        };
+        if (this.agentName)
+            base.agentName = this.agentName;
+        if (this.callId)
+            base.callId = this.callId;
+        return { ...base, ...extra };
+    }
+}
+exports.VoiceFloorController = VoiceFloorController;

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

@@ -0,0 +1,29 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* v8 ignore file -- barrel exports only; executable voice helpers are covered directly. @preserve */
+__exportStar(require("./types"), exports);
+__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);
+__exportStar(require("./twilio-phone-runtime"), exports);
+__exportStar(require("./realtime-eval"), 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/outbound.js

@@ -0,0 +1,190 @@
+"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.readVoiceOutboundFriendRecordById = readVoiceOutboundFriendRecordById;
+exports.findVoiceOutboundFriendRecord = findVoiceOutboundFriendRecord;
+exports.voiceOutboundPhoneNumberForFriend = voiceOutboundPhoneNumberForFriend;
+exports.placeTrustedFriendVoiceOutboundCall = placeTrustedFriendVoiceOutboundCall;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const types_1 = require("../../mind/friends/types");
+const runtime_1 = require("../../nerves/runtime");
+const phone_1 = require("./phone");
+function readVoiceOutboundFriendRecordById(friendsDir, friendId) {
+    const recordPath = path.join(friendsDir, `${friendId}.json`);
+    if (!fs.existsSync(recordPath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(recordPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function externalIdMatches(externalId, wanted, wantedPhone) {
+    const normalized = externalId.trim().toLowerCase();
+    /* v8 ignore next -- exact external-id aliases are supported for non-phone providers; phone aliases are the production voice path @preserve */
+    if (normalized === wanted)
+        return true;
+    const phone = (0, phone_1.normalizeTwilioE164PhoneNumber)(externalId);
+    return Boolean(wantedPhone && phone === wantedPhone);
+}
+function findVoiceOutboundFriendRecord(friendsDir, friendId) {
+    const byId = readVoiceOutboundFriendRecordById(friendsDir, friendId);
+    if (byId)
+        return byId;
+    const normalized = friendId.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    const normalizedPhone = (0, phone_1.normalizeTwilioE164PhoneNumber)(friendId);
+    try {
+        const records = fs.readdirSync(friendsDir)
+            .filter((file) => file.endsWith(".json"))
+            .map((file) => {
+            try {
+                return JSON.parse(fs.readFileSync(path.join(friendsDir, file), "utf-8"));
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((record) => Boolean(record));
+        return records.find((record) => record.id === friendId
+            || record.name?.toLowerCase() === normalized
+            || record.externalIds?.some((externalId) => externalIdMatches(externalId.externalId, normalized, normalizedPhone))) ?? records.find((record) => record.name?.toLowerCase().startsWith(normalized)) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function voiceOutboundPhoneNumberForFriend(friend, explicitPhoneNumber) {
+    const explicit = (0, phone_1.normalizeTwilioE164PhoneNumber)(explicitPhoneNumber);
+    if (explicit)
+        return explicit;
+    for (const externalId of friend?.externalIds ?? []) {
+        /* v8 ignore next -- voice outbound only consumes iMessage phone handles today @preserve */
+        if (externalId.provider !== "imessage-handle")
+            continue;
+        const phoneNumber = (0, phone_1.normalizeTwilioE164PhoneNumber)(externalId.externalId);
+        /* v8 ignore next -- malformed iMessage handles are covered by missing-number blocking at the caller boundary @preserve */
+        if (phoneNumber)
+            return phoneNumber;
+    }
+    return undefined;
+}
+async function placeTrustedFriendVoiceOutboundCall(request) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_outbound_call_start",
+        message: "checking trusted friend outbound voice call request",
+        meta: { agentName: request.agentName, friendId: request.friendId },
+    });
+    const friendsDir = path.join(request.agentRoot, "friends");
+    const friend = findVoiceOutboundFriendRecord(friendsDir, request.friendId);
+    if (!friend) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_outbound_call_blocked",
+            message: "blocked outbound voice call request",
+            meta: { agentName: request.agentName, friendId: request.friendId, reason: "unknown_friend" },
+        });
+        return { status: "blocked", detail: "voice call requires a known friend record" };
+    }
+    if (!(0, types_1.isTrustedLevel)(friend.trustLevel)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_outbound_call_blocked",
+            message: "blocked outbound voice call request",
+            meta: { agentName: request.agentName, friendId: friend.id, reason: "untrusted_friend" },
+        });
+        return { status: "blocked", detail: "voice calls are limited to trusted friends" };
+    }
+    const phoneNumber = voiceOutboundPhoneNumberForFriend(friend, request.phoneNumber);
+    if (!phoneNumber) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_outbound_call_blocked",
+            message: "blocked outbound voice call request",
+            meta: { agentName: request.agentName, friendId: friend.id, reason: "missing_phone_number" },
+        });
+        return { status: "blocked", detail: "no phone number is available for voice call" };
+    }
+    try {
+        const { placeConfiguredTwilioPhoneCall } = await Promise.resolve().then(() => __importStar(require("./twilio-phone-runtime")));
+        const call = await placeConfiguredTwilioPhoneCall({
+            agentName: request.agentName,
+            friendId: friend.id,
+            to: phoneNumber,
+            reason: request.reason,
+            ...(request.initialAudio ? { initialAudio: request.initialAudio } : {}),
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_outbound_call_placed",
+            message: "placed outbound voice call request",
+            meta: {
+                agentName: request.agentName,
+                friendId: friend.id,
+                outboundId: call.outboundId.replace(/[^A-Za-z0-9._-]+/g, "-"),
+                callSid: call.callSid?.replace(/[^A-Za-z0-9._-]+/g, "-") ?? "unknown",
+                status: call.status ?? "unknown",
+            },
+        });
+        return {
+            status: "placed",
+            detail: `voice call initiated${call.status ? ` (${call.status})` : ""}`,
+            friendId: friend.id,
+            phoneNumber,
+            outboundId: call.outboundId,
+            ...(call.callSid ? { callSid: call.callSid } : {}),
+            ...(call.status ? { callStatus: call.status } : {}),
+        };
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_outbound_call_failed",
+            message: "failed outbound voice call request",
+            /* v8 ignore next -- dynamic import/runtime failures arrive as Error objects in supported Node runtimes @preserve */
+            meta: { agentName: request.agentName, friendId: friend.id, error: error instanceof Error ? error.message : String(error) },
+        });
+        return {
+            status: "failed",
+            /* v8 ignore next -- dynamic import/runtime failures arrive as Error objects in supported Node runtimes @preserve */
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/senses/voice/phone.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTwilioE164PhoneNumber = normalizeTwilioE164PhoneNumber;
+const runtime_1 = require("../../nerves/runtime");
+function normalizeTwilioE164PhoneNumber(value) {
+    const raw = value?.trim();
+    if (!raw)
+        return undefined;
+    if (raw.toLowerCase().startsWith("group:")) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_phone_number_rejected",
+            message: "voice phone number candidate rejected",
+            meta: { reason: "group_handle" },
+        });
+        return undefined;
+    }
+    const cleaned = raw.replace(/[^\d+]+/g, "");
+    if (/^\+[1-9]\d{6,14}$/.test(cleaned))
+        return cleaned;
+    const digits = cleaned.replace(/\D+/g, "");
+    if (/^1\d{10}$/.test(digits))
+        return `+${digits}`;
+    if (/^\d{10}$/.test(digits))
+        return `+1${digits}`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_phone_number_rejected",
+        message: "voice phone number candidate rejected",
+        meta: { reason: "invalid_e164" },
+    });
+    return undefined;
+}