Fix beta realtime session payloads

cursoragent · cursoragent · commit e33fd0ddcf10 · 2026-05-04T13:37:18.000Z
diff --git a/litellm/litellm_core_utils/realtime_streaming.py b/litellm/litellm_core_utils/realtime_streaming.py
@@ -260,23 +260,20 @@ async def _send_to_backend(self, message: str) -> None:
             await self.backend_ws.send(message)  # type: ignore[union-attr, attr-defined]
 
     def _make_disable_auto_response_message(self) -> str:
-        """Return a GA-shaped session.update that disables VAD auto-response.
-
-        The guardrail injection sites historically sent a beta-style payload
-        with a flat ``turn_detection`` key.  When the upstream operates in GA
-        mode (no ``OpenAI-Beta: realtime=v1`` header), the backend requires
-        the nested shape ``session.audio.input.turn_detection`` and a required
-        ``session.type`` field.  This helper always produces the correct shape
-        so both injection sites are GA-safe regardless of client protocol.
-        """
-        session: Dict[str, Any] = {
-            "type": "realtime",
-            "audio": {
-                "input": {
-                    "turn_detection": {"create_response": False},
-                }
-            },
-        }
+        """Return a session.update that disables VAD auto-response."""
+        if self._client_wants_beta:
+            session: Dict[str, Any] = {
+                "turn_detection": {"create_response": False},
+            }
+        else:
+            session = {
+                "type": "realtime",
+                "audio": {
+                    "input": {
+                        "turn_detection": {"create_response": False},
+                    }
+                },
+            }
         return json.dumps({"type": "session.update", "session": session})
 
     def _has_realtime_guardrails(self) -> bool:
@@ -813,11 +810,10 @@ async def client_ack_messages(self):
                         self._pending_guardrail_message = None
                         continue
 
-                    # GA compatibility: remap beta-style session fields to GA shape.
-                    # Always applied so that beta-format clients work against a GA
-                    # backend.  When _client_wants_beta is True the proxy also
-                    # translates GA events back to beta names on the return path.
-                    if msg_type == "session.update":
+                    # GA compatibility: remap beta-style session fields only when
+                    # the upstream is in GA mode. Beta upstreams expect the flat
+                    # session shape unchanged.
+                    if msg_type == "session.update" and not self._client_wants_beta:
                         session = msg_obj.get("session", {})
                         if isinstance(session, dict):
                             session = self._remap_beta_session_to_ga(session)
diff --git a/tests/test_litellm/litellm_core_utils/test_realtime_streaming.py b/tests/test_litellm/litellm_core_utils/test_realtime_streaming.py
@@ -121,6 +121,59 @@ def test_make_disable_auto_response_message_produces_ga_shape():
     assert session["audio"]["input"]["turn_detection"]["create_response"] is False
 
 
+def test_make_disable_auto_response_message_produces_beta_shape_for_beta_clients():
+    websocket = MagicMock()
+    websocket.scope = {"headers": [(b"openai-beta", b"realtime=v1")]}
+    backend_ws = MagicMock()
+    logging_obj = MagicMock()
+    streaming = RealTimeStreaming(websocket, backend_ws, logging_obj)
+
+    raw = streaming._make_disable_auto_response_message()
+    msg = json.loads(raw)
+
+    assert msg["type"] == "session.update"
+    session = msg["session"]
+    assert session == {"turn_detection": {"create_response": False}}
+
+
+@pytest.mark.asyncio
+async def test_client_ack_messages_keeps_beta_session_shape_for_beta_clients():
+    client_ws = MagicMock()
+    client_ws.scope = {"headers": [(b"openai-beta", b"realtime=v1")]}
+    session_update = json.dumps(
+        {
+            "type": "session.update",
+            "session": {
+                "modalities": ["audio", "text"],
+                "voice": "alloy",
+                "turn_detection": {"create_response": False},
+            },
+        }
+    )
+    client_ws.receive_text = AsyncMock(
+        side_effect=[
+            session_update,
+            Exception("connection closed"),
+        ]
+    )
+    backend_ws = MagicMock()
+    backend_ws.send = AsyncMock()
+    logging_obj = MagicMock()
+    logging_obj.pre_call = MagicMock()
+    streaming = RealTimeStreaming(client_ws, backend_ws, logging_obj)
+
+    await streaming.client_ack_messages()
+
+    sent_to_backend = json.loads(backend_ws.send.call_args_list[0].args[0])
+    session = sent_to_backend["session"]
+    assert session["modalities"] == ["audio", "text"]
+    assert session["voice"] == "alloy"
+    assert session["turn_detection"] == {"create_response": False}
+    assert "type" not in session
+    assert "output_modalities" not in session
+    assert "audio" not in session
+
+
 def test_translate_event_to_beta_renames_delta_types():
     ev = RealTimeStreaming._translate_event_to_beta(
         {"type": "response.output_audio.delta", "delta": "abc", "event_id": "e1"}
