fix(voice): avoid silence on ASR runtime failures

services/ai_voice_runtime_service/media_runtime.py

@@ -283,6 +283,13 @@ class AudioSocketMediaRuntime:
             return "Сейчас уточню."
         return "Секунду."
 
+    @staticmethod
+    def _technical_issue_text(language: str | None) -> str:
+        normalized = str(language or "").strip().lower()
+        if normalized == "kz":
+            return "Техникалық ақау шықты. Оператормен қосамын."
+        return "Возникла техническая проблема со связью. Соединяю с оператором."
+
     @staticmethod
     def _should_use_emotive_ack(registration: MediaRegistration, language: str | None) -> bool:
         if not registration.voice_v2_emotive_ack:
@@ -1184,25 +1191,69 @@ class AudioSocketMediaRuntime:
             actor.barge_in_pending = False
 
     async def _worker(self, actor: MediaActor) -> None:
-        greeting_text = await asyncio.to_thread(
-            self._get_pending_greeting,
-            actor.registration.voice_session_id,
-        )
-        if greeting_text:
-            logger.info(
-                "audiosocket.greeting session_id=%s text_len=%s",
+        try:
+            greeting_text = await asyncio.to_thread(
+                self._get_pending_greeting,
                 actor.registration.voice_session_id,
-                len(greeting_text),
             )
-            await self._speak_reply(actor, greeting_text, is_greeting=True, reply_phase="greeting")
-        if not actor.closed:
-            await self._set_actor_state(actor, "listening")
+            if greeting_text:
+                logger.info(
+                    "audiosocket.greeting session_id=%s text_len=%s",
+                    actor.registration.voice_session_id,
+                    len(greeting_text),
+                )
+                await self._speak_reply(actor, greeting_text, is_greeting=True, reply_phase="greeting")
+            if not actor.closed:
+                await self._set_actor_state(actor, "listening")
 
-        while not actor.closed:
-            pcm_bytes, barge_in = await actor.turn_queue.get()
-            if actor.closed:
-                break
-            await self._process_utterance(actor, pcm_bytes, barge_in)
+            while not actor.closed:
+                pcm_bytes, barge_in = await actor.turn_queue.get()
+                if actor.closed:
+                    break
+                await self._process_utterance(actor, pcm_bytes, barge_in)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            await self._handle_turn_exception(actor, exc)
+
+    async def _handle_turn_exception(self, actor: MediaActor, exc: Exception) -> None:
+        error_text = str(exc)[:500] or "voice_turn_failed"
+        metadata = {
+            "media_uuid": actor.registration.media_uuid,
+            "queue_code": actor.registration.queue_code,
+            "reply_phase": actor.current_reply_phase or "error_handoff",
+            "error_class": exc.__class__.__name__,
+        }
+        logger.warning(
+            "audiosocket.turn_failed session_id=%s error=%s",
+            actor.registration.voice_session_id,
+            error_text,
+        )
+        await self._set_actor_state(actor, "handoff_requested", error_text)
+        fallback_text = self._technical_issue_text(actor.registration.language)
+        with contextlib.suppress(Exception):
+            await self._plan_reply_segment(
+                actor,
+                fallback_text,
+                kind="reply",
+                metadata={
+                    **metadata,
+                    "phase": "error_handoff",
+                    "technical_fallback": True,
+                },
+            )
+            await self._speak_reply(
+                actor,
+                fallback_text,
+                is_greeting=False,
+                reply_phase="error_handoff",
+            )
+        await asyncio.to_thread(
+            self._handle_media_error,
+            actor.registration.voice_session_id,
+            error_text,
+            metadata,
+        )
 
     async def _process_utterance(self, actor: MediaActor, pcm_bytes: bytes, barge_in: bool) -> None:
         await self._set_actor_state(actor, "thinking")