Update app.py

app.py

@@ -1456,18 +1456,11 @@ class Hive:
     def chat(self, message:str, effective_role:str, caller_id: Optional[str],
              k:int=None, max_new_tokens:int=256, temperature:float=None, prompt_override: Optional[str] = None) -> str: # type: ignore
         temp = temperature if temperature is not None else (self.decoding_temperature if not self.lite_mode else 0.7)
-        
-        user_obj, _ = _find_user(_load_users(), caller_id)
-        user_prefs = (user_obj.get("prefs", {}) or {}) if user_obj else {}
-        user_lang = user_prefs.get("language", "en")
-        phonics_on = user_prefs.get("phonics_on", False)
-        
-        final_message, intent = self._prepare_chat_input(message, user_lang, phonics_on, prompt_override) # type: ignore
 
         if self.lite_mode:
-            prompt = f"User: {final_message}\nAssistant:"
+            prompt = f"<|user|>\n{message}</s>\n<|assistant|>\n"
             full_reply = "".join(list(self.chat_stream(prompt, max_new_tokens, temp)))
-            return full_reply.rsplit("Assistant:", 1)[-1].strip()
+            return full_reply
         
         kk = k if k is not None else (self.retrieval_k if hasattr(self, 'retrieval_k') else 6)
         snippets = self._get_retrieval_context(message, effective_role, caller_id, kk) # type: ignore
@@ -1520,6 +1513,7 @@ def launch_ui(bootstrap_instance: "Bootstrap"):
                 chatbot = gr.Chatbot(height=600, type="messages", label="Chat", placeholder="Initializing...")
                 msg = gr.Textbox(placeholder="Please wait for the model to load...", interactive=False, show_label=False, container=False, scale=4)
 
+
             with gr.Column(scale=1, min_width=300):
                 with gr.Sidebar():
                     uid_state=gr.State(None); role_state=gr.State("guest"); mode_state=gr.State("user"); phonics_state=gr.State(False) # type: ignore
@@ -1734,12 +1728,19 @@ def launch_ui(bootstrap_instance: "Bootstrap"):
                 gr.Button(interactive=True), # apply_btn
             )
         demo.load(wait_for_memory_features, None, [core_status, summary_output, msg, summary_btn, vocab_output, vocab_btn, progress_output, online_now, ingest_now_btn, mem_compress_btn, hotpatch_apply, propose_btn, test_btn, apply_btn, network_status_md])
+        def wait_for_lite_core():
+            """Waits for the lite Hive core and enables basic chat."""
+            bootstrap_instance.lite_core_ready.wait()
+            return gr.Textbox(placeholder=f"Talk to {CFG['AGENT_NAME']} (Lite Mode)", interactive=True)
+
+        demo.load(wait_for_lite_core, None, [msg])
         vocab_btn.click(do_get_vocab_word, [uid_state], [vocab_output]) # type: ignore
 
 
         def wait_for_voice_features(request: gr.Request):
             """Waits for ASR/TTS models and enables voice-related UI elements."""
             bootstrap_instance.voice_ready.wait()
+            bootstrap_instance.hive_ready.wait() # Also wait for full core for voice features
             hive_instance = get_hive_instance() # type: ignore
 
             voice_ready = not hive_instance.lite_mode and hasattr(hive_instance, 'asr_service') and hasattr(hive_instance, 'tts_service')
@@ -2038,6 +2039,7 @@ class Bootstrap:
         self.hive_instance: Optional[Hive] = None
         self.hive_lite_instance: Optional[Hive] = None
         self.hive_ready = threading.Event()
+        self.lite_core_ready = threading.Event()
         self.voice_ready = threading.Event()
         self.env: Optional[Dict] = None
         self.app: Optional[gr.Blocks] = None # type: ignore
@@ -2077,27 +2079,34 @@ class Bootstrap:
             print("[Bootstrap] Low memory detected, enabling ultra-constrained mode.")
             self.config["CTX_TOKENS"] = min(self.config.get("CTX_TOKENS", 2048), 1024)
 
-        # --- Lite Core Initialization (Fast Path) ---
         self._run_task("lite_core_init", self._init_lite_core)
 
+        # --- Pre-launch heavy model loading in parallel ---
+        llm_thread = threading.Thread(target=lambda: get_hive_instance(lite=False, caps=self.caps), daemon=True)
+        asr_thread = threading.Thread(target=get_asr, daemon=True)
+        tts_thread = threading.Thread(target=lambda: get_tts(CFG["TTS_LANG"]), daemon=True)
+
+        llm_thread.start()
+        asr_thread.start()
+        tts_thread.start()
+
         def full_init_task():
             """Initializes the full Hive instance."""
-            Hive.bootstrap_instance = self
-            self.hive_instance = Hive(lite=False, caps=self.caps)
+            llm_thread.join()  # Wait for the LLM to be loaded
+            self.hive_instance = get_hive_instance(lite=False) # Retrieve the pre-loaded instance
             self.hive_ready.set()
 
         def self_optimize_task():
             """Kicks off the self-optimization process after full initialization."""
             self.hive_ready.wait()  # Wait for the full hive to be ready
             if self.hive_instance and hasattr(self.hive_instance, 'selfopt'):
-                print("[Bootstrap] Triggering initial self-optimization cycle.") # type: ignore
+                print("[Bootstrap] Triggering initial self-optimization cycle.")
                 self.hive_instance.selfopt.trigger_once()
 
         def voice_init_task():
             """Initializes voice models in a separate thread."""
-            with ThreadPoolExecutor(max_workers=2) as executor:
-                executor.submit(get_asr)
-                executor.submit(get_tts, CFG["TTS_LANG"])
+            asr_thread.join()
+            tts_thread.join()
             self.voice_ready.set()
 
         # --- Launch Background Initialization Tasks ---
@@ -2107,7 +2116,7 @@ class Bootstrap:
             "full_core_init": (self._run_task, "full_core_init", full_init_task),
             "self_optimize": (self._run_task, "self_optimize", self_optimize_task),
         }
-        for name, (runner, task_name, target) in tasks.items(): # type: ignore
+        for name, (runner, task_name, target) in tasks.items():
             threading.Thread(target=runner, args=(task_name, target), daemon=True).start()
 
         import signal
@@ -2122,6 +2131,7 @@ class Bootstrap:
         Hive.bootstrap_instance = self
         self.hive_lite_instance = Hive(lite=True, caps=self.caps)
         self.video_service = VideoService() # type: ignore
+        self.lite_core_ready.set()
         self.video_service.start()
 
     def soft_restart(self):