deploy(S4): Blender headless pipeline + WebAR client + backend fixes

backend/db/mongodb.py

@@ -1,10 +1,16 @@
 import os
+import logging
 import certifi
 from motor.motor_asyncio import AsyncIOMotorClient
 
-# Load the URI from environment variables or use the default provided string
-# In production on HF Spaces, this will be set via Space Secrets
-MONGO_URI = os.getenv("MONGO_URI", "mongodb+srv://JARVIS:JARVIS@cluster0.qdzuimf.mongodb.net/?appName=Cluster0")
+# The URI is a secret and must come from the environment only:
+#   - PC/exe: MONGO_URI in the loaded .env
+#   - HF Space: MONGO_URI Space Secret
+# It is deliberately NOT hardcoded here — an embedded connection string is a
+# second copy of a live credential that silently drifts out of sync the moment
+# the real secret is rotated (exactly the duplication the vault is meant to
+# prevent).
+MONGO_URI = os.getenv("MONGO_URI", "").strip()
 
 class MongoDBClient:
     _client = None
@@ -12,6 +18,12 @@ class MongoDBClient:
     @classmethod
     def get_client(cls) -> AsyncIOMotorClient:
         if cls._client is None:
+            if not MONGO_URI:
+                raise RuntimeError(
+                    "MONGO_URI is not configured. Set it in the local .env "
+                    "(PC/exe) or as an HF Space Secret (cloud) before using "
+                    "Mongo-backed memory."
+                )
             # We use certifi to prevent SSL handshake errors when running inside Docker
             cls._client = AsyncIOMotorClient(MONGO_URI, tlsCAFile=certifi.where())
         return cls._client

backend/memory/consolidator.py

@@ -90,7 +90,7 @@ class MemoryConsolidator:
         
         for t in triples:
             if "subject" in t and "predicate" in t and "object" in t:
-                self.semantic.add_fact(
+                await self.semantic.add_fact(
                     subject=t["subject"],
                     predicate=t["predicate"],
                     obj=t["object"],
@@ -115,8 +115,9 @@ If none, return {"tasks": []}"""
         
         for t in tasks:
             if "task_name" in t and "steps" in t:
-                # Update ProceduralMemory
-                self.procedural.record_success(t["task_name"], t["steps"])
+                # Update ProceduralMemory (async — must be awaited or the Mongo
+                # write is silently dropped, same class of bug as add_fact above).
+                await self.procedural.record_success(t["task_name"], t["steps"])
                 
         # Finally, clear working memory
         working_memory.clear()

backend/requirements.txt

@@ -4,18 +4,21 @@
 # Those are only needed in the local Windows EXE build.
 
 # ── Core API ──────────────────────────────────────────────────────────────────
-fastapi
+# Upper bounds cap the next MAJOR (the actual break vector) while still admitting
+# every version currently resolving on the live Space — this stops a silent
+# rebuild from pulling a breaking fastapi/starlette/pydantic 1.x→next-major.
+fastapi<1.0
 uvicorn[standard]
 websockets
 python-multipart
-pydantic>=2.0.0
-starlette
+pydantic>=2.0.0,<3.0
+starlette<1.0
 
 # ── Database Layer ─────────────────────────────────────────────────────────────
 pymongo
 motor
 certifi
-chromadb
+chromadb<1.0
 SQLAlchemy==2.0.23
 apscheduler==3.10.4
 
@@ -27,10 +30,10 @@ google-auth-oauthlib>=1.1.0
 google-api-python-client>=2.118.0
 openai>=1.0.0
 anthropic>=0.25.0
-huggingface_hub
-transformers>=4.40.0
-torch>=2.1.0
-torchaudio>=2.1.0
+huggingface_hub<1.0
+transformers>=4.40.0,<5.0
+torch>=2.1.0,<3.0
+torchaudio>=2.1.0,<3.0
 sentence-transformers
 librosa
 scipy

backend/services/token_manager.py

@@ -26,6 +26,24 @@ from backend.services.usb_vault import KeyDomain, resolve_vault_key
 def get_runtime_location() -> str:
     return "cloud" if os.environ.get("SPACE_ID") else "pc"
 
+def _persona_system_prompt(persona: str) -> str:
+    """The identity prompt for the EXPLICITLY requested persona.
+
+    The mobile app (and other callers) pass the persona they want per-turn, so
+    we select on that string directly rather than the persisted global mode.
+    Without this, LLM replies carry no JARVIS/FRIDAY character at all — the
+    identity file that is supposed to be the source of truth was being ignored
+    on the primary /api/chat path.
+    """
+    try:
+        from modules.assistant_identity import (
+            JARVIS_PERSONALITY_PROMPT, FRIDAY_PERSONALITY_PROMPT,
+        )
+        p = (persona or "jarvis").strip().lower()
+        return JARVIS_PERSONALITY_PROMPT if p == "jarvis" else FRIDAY_PERSONALITY_PROMPT
+    except Exception:
+        return ""
+
 # Load all 15 keys into the token manager pool
 GOOGLE_API_KEYS = {}
 try:
@@ -225,8 +243,11 @@ def _nvidia_fallback_call_sync(prompt: str, task_id: str, task_type: str, partia
     # Construct exact prompt with resume logic and hive mind context
     actual_prompt = _build_resume_prompt(prompt, partial_so_far, _extract_last_word(partial_so_far))
     if not partial_so_far:
-        actual_prompt = omni_context + actual_prompt
-        
+        # NVIDIA models take no separate system channel here, so the persona
+        # prompt is prepended (same place the hive-mind context goes).
+        _sys = _persona_system_prompt(persona)
+        actual_prompt = (_sys + "\n\n" if _sys else "") + omni_context + actual_prompt
+
     # Delegate to the NVIDIA Vault API directly
     from backend.services.nvidia_vault import call_nvidia_model, NvidiaModel
     fallback_response = call_nvidia_model(actual_prompt, NvidiaModel.GLM_5_1)
@@ -249,11 +270,14 @@ def _gemini_call_sync(prompt: str, task_id: str, task_type: str,
         
     genai.configure(api_key=key)
     _broadcast_live_key_status("GOOGLE", MODEL, "primary_active")
-    
+
     from backend.services.memory_service import GlobalOmniMemory
     omni_context = GlobalOmniMemory.get_global_context_stream()
-    
-    model = genai.GenerativeModel(MODEL)
+
+    # Shape the reply in the active assistant's voice (JARVIS/FRIDAY). Skip on a
+    # resume continuation so we don't restate the persona mid-sentence.
+    _sys = _persona_system_prompt(persona) if not partial_so_far else None
+    model = genai.GenerativeModel(MODEL, system_instruction=_sys) if _sys else genai.GenerativeModel(MODEL)
     actual_prompt = _build_resume_prompt(prompt, partial_so_far, _extract_last_word(partial_so_far))
     if not partial_so_far:
         actual_prompt = omni_context + actual_prompt

backend/services/usb_vault.py

@@ -139,8 +139,15 @@ def resolve_vault_key(domain: KeyDomain) -> str:
         # Fallback to local SQLite vault
         key = get_secret(env_var_name)
         
-    # BACKWARD COMPATIBILITY: If the new key slot is empty, check the old generic GEMINI_API_KEY slot
-    if not key and domain in (KeyDomain.CHAT, KeyDomain.CLOUD):
+    # BACKWARD COMPATIBILITY / SINGLE-KEY FALLBACK: every domain here is a Google
+    # (Gemini) key slot. If a caller hasn't provisioned the dedicated per-domain
+    # key, fall back to the generic GEMINI_API_KEY rather than crashing the
+    # feature. The dedicated key is always preferred (checked above) so the
+    # multi-key rate-limit partitioning still applies whenever it's configured;
+    # this only rescues the common single-key desktop user, for whom otherwise
+    # only chat/cloud worked and gaming-coach / image-gen / self-heal / etc.
+    # raised MissingDomainKeyError.
+    if not key:
         key = os.environ.get("GEMINI_API_KEY") or get_secret("GEMINI_API_KEY")
         
     if not key:

backend/voice/tts.py

@@ -70,13 +70,23 @@ class TTSPipeline:
         logging.info(f"[TTS] Routing to Edge-TTS for unsupported language: '{language}'")
         try:
             import edge_tts
-            voices = await edge_tts.list_voices()
             target_gender = "Male" if personality == "jarvis" else "Female"
             selected_voice = None
-            for v in voices:
-                if v["Locale"].lower().startswith(language.lower()) and v["Gender"] == target_gender:
-                    selected_voice = v["ShortName"]
-                    break
+            # For English, honour the identity file's chosen persona voice
+            # (JARVIS → British male, FRIDAY → Irish female) instead of grabbing
+            # the first gender match, so the cloud voice matches the desktop one.
+            if language.lower().startswith("en"):
+                try:
+                    from modules.assistant_identity import get_voice_id_for_mode
+                    selected_voice = get_voice_id_for_mode("jarvis" if personality == "jarvis" else "friday")
+                except Exception:
+                    selected_voice = None
+            if not selected_voice:
+                voices = await edge_tts.list_voices()
+                for v in voices:
+                    if v["Locale"].lower().startswith(language.lower()) and v["Gender"] == target_gender:
+                        selected_voice = v["ShortName"]
+                        break
             if not selected_voice:
                 selected_voice = "gu-IN-NiranjanNeural" if target_gender == "Male" else "gu-IN-DhwaniNeural"
             communicate = edge_tts.Communicate(text, selected_voice)
@@ -110,15 +120,19 @@ class TTSPipeline:
         loop = asyncio.get_running_loop()
         def _sync_tts():
             if self.tts is None:
-                try:
-                    from TTS.api import TTS as CoquiTTS
-                    self.tts = CoquiTTS("tts_models/multilingual/multi-dataset/xtts_v2")
-                except Exception as e:
-                    import logging
-                    logging.error(f"[XTTS] Failed to load model: {e}")
-                    raise RuntimeError("XTTS backend failed to load") from e
+                from TTS.api import TTS as CoquiTTS
+                self.tts = CoquiTTS("tts_models/multilingual/multi-dataset/xtts_v2")
             return self.tts.tts(text=text, language=language, speaker_wav=speaker_wav, **params)
-        wav = await loop.run_in_executor(None, _sync_tts)
+        try:
+            wav = await loop.run_in_executor(None, _sync_tts)
+        except Exception as e:
+            # Coqui XTTS is intentionally NOT installed on the cloud Space (too
+            # heavy), and the speaker clone wav may be absent there too. Rather
+            # than 500 (which left the DEFAULT persona with no cloud voice at
+            # all), fall back to Edge-TTS in FRIDAY's identity voice.
+            import logging
+            logging.warning(f"[TTS] FRIDAY XTTS unavailable ({e}); falling back to Edge-TTS.")
+            return await self._synthesize_edge_tts(text, personality, language)
         res = wav_to_bytes(wav)
         del wav
         import gc