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

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"));
+                    }
+                });
+            });
+        },
+    };
+}

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(" ");
+}