Add multi-language translator

app.py

@@ -37,8 +37,9 @@ MODELS = [
 
 LANGUAGES = ["English", "French", "German", "Italian", "Russian", "Turkish", "Chinese"]
 
-DEFAULT_MODEL    = MODELS[14][1]
-DEFAULT_LANGUAGE = "English"
+DEFAULT_MODEL       = MODELS[14][1]
+DEFAULT_LANGUAGE    = "English"
+TRANSLATION_MODEL   = "openai/gpt-oss-120b"
 
 #MODEL        = "deepseek-ai/DeepSeek-V3"   # or e.g. "openai/gpt-4o-mini"
 #MODEL       = "Qwen/Qwen3-235B-A22B-Instruct-2507"
@@ -113,6 +114,7 @@ def respond(
         temperature=temperature,
         top_p=top_p,
         language=language,
+        translation_model=TRANSLATION_MODEL,
     )
 
 

engine/chat.py

@@ -22,20 +22,22 @@ from engine.memory import (
 )
 from engine.parser import parse_response, segments_to_markdown
 from engine.prompt_builder import build_messages, load_character
+from engine.translator import translate_from_english, translate_to_english
 
 logger = logging.getLogger(__name__)
 
 
 def generate_response(
-    message:      str,
-    character_id: str,
-    client:       InferenceClient,
-    persona:      dict | None = None,
-    model:        str   = "deepseek-ai/DeepSeek-V3",
-    max_tokens:   int   = 512,
-    temperature:  float = 0.7,
-    top_p:        float = 0.95,
-    language:     str   = "English",
+    message:            str,
+    character_id:       str,
+    client:             InferenceClient,
+    persona:            dict | None = None,
+    model:              str   = "Qwen/Qwen3-235B-A22B-Instruct-2507",
+    max_tokens:         int   = 512,
+    temperature:        float = 0.7,
+    top_p:              float = 0.95,
+    language:           str   = "English",
+    translation_model:  str | None = None,
 ):
     """
     Core streaming generator.
@@ -78,14 +80,26 @@ def generate_response(
     summary          = load_summary(character_id)
     long_term_memory = load_long_term_memory(character_id)
 
+    # ── Translation mode? ──────────────────────────────────────────────────────
+    use_translation = language.strip().lower() != "english" and bool(translation_model)
+
+    if use_translation:
+        # Translate user message → English before sending to main model
+        en_message = translate_to_english(message, language, client, translation_model)
+        prompt_language = "English"   # main model always responds in English
+    else:
+        en_message      = message
+        prompt_language = language
+
+    # ── Build prompt ───────────────────────────────────────────────────────────
     messages = build_messages(
         character=character,
         persona=persona,
         summary=summary,
         long_term_memory=long_term_memory,
         recent_messages=recent_messages,
-        current_message=message,
-        language=language,
+        current_message=en_message,
+        language=prompt_language,
     )
 
     # ── LLM call ──────────────────────────────────────────────────────────────
@@ -93,18 +107,32 @@ def generate_response(
     raw_response = ""
 
     try:
-        for chunk in client.chat_completion(
-            messages,
-            model=model,
-            max_tokens=max_tokens,
-            stream=True,
-            temperature=temperature,
-            top_p=top_p,
-        ):
-            choices = chunk.choices
-            if choices and choices[0].delta.content:
-                raw_response += choices[0].delta.content
-            yield raw_response
+        if use_translation:
+            # Collect silently — yield placeholder while model generates
+            yield "*(…)*"
+            for chunk in client.chat_completion(
+                messages,
+                model=model,
+                max_tokens=max_tokens,
+                stream=True,
+                temperature=temperature,
+                top_p=top_p,
+            ):
+                if chunk.choices and chunk.choices[0].delta.content:
+                    raw_response += chunk.choices[0].delta.content
+        else:
+            # Stream tokens in real time
+            for chunk in client.chat_completion(
+                messages,
+                model=model,
+                max_tokens=max_tokens,
+                stream=True,
+                temperature=temperature,
+                top_p=top_p,
+            ):
+                if chunk.choices and chunk.choices[0].delta.content:
+                    raw_response += chunk.choices[0].delta.content
+                yield raw_response
 
     except Exception as e:
         logger.error(f"[Chat] LLM error: {e}")
@@ -113,14 +141,19 @@ def generate_response(
         return
 
     # ── Post-stream ────────────────────────────────────────────────────────────
-    # Save raw text to memory (preserves original markers for future context)
+    # Memory always stores English (so main model gets consistent context)
     try:
-        append_message(character_id, "user",      message)
+        append_message(character_id, "user",      en_message)
         append_message(character_id, "assistant", raw_response)
     except Exception as e:
         logger.error(f"[Chat] Memory save failed: {e}")
 
-    # ── Final yield: formatted markdown ───────────────────────────────────���───
-    segments  = parse_response(raw_response)
+    # ── Translate response → user's language, format, yield ───────────────────
+    if use_translation:
+        final_text = translate_from_english(raw_response, language, client, translation_model)
+    else:
+        final_text = raw_response
+
+    segments  = parse_response(final_text)
     formatted = segments_to_markdown(segments)
     yield formatted

engine/translator.py

@@ -0,0 +1,94 @@
+"""
+Translation layer — translates between the user's language and English.
+
+The main LLM always receives and produces English.
+This module handles conversion in both directions so the UI shows the user's language.
+
+Formatting rules:
+    Text inside (parentheses) and *asterisks* is roleplay markup — it must be
+    preserved as-is so the parser can still identify actions and thoughts.
+"""
+
+import logging
+from huggingface_hub import InferenceClient
+
+logger = logging.getLogger(__name__)
+
+_TO_EN = (
+    "You are a professional translator. "
+    "Translate the following text to English. "
+    "Preserve any text inside parentheses ( ) and asterisks * exactly as written — do not translate them. "
+    "Return ONLY the translation, no explanations or extra text."
+)
+
+_FROM_EN = (
+    "You are a professional translator. "
+    "Translate the following text to {language}. "
+    "Preserve any text inside parentheses ( ) and asterisks * exactly as written — do not translate them. "
+    "Return ONLY the translation, no explanations or extra text."
+)
+
+
+def translate_to_english(
+    text:            str,
+    source_language: str,
+    client:          InferenceClient,
+    model:           str,
+) -> str:
+    """
+    Translate `text` from `source_language` to English.
+    Returns the original text unchanged if already English or on any failure.
+    """
+    if not text.strip() or source_language.strip().lower() == "english":
+        return text
+
+    try:
+        response = client.chat_completion(
+            messages=[
+                {"role": "system", "content": _TO_EN},
+                {"role": "user",   "content": text},
+            ],
+            model=model,
+            max_tokens=1024,
+            stream=False,
+            temperature=0.1,
+        )
+        result = response.choices[0].message.content.strip()
+        logger.info(f"[Translator] {source_language}→EN: {text[:60]!r} → {result[:60]!r}")
+        return result
+    except Exception as e:
+        logger.warning(f"[Translator] to_english failed ({e}), keeping original.")
+        return text
+
+
+def translate_from_english(
+    text:            str,
+    target_language: str,
+    client:          InferenceClient,
+    model:           str,
+) -> str:
+    """
+    Translate `text` from English to `target_language`.
+    Returns the original text unchanged if target is English or on any failure.
+    """
+    if not text.strip() or target_language.strip().lower() == "english":
+        return text
+
+    try:
+        system = _FROM_EN.format(language=target_language)
+        response = client.chat_completion(
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user",   "content": text},
+            ],
+            model=model,
+            max_tokens=1024,
+            stream=False,
+            temperature=0.1,
+        )
+        result = response.choices[0].message.content.strip()
+        logger.info(f"[Translator] EN→{target_language}: {text[:60]!r} → {result[:60]!r}")
+        return result
+    except Exception as e:
+        logger.warning(f"[Translator] from_english failed ({e}), keeping original.")
+        return text