fix(indic): KI-110 — repair Hindi pipeline raising on every turn

Live re-smoke verification (2026-05-15) caught every Hindi/Devanagari turn
in Scenario S2 surfacing `brain_used=error_fallback` from KI-106's catch-all
exception handler. Root cause: post-KI-099 the translator's try/except only
catches `asyncio.TimeoutError` — but the KI-099 split httpx.Timeout(connect=2,
read=20, write=2, pool=2) means httpx can raise other exception types that
are NOT subclasses of asyncio.TimeoutError:

- httpx.ReadTimeout (inner 20s read budget; races the outer wait_for(20s))
- httpx.ConnectError / ConnectTimeout (network / DNS / TLS failures)
- httpx.HTTPStatusError (Sarvam 429 rate-limit on Indic-heavy load, or 5xx
server hiccups, surfaced by resp.raise_for_status())
- KeyError ("choices") on malformed Sarvam payload
- ValueError on malformed JSON / dataclass construction

Any of these would propagate up through translate_to_english /
translate_to_indic. While orchestrator's wrapping `except Exception` catches
the inbound call, translation_check.check_back_translation chains another
translate_to_english that — combined with sibling KI-108/109 reorganisation
of the indic cascade — could still surface as the user-facing error.

Fix: translator contract is now "NEVER raise on a Sarvam failure". Both
translate_to_english and translate_to_indic catch the explicit tuple of
Sarvam-originated exception types (_TRANSLATOR_FAILURE_TYPES) and passthrough
the original text on any failure. Logged with type-name so Sarvam health
remains observable from logs.

We deliberately do NOT catch asyncio.CancelledError (would break task
cancellation), and we do NOT use bare `except Exception` (would hide real
coding bugs in the translator path itself).

Files touched:
- backend/translator.py: explicit failure-type tuple, broadened catch
- tests/test_translator.py: NEW — 11 regression tests covering every
Sarvam failure mode (httpx.ReadTimeout, ConnectError, HTTPStatusError,
KeyError, asyncio.TimeoutError, malformed payload, empty input) and a
CRITICAL test that asyncio.CancelledError still propagates

Test results: 86 passed (75 existing + 11 new), 29 subtests passed, 0 failures.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

backend/translator.py

@@ -20,6 +20,8 @@ from __future__ import annotations
 import asyncio
 import logging
 
+import httpx
+
 from backend.providers.base import ChatMessage
 from backend.providers.sarvam_llm import SarvamLLM
 
@@ -31,6 +33,35 @@ from backend.providers.sarvam_llm import SarvamLLM
 # something is genuinely wedged.
 _SARVAM_CALL_TIMEOUT = 20.0
 
+
+# KI-110 (2026-05-15) — translator contract: NEVER raise on a Sarvam failure.
+# Callers (orchestrator inbound translate, cascade outbound translate,
+# translation_check back-translate) all degrade gracefully when passthrough
+# text is returned, but any exception escaping translate_to_english /
+# translate_to_indic is a P0: live re-smoke verified that EVERY Hindi /
+# Devanagari turn surfaced `brain_used=error_fallback` from KI-106's catch-all
+# because the translator could raise non-TimeoutError exceptions and the
+# catch only handled `asyncio.TimeoutError`.
+#
+# Specifically, post-KI-099 the inner httpx.Timeout(read=20.0) races with the
+# outer asyncio.wait_for(timeout=20.0). When httpx fires first it raises
+# `httpx.ReadTimeout` (NOT a subclass of asyncio.TimeoutError); on Sarvam 4xx
+# or 5xx (rate-limit on Indic-heavy load, auth issues, server hiccups) it
+# raises `httpx.HTTPStatusError`; on malformed payload it raises KeyError on
+# `payload["choices"][0]`. None were caught.
+#
+# Fix: catch every Sarvam-originated exception type explicitly. We do NOT
+# catch `asyncio.CancelledError` (would break task cancellation), and we do
+# NOT use a bare `except Exception` (would hide real coding bugs).
+_TRANSLATOR_FAILURE_TYPES: tuple[type[BaseException], ...] = (
+    asyncio.TimeoutError,
+    httpx.TimeoutException,  # ConnectTimeout / ReadTimeout / WriteTimeout / PoolTimeout
+    httpx.HTTPStatusError,   # 4xx/5xx from Sarvam
+    httpx.RequestError,      # network / DNS / SSL / connect errors
+    KeyError,                # malformed Sarvam payload (missing 'choices')
+    ValueError,              # malformed JSON / dataclass construction
+)
+
 _log = logging.getLogger(__name__)
 
 
@@ -82,10 +113,14 @@ async def translate_to_english(text: str, sarvam: SarvamLLM | None = None) -> st
             ),
             timeout=_SARVAM_CALL_TIMEOUT,
         )
-    except asyncio.TimeoutError:
+    except _TRANSLATOR_FAILURE_TYPES as e:
+        # KI-110 — passthrough on ANY Sarvam failure (timeout, http error,
+        # network error, malformed payload). The translator contract is
+        # "never raise" so callers don't see this as a chat-killing
+        # exception. Log with type-name so we can still observe Sarvam health.
         _log.warning(
-            "sarvam translate_to_english wait_for timed out after %.1fs — passthrough",
-            _SARVAM_CALL_TIMEOUT,
+            "sarvam translate_to_english passthrough (%s): %s",
+            type(e).__name__, str(e)[:200],
         )
         return text
     out = res.text.strip()
@@ -123,10 +158,14 @@ async def translate_to_indic(
             ),
             timeout=_SARVAM_CALL_TIMEOUT,
         )
-    except asyncio.TimeoutError:
+    except _TRANSLATOR_FAILURE_TYPES as e:
+        # KI-110 — see translate_to_english for full rationale. Passthrough
+        # the English on any Sarvam failure; orchestrator's indic cascade
+        # treats English-back == English-input as "no cascade translation"
+        # and serves the English reply unchanged.
         _log.warning(
-            "sarvam translate_to_indic wait_for timed out after %.1fs — passthrough",
-            _SARVAM_CALL_TIMEOUT,
+            "sarvam translate_to_indic passthrough (%s): %s",
+            type(e).__name__, str(e)[:200],
         )
         return english
     out = res.text.strip()

tests/test_translator.py

@@ -0,0 +1,139 @@
+"""Regression tests for backend.translator — KI-110.
+
+Locks in the translator contract: NEVER raise on a Sarvam failure. Live
+re-smoke (2026-05-15) caught every Hindi turn in Scenario S2 surfacing
+`brain_used=error_fallback` because the post-KI-099 try/except only caught
+`asyncio.TimeoutError` — leaving httpx.ReadTimeout, httpx.HTTPStatusError,
+httpx.RequestError, and KeyError (malformed Sarvam payload) to propagate
+through to KI-106's catch-all in main.py.
+
+These tests assert: every Sarvam failure mode returns the original text
+(passthrough), not raises. Mirrors the existing project convention of
+asyncio.run inside unittest.TestCase (no pytest-asyncio dependency).
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+import unittest
+from unittest.mock import AsyncMock
+
+import httpx
+
+# Ensure SARVAM_API_KEY is set so SarvamLLM constructor doesn't reject
+os.environ.setdefault("SARVAM_API_KEY", "test-key-stub")
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from backend.providers.base import LLMResult  # noqa: E402
+from backend.providers.sarvam_llm import SarvamLLM  # noqa: E402
+from backend.translator import translate_to_english, translate_to_indic  # noqa: E402
+
+
+HINDI_QUERY = "मुझे स्वास्थ्य बीमा चाहिए"
+ENGLISH_REPLY = "Yes, HDFC ERGO Optima Secure covers Ayurveda treatment."
+
+
+def _make_request() -> httpx.Request:
+    """httpx exceptions need a Request; construct a minimal one."""
+    return httpx.Request("POST", "https://api.sarvam.ai/v1/chat/completions")
+
+
+def _stub_sarvam(side_effect=None, return_value=None) -> SarvamLLM:
+    fake = SarvamLLM(api_key="stub")
+    if side_effect is not None:
+        fake.chat = AsyncMock(side_effect=side_effect)  # type: ignore[method-assign]
+    else:
+        fake.chat = AsyncMock(return_value=return_value)  # type: ignore[method-assign]
+    return fake
+
+
+class TranslateToEnglishTests(unittest.TestCase):
+    def test_happy_path(self):
+        fake = _stub_sarvam(return_value=LLMResult(
+            text="I want health insurance",
+            model="sarvam-m",
+        ))
+        out = asyncio.run(translate_to_english(HINDI_QUERY, sarvam=fake))
+        self.assertEqual(out, "I want health insurance")
+
+    def test_passthrough_on_asyncio_timeout(self):
+        """KI-099 baseline: outer wait_for fires → passthrough original Hindi."""
+        fake = _stub_sarvam(side_effect=asyncio.TimeoutError())
+        out = asyncio.run(translate_to_english(HINDI_QUERY, sarvam=fake))
+        self.assertEqual(out, HINDI_QUERY)
+
+    def test_passthrough_on_httpx_read_timeout(self):
+        """KI-110 P0: httpx.ReadTimeout (NOT subclass of asyncio.TimeoutError) — passthrough."""
+        fake = _stub_sarvam(side_effect=httpx.ReadTimeout(
+            "Read timeout", request=_make_request(),
+        ))
+        out = asyncio.run(translate_to_english(HINDI_QUERY, sarvam=fake))
+        self.assertEqual(out, HINDI_QUERY)
+
+    def test_passthrough_on_httpx_connect_error(self):
+        """KI-110: Sarvam unreachable — passthrough."""
+        fake = _stub_sarvam(side_effect=httpx.ConnectError(
+            "Connection refused", request=_make_request(),
+        ))
+        out = asyncio.run(translate_to_english(HINDI_QUERY, sarvam=fake))
+        self.assertEqual(out, HINDI_QUERY)
+
+    def test_passthrough_on_http_status_error(self):
+        """KI-110: Sarvam 429 (rate-limit on Indic-heavy load) — passthrough."""
+        req = _make_request()
+        resp = httpx.Response(status_code=429, request=req)
+        fake = _stub_sarvam(side_effect=httpx.HTTPStatusError(
+            "Too Many Requests", request=req, response=resp,
+        ))
+        out = asyncio.run(translate_to_english(HINDI_QUERY, sarvam=fake))
+        self.assertEqual(out, HINDI_QUERY)
+
+    def test_passthrough_on_malformed_payload(self):
+        """KI-110: Sarvam returns malformed payload (no 'choices' key) — passthrough."""
+        fake = _stub_sarvam(side_effect=KeyError("choices"))
+        out = asyncio.run(translate_to_english(HINDI_QUERY, sarvam=fake))
+        self.assertEqual(out, HINDI_QUERY)
+
+    def test_empty_input_no_sarvam_call(self):
+        """Empty input: returns immediately, no Sarvam call."""
+        self.assertEqual(asyncio.run(translate_to_english("")), "")
+        self.assertEqual(asyncio.run(translate_to_english("   ")), "   ")
+
+    def test_cancelled_error_propagates(self):
+        """CRITICAL: asyncio.CancelledError MUST propagate — never swallow it,
+        otherwise outer wait_for / task cancellation breaks."""
+        fake = _stub_sarvam(side_effect=asyncio.CancelledError())
+        with self.assertRaises(asyncio.CancelledError):
+            asyncio.run(translate_to_english(HINDI_QUERY, sarvam=fake))
+
+
+class TranslateToIndicTests(unittest.TestCase):
+    def test_happy_path(self):
+        fake = _stub_sarvam(return_value=LLMResult(
+            text="Haan, HDFC ERGO Optima Secure mein Ayurveda cover hai.",
+            model="sarvam-m",
+        ))
+        out = asyncio.run(translate_to_indic(ENGLISH_REPLY, sarvam=fake))
+        self.assertIn("HDFC", out)
+
+    def test_passthrough_on_httpx_read_timeout(self):
+        fake = _stub_sarvam(side_effect=httpx.ReadTimeout(
+            "Read timeout", request=_make_request(),
+        ))
+        out = asyncio.run(translate_to_indic(ENGLISH_REPLY, sarvam=fake))
+        self.assertEqual(out, ENGLISH_REPLY)
+
+    def test_passthrough_on_http_status_error(self):
+        req = _make_request()
+        resp = httpx.Response(status_code=500, request=req)
+        fake = _stub_sarvam(side_effect=httpx.HTTPStatusError(
+            "Server Error", request=req, response=resp,
+        ))
+        out = asyncio.run(translate_to_indic(ENGLISH_REPLY, sarvam=fake))
+        self.assertEqual(out, ENGLISH_REPLY)
+
+
+if __name__ == "__main__":
+    unittest.main()