Auto-reconnect Gemini Live on 1011 / handshake / transient drops

Without this, when Gemini Live's websocket dies mid-session (1011
Internal error from Google, or transient network blip), the bot
went silent for the rest of the app's lifetime — operator had to
SSH in and restart. Manual register from the dashboard also
appeared to be a "no greeting" bug, but it was actually working
correctly: the session-event push fired with a SPEAK_NOW hint, the
push just had nowhere to land because the socket was dead.

Wraps the connect/run block in a reconnect loop with exponential
backoff (1s -> 30s cap), resetting the backoff on every successful
connection. First connect keeps the visitor-greeting kick-off
prompt; reconnects skip it and call _push_reconnect_context to
hand the LLM a one-line recap of where the conversation was
(state, visitor name, employee, appointment, email status). For
SPEAK_NOW states like RECOGNIZED / APPOINTMENT_MATCHED, the recap
also includes "SPEAK NOW: <hint>" so the bot picks up speaking
immediately instead of waiting silently.

Shutdown path still works — _shutdown_requested breaks the loop
before the next backoff sleep, and CancelledError on the sleep
also exits cleanly.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

src/reachy_mini_receptionist/gemini_live.py

@@ -232,50 +232,151 @@ class GeminiLiveHandler(AsyncStreamHandler):
         if gemini_tools:
             config_obj["tools"] = gemini_tools
 
+        # Reconnect loop. Gemini Live websockets die periodically with
+        # 1011 "Internal error" — observed in production after long
+        # idle periods, after certain tool error responses, and after
+        # transient Google-side hiccups. Without auto-reconnect the
+        # bot goes silent for the rest of the app's lifetime, requiring
+        # an operator restart. This loop reconnects with exponential
+        # backoff (1s → 30s cap) and resets backoff on every successful
+        # connection. First connect sends the visitor-greeting prompt;
+        # subsequent reconnects skip it and push a state-restoration
+        # context message instead, so the LLM picks up wherever the
+        # conversation was when the socket dropped.
+        backoff_seconds = 1.0
+        max_backoff_seconds = 30.0
+        is_first_connect = True
+
+        while not self._shutdown_requested:
+            try:
+                async with self._client.aio.live.connect(model=model_id, config=config_obj) as session:
+                    self.session = session
+                    if is_first_connect:
+                        logger.info("Gemini Live connected.")
+                    else:
+                        logger.warning("Gemini Live reconnected after disconnect.")
+                    backoff_seconds = 1.0  # reset on every successful connect
+                    self.tool_manager.start_up(tool_callbacks=[self._handle_tool_result])
+
+                    try:
+                        if is_first_connect:
+                            # Visitor just walked up — proactive greeting.
+                            await session.send_client_content(
+                                turns=[{
+                                    "role": "user",
+                                    "parts": [{
+                                        "text": (
+                                            "(Visitor just walked up. Greet them "
+                                            "very briefly in ONE short friendly "
+                                            "sentence and ask their name or who "
+                                            "they're here to see. Keep it under "
+                                            "8 words.)"
+                                        ),
+                                    }],
+                                }],
+                                turn_complete=True,
+                            )
+                            logger.info("Gemini Live: sent kick-off greeting prompt")
+                        else:
+                            # Reconnect — restore session context so the
+                            # LLM knows current state (visitor name,
+                            # employee, appointment) and continues
+                            # naturally instead of asking the visitor to
+                            # repeat themselves.
+                            await self._push_reconnect_context(session)
+                    except Exception as e:
+                        logger.warning("Gemini Live: post-connect send failed: %s", e)
+
+                    is_first_connect = False
+
+                    try:
+                        await self._run_event_loop()
+                    except Exception as inner:
+                        logger.exception("Gemini Live event loop crashed: %s", inner)
+                    finally:
+                        await self.tool_manager.shutdown()
+                        self.session = None
+                        logger.info("Gemini Live: session ended.")
+            except Exception as e:
+                logger.exception("Gemini Live session failed: %s", e)
+                self.session = None
+
+            if self._shutdown_requested:
+                break
+
+            logger.warning(
+                "Gemini Live disconnected — reconnecting in %.1fs",
+                backoff_seconds,
+            )
+            try:
+                await asyncio.sleep(backoff_seconds)
+            except asyncio.CancelledError:
+                break
+            backoff_seconds = min(backoff_seconds * 2.0, max_backoff_seconds)
+
+    async def _push_reconnect_context(self, session: Any) -> None:
+        """After auto-reconnect, tell the LLM where we left off.
+
+        Pulls the current session snapshot (state, visitor, employee,
+        appointment) and sends it as a context message so the model
+        resumes the flow instead of cold-starting. If a visitor is
+        mid-flow in a SPEAK-NOW state, prompts the model to speak
+        immediately — this is what makes manual register or face
+        recognition work right after a websocket recovery.
+        """
+        sm = self._session_manager
+        if sm is None:
+            return
         try:
-            async with self._client.aio.live.connect(model=model_id, config=config_obj) as session:
-                self.session = session
-                logger.info("Gemini Live connected.")
-                # Start background tool manager (same callback signature)
-                self.tool_manager.start_up(tool_callbacks=[self._handle_tool_result])
-
-                # Kick off conversation with a one-shot greeting prompt.
-                # With the tighter VAD config (400ms silence) we could
-                # in theory wait for visitor speech, but a proactive
-                # greeting keeps the demo natural — the bot says hi
-                # the moment a face is detected. Server VAD handles
-                # all subsequent visitor turns with low latency.
-                try:
-                    await session.send_client_content(
-                        turns=[{
-                            "role": "user",
-                            "parts": [{
-                                "text": (
-                                    "(Visitor just walked up. Greet them "
-                                    "very briefly in ONE short friendly "
-                                    "sentence and ask their name or who "
-                                    "they're here to see. Keep it under "
-                                    "8 words.)"
-                                ),
-                            }],
-                        }],
-                        turn_complete=True,
-                    )
-                    logger.info("Gemini Live: sent kick-off greeting prompt")
-                except Exception as e:
-                    logger.warning("Gemini Live: kick-off send failed: %s", e)
+            snap = sm.session
+            snap_dict = snap.to_dict() if hasattr(snap, "to_dict") else {}
+            current_state = snap.current_state
+            state_value = getattr(current_state, "value", str(current_state))
+        except Exception as e:
+            logger.debug("reconnect-context: snapshot failed: %s", e)
+            return
 
-                try:
-                    await self._run_event_loop()
-                except Exception as inner:
-                    logger.exception("Gemini Live event loop crashed: %s", inner)
-                finally:
-                    await self.tool_manager.shutdown()
-                    self.session = None
-                    logger.info("Gemini Live: session ended cleanly")
+        if state_value == "idle":
+            return  # No active visitor; nothing to restore.
+
+        hint = ""
+        speak_now = False
+        try:
+            from reachy_mini_receptionist.conversation_controller import (
+                next_action_hint, should_speak_immediately,
+            )
+            hint = next_action_hint(current_state)
+            speak_now = should_speak_immediately(current_state)
+        except Exception:
+            pass
+
+        base = (
+            f"[Backend reconnect {self.format_timestamp()}] "
+            f"Resuming mid-session. Current state: {state_value}; "
+            f"visitor={snap_dict.get('visitor_name')}; "
+            f"employee={snap_dict.get('employee_name')}; "
+            f"appointment={(snap_dict.get('matched_appointment') or {}).get('time')}; "
+            f"email_sent_to={snap_dict.get('email_sent_to')}."
+        )
+        if hint and speak_now:
+            msg = f"{base} SPEAK NOW: {hint}"
+        elif hint:
+            msg = f"{base} Next: {hint}"
+        else:
+            msg = f"{base} Continue the conversation naturally."
+
+        try:
+            if speak_now:
+                await session.send_client_content(
+                    turns=[{"role": "user", "parts": [{"text": msg}]}],
+                    turn_complete=True,
+                )
+            else:
+                await session.send_realtime_input(text=msg)
+            logger.info("Gemini Live: pushed reconnect context (state=%s, speak_now=%s)",
+                        state_value, speak_now)
         except Exception as e:
-            logger.exception("Gemini Live session failed: %s", e)
-            self.session = None
+            logger.warning("reconnect-context send failed: %s", e)
 
     async def shutdown(self) -> None:
         self._shutdown_requested = True