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

package/changelog.json

@@ -1,6 +1,12 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.591",
+      "changes": [
+        "Voice floor-control gains a principled caller.turn.dismissed event. The realtime runtime now emits this event when OpenAI starts a coordinated tool call inside an active response cycle (proof the realtime server has parsed the caller's most recent turn), replacing the tactical synthetic caller.transcript.final hack that previously did the same job from outside the reducer. No live human calls."
+      ]
+    },
     {
       "version": "0.1.0-alpha.590",
       "changes": [

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

@@ -178,6 +178,37 @@ function applyCallerTranscriptFinal(state, event) {
     }
     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)
@@ -330,6 +361,8 @@ function applyVoiceFloorEvent(state, event) {
             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":

package/dist/senses/voice/twilio-phone.js

@@ -2140,24 +2140,9 @@ class TwilioOpenAIRealtimeMediaStreamSession {
         this.clearRealtimeToolPresenceTimer(state);
         if (state.suppressFollowup)
             return true;
-        this.releaseCallerFloorForToolFollowup();
         this.requestRealtimeResponse();
         return true;
     }
-    releaseCallerFloorForToolFollowup() {
-        // OpenAI emitting a function-call result inside a coordinated response
-        // means the caller's most recent turn has already been parsed by the
-        // realtime server. If we still hold a synthetic caller turn (because the
-        // matching transcript event has not been delivered yet — common in unit
-        // fixtures and during fast-turn races), release it before asking the gate
-        // to flush a follow-up response.create so the gate is not stuck thinking
-        // the caller still owns the floor.
-        if (!this.activeCallerTurnId)
-            return;
-        const turnId = this.activeCallerTurnId;
-        this.activeCallerTurnId = undefined;
-        this.floor.apply({ type: "caller.transcript.final", atMs: Date.now(), turnId });
-    }
     scheduleRealtimeToolPresence(responseId, state) {
         if (!responseId || state.presenceRequested || state.presenceTimer)
             return;
@@ -2195,6 +2180,24 @@ class TwilioOpenAIRealtimeMediaStreamSession {
             toolState.suppressFollowup = true;
         if (toolState && !toolState.suppressFollowup)
             this.scheduleRealtimeToolPresence(responseId, toolState);
+        // A coordinated tool call (one with a responseId from OpenAI's active
+        // response cycle) is proof that the realtime server has already parsed the
+        // caller's most recent turn into a tool intent. If we still hold a
+        // synthetic caller floor for that turn — because the matching
+        // input_audio_transcription.completed event has not arrived yet, which is
+        // common in unit fixtures and during fast-turn races — dismiss it so the
+        // floor gate is not stuck thinking the caller still owns the floor when
+        // the assistant is mid-response.
+        if (coordinated && this.activeCallerTurnId) {
+            const turnId = this.activeCallerTurnId;
+            this.activeCallerTurnId = undefined;
+            this.floor.apply({
+                type: "caller.turn.dismissed",
+                atMs: Date.now(),
+                turnId,
+                reason: "coordinated_tool_call",
+            });
+        }
         this.floor.apply({
             type: "tool.call.started",
             atMs: Date.now(),
@@ -3280,6 +3283,24 @@ class OpenAISipPhoneSession {
             toolState.suppressFollowup = true;
         if (toolState && !toolState.suppressFollowup)
             this.scheduleRealtimeToolPresence(responseId, toolState);
+        // A coordinated tool call (one with a responseId from OpenAI's active
+        // response cycle) is proof that the realtime server has already parsed the
+        // caller's most recent turn into a tool intent. If we still hold a
+        // synthetic caller floor for that turn — because the matching
+        // input_audio_transcription.completed event has not arrived yet, which is
+        // common in unit fixtures and during fast-turn races — dismiss it so the
+        // floor gate is not stuck thinking the caller still owns the floor when
+        // the assistant is mid-response.
+        if (coordinated && this.activeCallerTurnId) {
+            const turnId = this.activeCallerTurnId;
+            this.activeCallerTurnId = undefined;
+            this.floor.apply({
+                type: "caller.turn.dismissed",
+                atMs: Date.now(),
+                turnId,
+                reason: "coordinated_tool_call",
+            });
+        }
         this.floor.apply({
             type: "tool.call.started",
             atMs: Date.now(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.590",
+  "version": "0.1.0-alpha.591",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",