@ouro.bot/cli 0.1.0-alpha.59 → 0.1.0-alpha.591

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

@@ -0,0 +1,431 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitialVoiceFloorState = createInitialVoiceFloorState;
+exports.canRequestVoiceResponse = canRequestVoiceResponse;
+exports.canSpeakToolHolding = canSpeakToolHolding;
+exports.canSpeakToolResult = canSpeakToolResult;
+exports.applyVoiceFloorEvent = applyVoiceFloorEvent;
+exports.replayVoiceFloorEvents = replayVoiceFloorEvents;
+exports.summarizeVoiceFloorState = summarizeVoiceFloorState;
+const runtime_1 = require("../../nerves/runtime");
+const MAX_TOOL_HOLDING_WORDS = 6;
+function createInitialVoiceFloorState() {
+    return {
+        phase: "idle",
+        floorOwner: "none",
+        terminal: false,
+        hangupRequested: false,
+        pendingToolCallIds: [],
+        staleToolCallIds: [],
+        spokenToolCallIds: [],
+        callerTurnIds: [],
+        toolCalls: {},
+    };
+}
+function decision(allowed, action, reason, details = {}) {
+    return { allowed, action, reason, ...details };
+}
+function copyState(state) {
+    return {
+        ...state,
+        pendingToolCallIds: [...state.pendingToolCallIds],
+        staleToolCallIds: [...state.staleToolCallIds],
+        spokenToolCallIds: [...state.spokenToolCallIds],
+        callerTurnIds: [...state.callerTurnIds],
+        toolCalls: { ...state.toolCalls },
+    };
+}
+function withUnique(values, value) {
+    return values.includes(value) ? values : [...values, value];
+}
+function withoutValue(values, value) {
+    return values.filter((candidate) => candidate !== value);
+}
+function rememberCallerTurn(state, turnId) {
+    state.latestCallerTurnId = turnId;
+    state.callerTurnIds = withUnique(state.callerTurnIds, turnId);
+}
+function hasNewerCallerTurn(state, turnId) {
+    if (!turnId || !state.latestCallerTurnId || state.latestCallerTurnId === turnId)
+        return false;
+    const originalIndex = state.callerTurnIds.indexOf(turnId);
+    const latestIndex = state.callerTurnIds.indexOf(state.latestCallerTurnId);
+    return originalIndex >= 0 && latestIndex > originalIndex;
+}
+function toolState(state, toolCallId) {
+    return state.toolCalls[toolCallId];
+}
+function setToolState(state, nextTool) {
+    state.toolCalls = { ...state.toolCalls, [nextTool.toolCallId]: nextTool };
+}
+function phaseAfterAssistantSpeech(state) {
+    const pendingTools = state.pendingToolCallIds.map((toolCallId) => state.toolCalls[toolCallId]).filter(Boolean);
+    if (pendingTools.some((tool) => tool.status === "ready"))
+        return "tool-result-ready";
+    if (pendingTools.some((tool) => tool.status === "running"))
+        return "tool-running";
+    return "listening";
+}
+function suppressForHangup(state, event) {
+    return {
+        event,
+        state,
+        decision: decision(false, "suppress", "hangup_terminal", { atMs: event.atMs }),
+    };
+}
+function canRequestVoiceResponse(state, input) {
+    if (state.terminal || state.hangupRequested || state.floorOwner === "terminal") {
+        return decision(false, "suppress", "hangup_terminal", { responseId: input.responseId });
+    }
+    if (state.floorOwner === "caller" || state.phase === "caller-speaking" || state.phase === "interrupted") {
+        return decision(false, "delay", "caller_has_floor", { responseId: input.responseId });
+    }
+    if (state.floorOwner === "assistant" || state.activeAssistantSpeechId) {
+        return decision(false, "delay", "assistant_has_floor", { responseId: input.responseId });
+    }
+    if (state.pendingSpeech) {
+        return decision(false, "delay", "response_pending", { responseId: input.responseId });
+    }
+    return decision(true, "allow", "ready_for_response", { responseId: input.responseId });
+}
+function canSpeakToolHolding(state, input) {
+    if (state.terminal || state.hangupRequested || state.floorOwner === "terminal") {
+        return decision(false, "suppress", "hangup_terminal", { toolCallId: input.toolCallId });
+    }
+    if (state.floorOwner === "caller" || state.phase === "caller-speaking" || state.phase === "interrupted") {
+        return decision(false, "delay", "caller_has_floor", { toolCallId: input.toolCallId });
+    }
+    const tool = toolState(state, input.toolCallId);
+    if (!tool || tool.status === "spoken") {
+        return decision(false, "suppress", "missing_tool_call", { toolCallId: input.toolCallId });
+    }
+    if (tool.status === "stale" || state.staleToolCallIds.includes(input.toolCallId)) {
+        return decision(false, "suppress", "stale_tool_result", { toolCallId: input.toolCallId });
+    }
+    const words = input.text?.trim().split(/\s+/).filter(Boolean).length ?? 0;
+    if (words > MAX_TOOL_HOLDING_WORDS) {
+        return decision(false, "suppress", "tool_holding_too_long", { toolCallId: input.toolCallId });
+    }
+    return decision(true, "allow", "tool_presence_allowed", { toolCallId: input.toolCallId });
+}
+function canSpeakToolResult(state, input) {
+    if (state.terminal || state.hangupRequested || state.floorOwner === "terminal") {
+        return decision(false, "suppress", "hangup_terminal", { toolCallId: input.toolCallId });
+    }
+    if (state.floorOwner === "caller" || state.phase === "caller-speaking" || state.phase === "interrupted") {
+        return decision(false, "delay", "caller_has_floor", { toolCallId: input.toolCallId });
+    }
+    const tool = toolState(state, input.toolCallId);
+    if (!tool || tool.status === "spoken") {
+        return decision(false, "suppress", "missing_tool_result", { toolCallId: input.toolCallId });
+    }
+    if (tool.status === "stale" || state.staleToolCallIds.includes(input.toolCallId)) {
+        return decision(false, "suppress", "stale_tool_result", { toolCallId: input.toolCallId });
+    }
+    if (tool.status !== "ready") {
+        return decision(false, "delay", "tool_still_running", { toolCallId: input.toolCallId });
+    }
+    return decision(true, "allow", "tool_result_ready", { toolCallId: input.toolCallId });
+}
+function applyConnected(state, event) {
+    const next = copyState(state);
+    next.phase = "listening";
+    next.floorOwner = "none";
+    next.terminal = false;
+    next.hangupRequested = false;
+    next.callId = event.callId;
+    return { event, state: next, decision: decision(true, "allow", "call_connected", { atMs: event.atMs }) };
+}
+function applyCallerSpeechStarted(state, event) {
+    const next = copyState(state);
+    rememberCallerTurn(next, event.turnId);
+    next.floorOwner = "caller";
+    if (state.activeAssistantSpeechId) {
+        next.phase = "interrupted";
+        next.interruption = {
+            turnId: event.turnId,
+            interruptedSpeechId: state.activeAssistantSpeechId,
+            atMs: event.atMs,
+        };
+        return {
+            event,
+            state: next,
+            decision: decision(false, "cancel", "caller_barge_in", {
+                atMs: event.atMs,
+                responseId: state.activeAssistantSpeechId,
+                interruptionTurnId: event.turnId,
+            }),
+        };
+    }
+    next.phase = "caller-speaking";
+    return { event, state: next, decision: decision(true, "allow", "caller_floor_started", { atMs: event.atMs }) };
+}
+function applyCallerSpeechEnded(state, event) {
+    const next = copyState(state);
+    rememberCallerTurn(next, event.turnId);
+    if (!next.activeAssistantSpeechId) {
+        next.floorOwner = "none";
+        next.phase = "listening";
+    }
+    return { event, state: next, decision: decision(true, "allow", "caller_floor_released", { atMs: event.atMs }) };
+}
+function applyCallerTranscriptFinal(state, event) {
+    const next = copyState(state);
+    rememberCallerTurn(next, event.turnId);
+    if (!next.activeAssistantSpeechId) {
+        next.floorOwner = "none";
+        next.phase = "thinking";
+    }
+    return { event, state: next, decision: decision(true, "allow", "caller_turn_ready", { atMs: event.atMs }) };
+}
+function applyCallerTurnDismissed(state, event) {
+    if (state.latestCallerTurnId !== event.turnId) {
+        return {
+            event,
+            state,
+            decision: decision(false, "suppress", "stale_caller_turn", { atMs: event.atMs }),
+        };
+    }
+    if (state.floorOwner !== "caller") {
+        return {
+            event,
+            state,
+            decision: decision(true, "allow", "caller_turn_already_released", { atMs: event.atMs }),
+        };
+    }
+    const next = copyState(state);
+    if (next.activeAssistantSpeechId) {
+        next.floorOwner = "assistant";
+        next.phase = "speaking";
+    }
+    else {
+        next.floorOwner = "none";
+        next.phase = "thinking";
+    }
+    next.interruption = undefined;
+    return {
+        event,
+        state: next,
+        decision: decision(true, "allow", "caller_turn_dismissed", { atMs: event.atMs }),
+    };
+}
+function applyAssistantResponseRequested(state, event) {
+    const requestDecision = canRequestVoiceResponse(state, { responseId: event.responseId, reason: event.reason });
+    if (!requestDecision.allowed)
+        return { event, state, decision: { ...requestDecision, atMs: event.atMs } };
+    const next = copyState(state);
+    next.phase = "thinking";
+    next.floorOwner = "none";
+    next.pendingSpeech = { responseId: event.responseId, reason: event.reason };
+    return { event, state: next, decision: { ...requestDecision, atMs: event.atMs } };
+}
+function applyAssistantSpeechStarted(state, event) {
+    const requestDecision = state.floorOwner === "caller"
+        ? decision(false, "delay", "caller_has_floor", { atMs: event.atMs, responseId: event.responseId })
+        : decision(true, "allow", "assistant_speech_allowed", { atMs: event.atMs, responseId: event.responseId });
+    if (!requestDecision.allowed)
+        return { event, state, decision: requestDecision };
+    const next = copyState(state);
+    next.phase = "speaking";
+    next.floorOwner = "assistant";
+    next.activeAssistantSpeechId = event.responseId;
+    next.pendingSpeech = undefined;
+    return { event, state: next, decision: requestDecision };
+}
+function applyAssistantSpeechDone(state, event) {
+    const next = copyState(state);
+    if (next.activeAssistantSpeechId === event.responseId)
+        next.activeAssistantSpeechId = undefined;
+    if (next.floorOwner === "assistant")
+        next.floorOwner = "none";
+    next.phase = phaseAfterAssistantSpeech(next);
+    return { event, state: next, decision: decision(true, "allow", "assistant_speech_done", { atMs: event.atMs, responseId: event.responseId }) };
+}
+function applyAssistantSpeechCancelled(state, event) {
+    const next = copyState(state);
+    if (next.activeAssistantSpeechId === event.responseId)
+        next.activeAssistantSpeechId = undefined;
+    if (next.interruption) {
+        next.floorOwner = "caller";
+        next.phase = "caller-speaking";
+    }
+    else {
+        next.floorOwner = "none";
+        next.phase = phaseAfterAssistantSpeech(next);
+    }
+    return {
+        event,
+        state: next,
+        decision: decision(true, "allow", "assistant_speech_cancelled", { atMs: event.atMs, responseId: event.responseId }),
+    };
+}
+function applyToolStarted(state, event) {
+    if (state.toolCalls[event.toolCallId]) {
+        return {
+            event,
+            state,
+            decision: decision(true, "allow", "duplicate_tool_start_ignored", { atMs: event.atMs, toolCallId: event.toolCallId }),
+        };
+    }
+    const next = copyState(state);
+    next.pendingToolCallIds = withUnique(next.pendingToolCallIds, event.toolCallId);
+    setToolState(next, {
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        turnId: event.turnId ?? next.latestCallerTurnId,
+        status: "running",
+        startedAtMs: event.atMs,
+    });
+    if (next.floorOwner === "none")
+        next.phase = "tool-running";
+    return { event, state: next, decision: decision(true, "allow", "tool_started", { atMs: event.atMs, toolCallId: event.toolCallId }) };
+}
+function applyToolHoldingSpoken(state, event) {
+    const holdingDecision = canSpeakToolHolding(state, { toolCallId: event.toolCallId, text: event.text });
+    if (!holdingDecision.allowed)
+        return { event, state, decision: { ...holdingDecision, atMs: event.atMs } };
+    return { event, state, decision: { ...holdingDecision, atMs: event.atMs } };
+}
+function applyToolCompleted(state, event) {
+    const existing = toolState(state, event.toolCallId);
+    if (!existing) {
+        return {
+            event,
+            state,
+            decision: decision(false, "suppress", "missing_tool_call", { atMs: event.atMs, toolCallId: event.toolCallId }),
+        };
+    }
+    if (existing.status !== "running") {
+        return {
+            event,
+            state,
+            decision: decision(true, "allow", "duplicate_tool_completion_ignored", { atMs: event.atMs, toolCallId: event.toolCallId }),
+        };
+    }
+    const turnId = event.turnId ?? existing.turnId;
+    const next = copyState(state);
+    if (hasNewerCallerTurn(next, turnId)) {
+        next.pendingToolCallIds = withoutValue(next.pendingToolCallIds, event.toolCallId);
+        next.staleToolCallIds = withUnique(next.staleToolCallIds, event.toolCallId);
+        setToolState(next, { ...existing, turnId, status: "stale", completedAtMs: event.atMs });
+        if (next.floorOwner === "none")
+            next.phase = "suppressing";
+        return {
+            event,
+            state: next,
+            decision: decision(false, "suppress", "newer_user_turn_started", { atMs: event.atMs, toolCallId: event.toolCallId }),
+        };
+    }
+    setToolState(next, { ...existing, turnId, status: "ready", completedAtMs: event.atMs });
+    next.pendingToolCallIds = withUnique(next.pendingToolCallIds, event.toolCallId);
+    if (next.floorOwner === "none")
+        next.phase = "tool-result-ready";
+    return { event, state: next, decision: decision(true, "allow", "tool_result_ready", { atMs: event.atMs, toolCallId: event.toolCallId }) };
+}
+function applyToolResultSpoken(state, event) {
+    const resultDecision = canSpeakToolResult(state, { toolCallId: event.toolCallId, text: event.text });
+    if (!resultDecision.allowed)
+        return { event, state, decision: { ...resultDecision, atMs: event.atMs } };
+    const existing = toolState(state, event.toolCallId);
+    const next = copyState(state);
+    setToolState(next, { ...existing, status: "spoken" });
+    next.pendingToolCallIds = withoutValue(next.pendingToolCallIds, event.toolCallId);
+    next.spokenToolCallIds = withUnique(next.spokenToolCallIds, event.toolCallId);
+    next.phase = phaseAfterAssistantSpeech(next);
+    return { event, state: next, decision: { ...resultDecision, atMs: event.atMs } };
+}
+function applyHangupRequested(state, event) {
+    const next = copyState(state);
+    next.phase = "hangup";
+    next.floorOwner = "terminal";
+    next.hangupRequested = true;
+    return { event, state: next, decision: decision(true, "allow", "hangup_requested", { atMs: event.atMs }) };
+}
+function applyCallEnded(state, event) {
+    const next = copyState(state);
+    next.phase = "ended";
+    next.floorOwner = "terminal";
+    next.terminal = true;
+    next.hangupRequested = true;
+    return { event, state: next, decision: decision(true, "allow", "call_ended", { atMs: event.atMs }) };
+}
+function applyVoiceFloorEvent(state, event) {
+    if (state.hangupRequested && event.type !== "call.ended" && event.type !== "hangup.requested")
+        return suppressForHangup(state, event);
+    switch (event.type) {
+        case "call.connected":
+            return applyConnected(state, event);
+        case "caller.speech.started":
+            return applyCallerSpeechStarted(state, event);
+        case "caller.speech.ended":
+            return applyCallerSpeechEnded(state, event);
+        case "caller.transcript.final":
+            return applyCallerTranscriptFinal(state, event);
+        case "caller.turn.dismissed":
+            return applyCallerTurnDismissed(state, event);
+        case "assistant.response.requested":
+            return applyAssistantResponseRequested(state, event);
+        case "assistant.speech.started":
+            return applyAssistantSpeechStarted(state, event);
+        case "assistant.speech.done":
+            return applyAssistantSpeechDone(state, event);
+        case "assistant.speech.cancelled":
+            return applyAssistantSpeechCancelled(state, event);
+        case "tool.call.started":
+            return applyToolStarted(state, event);
+        case "tool.holding.spoken":
+            return applyToolHoldingSpoken(state, event);
+        case "tool.call.completed":
+            return applyToolCompleted(state, event);
+        case "tool.result.spoken":
+            return applyToolResultSpoken(state, event);
+        case "hangup.requested":
+            return applyHangupRequested(state, event);
+        case "call.ended":
+            return applyCallEnded(state, event);
+        default:
+            throw new Error(`unknown voice floor event: ${String(event.type)}`);
+    }
+}
+function replayVoiceFloorEvents(events) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_floor_replay_start",
+        message: "starting Voice floor-control replay",
+        meta: { events: events.length },
+    });
+    let state = createInitialVoiceFloorState();
+    const steps = [];
+    for (const event of events) {
+        const transition = applyVoiceFloorEvent(state, event);
+        steps.push(transition);
+        state = transition.state;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_floor_replay_end",
+        message: "finished Voice floor-control replay",
+        meta: { events: events.length, phase: state.phase, floorOwner: state.floorOwner },
+    });
+    return { state, steps };
+}
+function listSummary(values) {
+    return values.length > 0 ? values.join(",") : "none";
+}
+function summarizeVoiceFloorState(state) {
+    const parts = [
+        `phase=${state.phase}`,
+        `floor=${state.floorOwner}`,
+    ];
+    if (state.activeAssistantSpeechId)
+        parts.push(`activeSpeech=${state.activeAssistantSpeechId}`);
+    parts.push(`pendingTools=${listSummary(state.pendingToolCallIds)}`);
+    parts.push(`staleTools=${listSummary(state.staleToolCallIds)}`);
+    if (state.interruption)
+        parts.push(`interruption=${state.interruption.turnId}@${state.interruption.interruptedSpeechId}`);
+    if (state.hangupRequested)
+        parts.push("hangup=requested");
+    if (state.terminal)
+        parts.push("terminal=true");
+    return parts.join(" ");
+}

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);