Update app.py

app.py

@@ -1255,16 +1255,10 @@ class PromptCompiler:
         return f"{head} {insight}\n\nUser: {final_instruction}\nAssistant:"
 
 class Hive:
-    def __init__(self, model_id: Optional[str]=None, device: Optional[str]=None, caps: Optional[Dict]=None, lite: bool=False):
+    def __init__(self, model_id: Optional[str]=None, device: Optional[str]=None, caps: Optional[Dict]=None): # type: ignore
         self.caps = caps or probe_caps()
-        self.lite_mode = lite
-
-        if not self.lite_mode:
-            self.store=CurveStore(CFG["CURVE_DIR"]); self.librarian=LibrarianCurve(self.store)
-            self.engine=EngineCurve()
-            self.overlay=RuntimeOverlay()
-            self.changes=ChangeManager(Hive)
-        self.compiler=PromptCompiler()
+        self.store=CurveStore(CFG["CURVE_DIR"]); self.librarian=LibrarianCurve(self.store)
+        self.compiler=PromptCompiler(); self.engine=EngineCurve()
         if not model_id:
             model_id, info = pick_model(self.caps)
             device = info.get("device","cpu")
@@ -1289,10 +1283,11 @@ class Hive:
             self.model = AutoModelForCausalLM.from_pretrained(self.model_id, trust_remote_code=trust, **kwargs)
             self.pipe = pipeline("text-generation", model=self.model, tokenizer=self.tok, device=0 if (torch and torch.cuda.is_available() and device=="cuda") else -1, return_full_text=False)
         
-        if not self.lite_mode:
-            self.retrieval_k=6; self.decoding_temperature=0.7; self.web_threshold=0.40
-            self.overlay.apply_to(self)
-            self.selfopt=SelfOptimizer(self); self.selfopt.start()
+        self.overlay=RuntimeOverlay()
+        self.retrieval_k=6; self.decoding_temperature=0.7; self.web_threshold=0.40
+        self.overlay.apply_to(self)
+        self.changes=ChangeManager(Hive)
+        self.selfopt=SelfOptimizer(self); self.selfopt.start() # type: ignore
 
     def summarize_for_memory(self, text:str, max_new_tokens:int=160)->str:
         prompt=("Condense the following content into 4–6 bullet points with names, dates, numbers, and a one-line takeaway. Keep it factual.\n\n"
@@ -1301,11 +1296,9 @@ class Hive:
         return out[0]["generated_text"].split("Summary:",1)[-1].strip()
 
     def add_curve(self, text:str, meta:Dict, scope:str="general"):
-        if self.lite_mode: return
         self.librarian.ingest_pairs([text],[meta],scope)
 
     def online_update(self, query_hint: Optional[str]=None)->Dict:
-        if self.lite_mode: return {"ok":False, "reason":"lite mode"}
         if not CFG["ONLINE_ENABLE"]: return {"ok":False,"reason":"online disabled"}
         if not online_available(int(CFG["ONLINE_TIMEOUT"])): return {"ok":False,"reason":"offline"}
         seen=_load_json(ONLINE_DB, {})
@@ -1322,7 +1315,6 @@ class Hive:
         _save_json(ONLINE_DB, seen); return {"ok":True,"added":added}
 
     def web_update_and_store(self, query:str, max_docs:int, timeout:int)->int:
-        if self.lite_mode: return 0
         if not (CFG["ONLINE_ENABLE"] and online_available(timeout)): return 0
         hits=web_search_snippets(query, max_results=max_docs, timeout=timeout); added=0
         for h in hits:
@@ -1335,23 +1327,16 @@ 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
-        
-        if self.lite_mode:
-            # In lite mode, we bypass all complex logic and just chat.
-            prompt = f"User: {message}\nAssistant:"
-            temp = temperature if temperature is not None else 0.7
-            out = self.pipe(prompt, max_new_tokens=max_new_tokens, do_sample=True, temperature=temp)
-            return out[0]["generated_text"].strip()
-
-        online_now = NET.online_quick()
+        online_now=NET.online_quick()
         if not online_now: NET.kick_async()
         kk = k if k is not None else self.retrieval_k
-        temp = temperature if temperature is not None else self.decoding_temperature
+        temp = temperature if temperature is not None else self.decoding_temperature # type: ignore
 
         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)
+
         intent = self.engine.choose_route(message)
         final_message = message
 
@@ -1363,7 +1348,7 @@ class Hive:
                 final_message = f"Explain how to pronounce the word '{word_to_process}'. Use this phonics hint in your explanation: {phonics_hint}"
         elif prompt_override:
             final_message = f"{prompt_override}\n\nHere is the text to work on:\n{message}"
-            if "review" in prompt_override.lower() or "essay" in prompt_override.lower(): intent = "essay_review" # type: ignore
+            if "review" in prompt_override.lower() or "essay" in prompt_override.lower(): intent = "essay_review"
 
         snippets, scores = self.librarian.retrieve_scoped_with_scores(message, effective_role, caller_id, k=kk)
         cov=coverage_score_from_snippets(snippets, scores)
@@ -1375,7 +1360,7 @@ class Hive:
             except Exception:
                 pass
         prompt=self.compiler.compile(final_message, snippets, token_budget=int(CFG["CTX_TOKENS"]), intent=intent, user_lang=user_lang)
-        _=self.engine.run(message, snippets) # type: ignore
+        _=self.engine.run(message, snippets)
         out=self.pipe(prompt, max_new_tokens=max_new_tokens, do_sample=True, temperature=temp)
         reply=out[0]["generated_text"].strip()
         if CFG["NO_PROFANITY"]:
@@ -1405,12 +1390,20 @@ def launch_ui(bootstrap_instance: "Bootstrap"):
     # Lazily initialize a global Hive instance to be shared across UI callbacks
     HIVE_INSTANCE: Optional[Hive] = None
     def get_hive_instance():
+        """
+        Returns the appropriate Hive instance.
+        If the full instance is ready, returns it.
+        Otherwise, returns the 'lite' instance for immediate chat.
+        """
         nonlocal HIVE_INSTANCE
-        if HIVE_INSTANCE is None:
-            # Wait for the bootstrap process to signal that the hive_instance is ready
-            bootstrap_instance.hive_ready.wait()
-            HIVE_INSTANCE = bootstrap_instance.hive_instance
-            print("[UI] Hive instance attached.")
+        # Check if the full instance is ready without blocking
+        if bootstrap_instance.hive_ready.is_set():
+            if HIVE_INSTANCE is None or HIVE_INSTANCE == bootstrap_instance.hive_lite_instance:
+                HIVE_INSTANCE = bootstrap_instance.hive_instance
+                print("[UI] Full Hive instance attached.")
+        elif HIVE_INSTANCE is None:
+            HIVE_INSTANCE = bootstrap_instance.hive_lite_instance
+            print("[UI] Lite Hive instance attached.")
         return HIVE_INSTANCE
 
     with gr.Blocks(title="Hive 🐝 Full Merged Optimized") as demo:
@@ -1439,12 +1432,12 @@ def launch_ui(bootstrap_instance: "Bootstrap"):
         mode_picker.change(set_mode, [role_state, mode_picker], [mode_state])
 
         with gr.Tab("Hive"):
-            core_status = gr.Markdown("⏳ **Initializing Hive Core...** Chat will be enabled shortly. This may take a few minutes on the first startup.")
+            core_status = gr.Markdown("⏳ **Initializing Full Hive Core...** You can chat with the Lite model now. Advanced features will be enabled shortly.")
             chat=gr.Chatbot(height=420)
-            msg=gr.Textbox(placeholder="Waiting for Hive to be ready...", interactive=False)
+            msg=gr.Textbox(placeholder=f"Talk to {CFG['AGENT_NAME']} (Lite Mode)", interactive=True)
 
             def talk(m, uid, role, mode, hist):
-                hive_instance = get_hive_instance(); lib = hive_instance.librarian
+                hive_instance = get_hive_instance()
                 eff = role if mode=="admin" else "user"
 
                 # --- Tutor Intent Routing ---
@@ -1460,21 +1453,26 @@ def launch_ui(bootstrap_instance: "Bootstrap"):
                 
                 reply=hive_instance.chat(m or "", effective_role=eff, caller_id=uid, prompt_override=prompt_override, max_new_tokens=max_tokens)
 
-                # privacy routing
-                personal = False
-                if re.search(r"\b(my|mine|me|I|our|we)\b", (m or ""), re.I) and re.search(r"\b(password|address|email|phone|ssn|school|kid|medical|bank|card|passport)\b", (m or ""), re.I):
-                    personal = True
-                scope = f"user:{uid}" if (uid and personal) else "general"
-                if lib: lib.ingest_pairs([m or ""],[{"dataset":"chat"}], scope=scope) # type: ignore
+                # In full mode, perform privacy routing and save to memory
+                if not hive_instance.lite_mode:
+                    personal = False
+                    if re.search(r"\b(my|mine|me|I|our|we)\b", (m or ""), re.I) and re.search(r"\b(password|address|email|phone|ssn|school|kid|medical|bank|card|passport)\b", (m or ""), re.I):
+                        personal = True
+                    scope = f"user:{uid}" if (uid and personal) else "general"
+                    if hive_instance.librarian: hive_instance.librarian.ingest_pairs([m or ""],[{"dataset":"chat"}], scope=scope)
                 return hist+[[m, reply]], ""
             msg.submit(talk,[msg,uid_state,role_state,mode_state,chat],[chat,msg])
 
             with gr.Accordion("Tools & Settings", open=False):
                 # This function will run on UI load, wait for the core, and then update the UI.
                 def wait_for_hive_core():
-                    bootstrap_instance.hive_ready.wait() # Block until the core is ready
+                    # This function now just updates the UI when the full core is ready.
+                    bootstrap_instance.hive_ready.wait() 
+                    # Re-fetch instance to ensure it's the full one.
+                    get_hive_instance()
                     ready_placeholder = f"Talk to {CFG['AGENT_NAME']}"
-                    return "✅ **Hive Core is Ready.**", gr.Textbox(interactive=True, placeholder=ready_placeholder)
+                    # The textbox is already interactive, we just update the status and placeholder
+                    return "✅ **Full Hive Core is Ready.**", gr.Textbox(placeholder=ready_placeholder)
                 demo.load(wait_for_hive_core, [], [core_status, msg])
 
                 with gr.Row():
@@ -1756,6 +1754,7 @@ class Bootstrap:
         self.config = config
         self.caps: Optional[Dict] = None
         self.hive_instance: Optional[Hive] = None
+        self.hive_lite_instance: Optional[Hive] = None
         self.hive_ready = threading.Event()
 
     def run(self):
@@ -1764,12 +1763,19 @@ class Bootstrap:
         self.caps = probe_caps()
         print(f"[Bootstrap] System capabilities: {self.caps}")
 
+        # Create a 'lite' instance immediately for basic chat
+        print("[Bootstrap] Initializing Lite Hive core...")
+        self.hive_lite_instance = Hive(lite=True)
+        print("[Bootstrap] Lite Hive core is ready.")
+
         # Launch UI immediately, it will wait for the hive_ready event
         ui_thread = threading.Thread(target=self.launch, daemon=True)
         ui_thread.start()
 
         print("[Bootstrap] Initializing Hive core in background...")
-        self.hive_instance = Hive()
+        # Now initialize the full instance. This is the slow part.
+        self.hive_instance = Hive(lite=False)
+
         self.hive_ready.set() # Signal that the Hive instance is ready
         print("[Bootstrap] Hive core is ready.")
 
@@ -1805,7 +1811,8 @@ class Bootstrap:
             self.run_cli_loop()
 
     def run_cli_loop(self):
-        """Runs a command-line interface loop for Hive."""
+        """Runs a command-line interface loop for Hive. Waits for full init."""
+        self.hive_ready.wait()
         print("Hive is ready. Type a message and press Enter (Ctrl+C to exit).")
         try:
             while True: