fix(translator): robust LLM response parsing and expose language in API

Normalize model output lines (markdown, list prefixes, case) so LANGUAGE/TRANSLATION are detected reliably and NodeBB no longer mislabels non-English as English when the model formats replies loosely.

- Add _normalize_response_line and extend _parse_model_content to return detected language
- Return optional language from translate_content/query_llm_robust; include in TranslateResponse
- Expand unit tests for **LANGUAGE:**, numbered lists, and Language:/Translation: casing

Author: anthony-tom1

src/api.py

@@ -7,15 +7,17 @@
 class TranslateResponse(BaseModel):
     is_english: bool
     translated_content: str
+    language: str | None = None
 
 
 app = FastAPI()
 
 
 @app.get("/")
 def translator_root(content: str = Query(default="")) -> TranslateResponse:
-    is_english, translated_content = translate_content(content.strip())
+    is_english, translated_content, language = translate_content(content.strip())
     return TranslateResponse(
         is_english=is_english,
         translated_content=translated_content,
+        language=language,
     )

src/translator.py

@@ -28,20 +28,34 @@ def _user_prompt(post: str) -> str:
 Text: {post}"""
 
 
-def _parse_model_content(raw: str, post: str) -> tuple[bool, str]:
+def _normalize_response_line(line: str) -> str:
+    """Strip list markers and leading markdown so LANGUAGE:/TRANSLATION: can be found."""
+    s = line.strip()
+    s = re.sub(r"^(\d+\.|[*•-])\s+", "", s)
+    while s.startswith("*"):
+        s = s[1:].lstrip()
+    return s.lstrip()
+
+
+def _parse_model_content(raw: str, post: str) -> tuple[bool, str, str | None]:
     content = raw.strip()
     if "</redacted_thinking>" in content:
         content = content.split("</redacted_thinking>")[-1].strip()
-    language = None
+    detected_language: str | None = None
     translation = post
     for line in content.splitlines():
-        if line.startswith("LANGUAGE:"):
-            language = line[len("LANGUAGE:") :].strip()
-        elif line.startswith("TRANSLATION:"):
-            translation = line[len("TRANSLATION:") :].strip()
-    if language is None:
-        return (True, post)
-    return (language.lower() == "english", translation)
+        norm = _normalize_response_line(line)
+        low = norm.lower()
+        if low.startswith("language:"):
+            detected_language = norm.split(":", 1)[1].strip()
+            detected_language = detected_language.strip("*").strip()
+        elif low.startswith("translation:"):
+            translation = norm.split(":", 1)[1].strip()
+            translation = translation.strip("*").strip()
+    if detected_language is None:
+        return (True, post, None)
+    is_english = detected_language.lower() == "english"
+    return (is_english, translation, detected_language)
 
 
 def _httpx_timeout() -> httpx.Timeout:
@@ -55,12 +69,12 @@ def _strip_html(text: str) -> str:
     return re.sub(r"<[^>]+>", "", text).strip()
 
 
-def translate_content(content: str) -> tuple[bool, str]:
+def translate_content(content: str) -> tuple[bool, str, str | None]:
     plain = _strip_html(content) if content else content
     return query_llm_robust(plain or content)
 
 
-def query_llm_robust(post: str) -> tuple[bool, str]:
+def query_llm_robust(post: str) -> tuple[bool, str, str | None]:
     url = f"{_ollama_base_url()}/api/chat"
     payload: dict[str, Any] = {
         "model": _ollama_model(),
@@ -73,13 +87,13 @@ def query_llm_robust(post: str) -> tuple[bool, str]:
             response.raise_for_status()
             data = response.json()
     except Exception:
-        return (True, post)
+        return (True, post, None)
 
     message = data.get("message")
     if not isinstance(message, dict):
-        return (True, post)
+        return (True, post, None)
     content = message.get("content")
     if not isinstance(content, str):
-        return (True, post)
+        return (True, post, None)
 
     return _parse_model_content(content, post)

test/unit/test_translator.py

@@ -15,49 +15,77 @@
 
 
 @pytest.mark.parametrize(
-    ("raw", "post", "expected_english", "expected_text"),
+    ("raw", "post", "expected_english", "expected_text", "expected_language"),
     [
         (
             "LANGUAGE: English\nTRANSLATION: Hello, world.",
             "Hello, world.",
             True,
             "Hello, world.",
+            "English",
         ),
         (
             "LANGUAGE: French\nTRANSLATION: Good day.",
             "Bonjour.",
             False,
             "Good day.",
+            "French",
         ),
         (
             "TRANSLATION: only this line",
             "some input",
             True,
             "some input",
+            None,
         ),
         (
             "</redacted_thinking>\nLANGUAGE: Spanish\nTRANSLATION: Hello.",
             "Hola",
             False,
             "Hello.",
+            "Spanish",
         ),
         (
             "LANGUAGE: German\nTRANSLATION: Hi there",
             "src",
             False,
             "Hi there",
+            "German",
         ),
         (
             "No LANGUAGE line at all.\nJust prose.",
             "orig",
             True,
             "orig",
+            None,
         ),
         (
             "LANGUAGE: english\nTRANSLATION: Same",
             "x",
             True,
             "Same",
+            "english",
+        ),
+        (
+            "**LANGUAGE:** French\nTRANSLATION: Hello",
+            "Bonjour",
+            False,
+            "Hello",
+            "French",
+        ),
+        (
+            "1. LANGUAGE: French\nTRANSLATION: Hello",
+            "Bonjour",
+            False,
+            "Hello",
+            "French",
+        ),
+        (
+            "Language: French\nTranslation: Hello",
+            "Bonjour",
+            False,
+            "Hello",
+            "French",
         ),
     ],
 )
@@ -66,8 +94,13 @@ def test_parse_model_content(
     post: str,
     expected_english: bool,
     expected_text: str,
+    expected_language: str | None,
 ) -> None:
-    assert _parse_model_content(raw, post) == (expected_english, expected_text)
+    assert _parse_model_content(raw, post) == (
+        expected_english,
+        expected_text,
+        expected_language,
+    )
 
 
 def test_user_prompt_includes_post_text() -> None:
@@ -94,9 +127,10 @@ def test_query_llm_robust_posts_chat_and_parses_response(monkeypatch: pytest.Mon
         )
     )
 
-    is_english, text = query_llm_robust("in")
+    is_english, text, language = query_llm_robust("in")
     assert is_english is True
     assert text == "out"
+    assert language == "English"
     assert route.called
     payload = json.loads(route.calls[0].request.content.decode())
     assert payload["model"] == "qwen3:0.6b"
@@ -112,7 +146,7 @@ def test_query_llm_robust_connect_error_returns_original(monkeypatch: pytest.Mon
     respx.post(_DEFAULT_CHAT_URL).mock(
         side_effect=httpx.ConnectError("refused", request=req),
     )
-    assert query_llm_robust("fall") == (True, "fall")
+    assert query_llm_robust("fall") == (True, "fall", None)
 
 
 @respx.mock
@@ -123,7 +157,7 @@ def test_query_llm_robust_missing_message_dict_returns_original(
     respx.post(_DEFAULT_CHAT_URL).mock(
         return_value=httpx.Response(200, json={"done": True}),
     )
-    assert query_llm_robust("z") == (True, "z")
+    assert query_llm_robust("z") == (True, "z", None)
 
 
 @respx.mock
@@ -137,20 +171,20 @@ def test_query_llm_robust_non_string_message_content_returns_original(
             json={"message": {"role": "assistant", "content": None}, "done": True},
         ),
     )
-    assert query_llm_robust("y") == (True, "y")
+    assert query_llm_robust("y") == (True, "y", None)
 
 
 def test_translate_content_delegates_to_query_llm_robust(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     calls: list[str] = []
 
-    def fake(post: str) -> tuple[bool, str]:
+    def fake(post: str) -> tuple[bool, str, str | None]:
         calls.append(post)
-        return (True, "ok")
+        return (True, "ok", "English")
 
     monkeypatch.setattr("src.translator.query_llm_robust", fake)
-    assert translate_content("hi") == (True, "ok")
+    assert translate_content("hi") == (True, "ok", "English")
     assert calls == ["hi"]
 
 
@@ -159,10 +193,10 @@ def test_translate_content_strips_html(
 ) -> None:
     calls: list[str] = []
 
-    def fake(post: str) -> tuple[bool, str]:
+    def fake(post: str) -> tuple[bool, str, str | None]:
         calls.append(post)
-        return (False, "translated")
+        return (False, "translated", "French")
 
     monkeypatch.setattr("src.translator.query_llm_robust", fake)
-    assert translate_content("<p>Bonjour</p>") == (False, "translated")
+    assert translate_content("<p>Bonjour</p>") == (False, "translated", "French")
     assert calls == ["Bonjour"]