Update src/chimera_core.py

src/chimera_core.py

@@ -4,7 +4,7 @@ from groq import Groq
 
 class Chimera:
     def __init__(self):
-        # 1. SETUP GEMINI (The Router & Drafter)
+        # 1. SETUP GEMINI (The Router)
         self.gemini_key = os.getenv("GEMINI_API_KEY")
         self.gemini_client = None
         if self.gemini_key:
@@ -12,112 +12,95 @@ class Chimera:
                 self.gemini_client = genai.Client(api_key=self.gemini_key)
                 self.gemini_model = "gemini-2.5-flash"
                 print(f"🦁 Gemini: ONLINE")
-            except Exception as e:
-                print(f"⚠️ Gemini Init Failed: {e}")
+            except: pass
 
-        # 2. SETUP GROQ (The Speed Refiner - Llama 3.3)
+        # 2. SETUP GROQ (The Factory)
         self.groq_key = os.getenv("GROQ_API_KEY")
         self.groq_client = None
         if self.groq_key:
             try:
                 self.groq_client = Groq(api_key=self.groq_key)
-                self.groq_model = "llama-3.3-70b-versatile"
-                print(f"⚡ Groq (Llama 3.3): ONLINE")
-            except Exception as e:
-                print(f"⚠️ Groq Init Failed: {e}")
+                print(f"⚡ Groq (Llama 3.3 + Qwen 2.5): ONLINE")
+            except: pass
 
-    def _call_gemini(self, prompt, system_msg="You are a helpful AI."):
-        if not self.gemini_client: raise Exception("Gemini Down")
-        response = self.gemini_client.models.generate_content(
-            model=self.gemini_model,
-            contents=f"System: {system_msg}\nUser: {prompt}"
-        )
-        return response.text
-
-    def _call_groq(self, prompt, system_msg="You are a helpful AI."):
-        if not self.groq_client: raise Exception("Groq Down")
-        response = self.groq_client.chat.completions.create(
-            model=self.groq_model,
-            messages=[
-                {"role": "system", "content": system_msg},
-                {"role": "user", "content": prompt}
-            ]
-        )
-        return response.choices[0].message.content
+    def _call_model(self, client, model, prompt, system_msg):
+        """ Generic handler for any model """
+        if not client: return None
+        try:
+            if "gemini" in model:
+                res = client.models.generate_content(
+                    model=model, contents=f"System: {system_msg}\nUser: {prompt}"
+                )
+                return res.text
+            else:
+                # Groq / OpenAI style
+                res = client.chat.completions.create(
+                    model=model,
+                    messages=[
+                        {"role": "system", "content": system_msg},
+                        {"role": "user", "content": prompt}
+                    ]
+                )
+                return res.choices[0].message.content
+        except Exception as e:
+            print(f"⚠️ Error calling {model}: {e}")
+            return None
 
-    def _binary_pipeline(self, user_prompt):
+    def _trinity_pipeline(self, user_prompt):
         """
-        THE BINARY STAR PIPELINE:
-        Phase 1: Gemini Drafts (Creative/Logic)
-        Phase 2: Groq Refines (Optimization/Speed)
+        THE QWEN TRINITY:
+        1. Gemini: Plan (Strategy)
+        2. Qwen 2.5: Code (Draft)
+        3. Llama 3.3: Refine (Polish)
         """
-        draft_code = ""
+        log = []
         
-        # --- PHASE 1: DRAFTING (Gemini) ---
-        try:
-            print("   ↳ Phase 1: Gemini Drafting...")
-            draft_code = self._call_gemini(user_prompt, "Write a Python solution. Be verbose and explanatory.")
-        except Exception as e:
-            print(f"⚠️ Gemini Draft Failed: {e}")
-            # FALLBACK: If Gemini dies, Groq does it all
-            try:
-                return self._call_groq(user_prompt, "You are an expert Python Coder."), "ASM (Groq Backup)"
-            except Exception as e2:
-                 return f"❌ CRITICAL: All models failed.", "ERROR"
+        # --- PHASE 1: STRATEGY (Gemini) ---
+        print("   ↳ Phase 1: Gemini Planning...")
+        strategy = self._call_model(self.gemini_client, "gemini-2.5-flash", user_prompt, "You are a Software Architect. Outline the logic for this code task.")
+        if not strategy: strategy = user_prompt
 
-        # --- PHASE 2: REFINEMENT (Groq) ---
-        try:
-            print("   ↳ Phase 2: Groq Refining...")
-            refine_prompt = f"""
-            You are a Senior Principal Engineer. Refine this Junior Developer's code.
-            
-            GOALS:
-            1. Optimize for speed.
-            2. Fix bugs.
-            3. Clean up comments.
-            
-            DRAFT CODE:
-            {draft_code}
-            """
-            final_code = self._call_groq(refine_prompt, "You are a Senior Engineer.")
-            return final_code, "ASM (Binary Refined)"
-        except Exception as e:
-            # Fallback: Just show the draft if Groq fails
-            return f"{draft_code}\n\n**[⚠️ Groq Refine Failed. Showing Gemini Draft]**", "ASM (Gemini Draft)"
+        # --- PHASE 2: DRAFTING (Qwen 2.5 - The Coder) ---
+        print("   ↳ Phase 2: Qwen Coding...")
+        # Note: Groq model ID for Qwen 2.5 32B
+        qwen_code = self._call_model(self.groq_client, "qwen-2.5-32b", f"Plan: {strategy}\n\nTask: {user_prompt}", "You are an expert Python Developer. Write the code.")
+        
+        if not qwen_code:
+            return "❌ Qwen failed to generate code.", "ERROR"
 
-    def _route_task(self, prompt):
-        # Quick router using Gemini (or Groq if Gemini is down)
-        sys = "Classify: [ASM] (Code), [SFE] (Science), [CSM] (Story), [CHAT]. Reply TAG only."
-        try: return self._call_gemini(prompt, sys).strip().replace("[","").replace("]","")
-        except: 
-            try: return self._call_groq(prompt, sys).strip().replace("[","").replace("]","")
-            except: return "CHAT"
+        # --- PHASE 3: REFINEMENT (Llama 3.3 - The Critic) ---
+        print("   ↳ Phase 3: Llama Refining...")
+        final_code = self._call_model(self.groq_client, "llama-3.3-70b-versatile", f"Refine this code:\n{qwen_code}", "You are a Senior Engineer. Fix bugs, optimize, and add comments.")
+        
+        if final_code:
+            return final_code, "ASM (Qwen + Llama)"
+        else:
+            return qwen_code, "ASM (Qwen Draft)"
 
     def process_request(self, user_message, history, manual_role="Auto"):
-        # 1. Routing
-        role = manual_role if manual_role != "Auto" else self._route_task(user_message)
-        print(f"👉 Routing to: [{role}]")
-
-        try:
-            # === CODE PATH (ASM) ===
-            # If we have both models, use the pipeline.
-            if role == "ASM" and self.groq_client and self.gemini_client:
-                return self._binary_pipeline(user_message)
-            
-            # === SINGLE MODEL PATHS ===
-            system_instruction = "You are Project Chimera."
-            if role == "SFE": system_instruction = "You are a Data Scientist."
-            if role == "CSM": system_instruction = "You are a Creative Writer."
+        # Router logic
+        role = manual_role
+        if role == "Auto":
+            # Simple keyword check for speed
+            if any(x in user_message.lower() for x in ["code", "python", "function", "script", "app"]):
+                role = "ASM"
+            else:
+                role = "CHAT"
 
-            # Prefer Gemini for creative/long context
-            try:
-                return self._call_gemini(user_message, system_instruction), f"{role} (Gemini)"
-            except:
-                # Fallback to Groq
-                try:
-                    return self._call_groq(user_message, system_instruction), f"{role} (Groq)"
-                except:
-                    return "❌ All systems down.", "OUTAGE"
+        print(f"👉 Routing to: [{role}]")
 
-        except Exception as e:
-            return f"❌ System Error: {str(e)}", "ERR"
+        # Execute
+        if role == "ASM" and self.groq_client:
+            return self._trinity_pipeline(user_message)
+        
+        elif role == "SFE":
+            # Use Llama for Science
+            return self._call_model(self.groq_client, "llama-3.3-70b-versatile", user_message, "You are a Scientist."), "SFE (Llama)"
+        
+        elif role == "CSM":
+            # Use Gemini for Stories
+            return self._call_model(self.gemini_client, "gemini-2.5-flash", user_message, "You are a Creative Writer."), "CSM (Gemini)"
+        
+        else:
+            # Default Chat (Gemini)
+            return self._call_model(self.gemini_client, "gemini-2.5-flash", user_message, "You are Chimera."), "CHAT"