Update src/chimera_core.py

src/chimera_core.py

@@ -1,44 +1,43 @@
 import os
 from google import genai
-from openai import OpenAI
+from groq import Groq
 
 class Chimera:
     def __init__(self):
-        # 1. SETUP GEMINI
-        self.gemini_key = os.getenv("GEMINI_API_KEY") or getattr(__import__("config", ignore_missing_imports=True), "API_KEY", None)
+        # 1. SETUP GEMINI (The Router & Drafter)
+        self.gemini_key = os.getenv("GEMINI_API_KEY")
         self.gemini_client = None
         if self.gemini_key:
             try:
                 self.gemini_client = genai.Client(api_key=self.gemini_key)
                 self.gemini_model = "gemini-2.5-flash"
-                print(f"🦁 Gemini: ONLINE [{self.gemini_model}]")
+                print(f"🦁 Gemini: ONLINE")
             except Exception as e:
                 print(f"⚠️ Gemini Init Failed: {e}")
 
-        # 2. SETUP GPT-4o
-        self.openai_key = os.getenv("OPENAI_API_KEY")
-        self.openai_client = None
-        if self.openai_key:
+        # 2. SETUP GROQ (The Speed Refiner - Llama 3.3)
+        self.groq_key = os.getenv("GROQ_API_KEY")
+        self.groq_client = None
+        if self.groq_key:
             try:
-                self.openai_client = OpenAI(api_key=self.openai_key)
-                print("🟢 OpenAI: ONLINE [gpt-4o]")
+                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"⚠️ OpenAI Init Failed: {e}")
+                print(f"⚠️ Groq Init Failed: {e}")
 
     def _call_gemini(self, prompt, system_msg="You are a helpful AI."):
-        """ Helper to safely call Gemini """
-        if not self.gemini_client: raise Exception("Gemini Client missing")
+        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_openai(self, prompt, system_msg="You are a helpful AI."):
-        """ Helper to safely call OpenAI """
-        if not self.openai_client: raise Exception("OpenAI Client missing")
-        response = self.openai_client.chat.completions.create(
-            model="gpt-4o",
+    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}
@@ -46,80 +45,79 @@ class Chimera:
         )
         return response.choices[0].message.content
 
-    def _pipeline_code(self, user_prompt):
+    def _binary_pipeline(self, user_prompt):
         """
-        Robust Dual-Core Pipeline:
-        1. Try Gemini Draft -> GPT Refine.
-        2. If GPT fails -> Return Gemini Draft.
-        3. If Gemini fails -> Ask GPT to do it all.
+        THE BINARY STAR PIPELINE:
+        Phase 1: Gemini Drafts (Creative/Logic)
+        Phase 2: Groq Refines (Optimization/Speed)
         """
         draft_code = ""
         
-        # --- PHASE 1: DRAFTING (Prefer Gemini) ---
+        # --- PHASE 1: DRAFTING (Gemini) ---
         try:
             print("   ↳ Phase 1: Gemini Drafting...")
-            draft_code = self._call_gemini(user_prompt, "Write a Python solution. Be verbose.")
+            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, ask GPT to do the whole job
+            # FALLBACK: If Gemini dies, Groq does it all
             try:
-                print("   ↳ ⚠️ Fallback: Switching to OpenAI for full task...")
-                return self._call_openai(user_prompt, "You are an expert Python Coder. Write a robust solution."), "ASM (OpenAI Backup)"
+                return self._call_groq(user_prompt, "You are an expert Python Coder."), "ASM (Groq Backup)"
             except Exception as e2:
-                 return f"❌ CRITICAL: Both models failed. Gemini error: {e}. OpenAI error: {e2}.", "ERROR"
+                 return f"❌ CRITICAL: All models failed.", "ERROR"
 
-        # --- PHASE 2: REFINEMENT (Prefer OpenAI) ---
+        # --- PHASE 2: REFINEMENT (Groq) ---
         try:
-            print("   ↳ Phase 2: GPT-4o Refining...")
-            refine_prompt = f"Refine this code for production:\n\n{draft_code}"
-            final_code = self._call_openai(refine_prompt, "You are a Senior Engineer. Fix bugs and optimize.")
-            return final_code, "ASM (Dual-Core)"
+            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:
-            print(f"⚠️ OpenAI Refine Failed: {e}")
-            # FALLBACK: If OpenAI dies, just return the Gemini draft
-            return f"{draft_code}\n\n**[⚠️ Note: OpenAI refinement failed. Showing Gemini Draft.]**", "ASM (Gemini Draft)"
+            # Fallback: Just show the draft if Groq fails
+            return f"{draft_code}\n\n**[⚠️ Groq Refine Failed. Showing Gemini Draft]**", "ASM (Gemini Draft)"
 
     def _route_task(self, prompt):
-        """ Tries to route using Gemini, falls back to OpenAI, defaults to CHAT. """
-        routing_prompt = "Classify: [ASM] (Code), [SFE] (Science), [CSM] (Story), [CHAT]. Reply TAG only."
-        
-        # Try Gemini Router
-        try:
-            return self._call_gemini(prompt, routing_prompt).strip().replace("[", "").replace("]", "")
-        except:
-            # Try OpenAI Router
-            try:
-                return self._call_openai(prompt, routing_prompt).strip().replace("[", "").replace("]", "")
-            except:
-                return "CHAT" # Default if router is dead
+        # 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"
 
     def process_request(self, user_message, history, manual_role="Auto"):
-        # 1. ROUTING
+        # 1. Routing
         role = manual_role if manual_role != "Auto" else self._route_task(user_message)
         print(f"👉 Routing to: [{role}]")
 
-        # 2. EXECUTE
         try:
             # === CODE PATH (ASM) ===
-            if role == "ASM":
-                return self._pipeline_code(user_message)
-
-            # === ALL OTHER PATHS (SFE/CSM/CHAT) ===
-            system_instruction = "You are a helpful AI."
-            if role == "SFE": system_instruction = "You are a Data Scientist. Be objective."
-            if role == "CSM": system_instruction = "You are a Creative Writer. Be artistic."
+            # 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."
 
-            # Primary Attempt: Gemini (Cheaper/Faster)
+            # Prefer Gemini for creative/long context
             try:
                 return self._call_gemini(user_message, system_instruction), f"{role} (Gemini)"
-            except Exception as e_gem:
-                print(f"⚠️ Gemini Failed: {e_gem}")
-                
-                # Secondary Attempt: OpenAI
+            except:
+                # Fallback to Groq
                 try:
-                    return self._call_openai(user_message, system_instruction), f"{role} (OpenAI Backup)"
-                except Exception as e_gpt:
-                     return "❌ Sorry, model is down right now. (Both API keys failed).", "SYSTEM OUTAGE"
+                    return self._call_groq(user_message, system_instruction), f"{role} (Groq)"
+                except:
+                    return "❌ All systems down.", "OUTAGE"
 
         except Exception as e:
             return f"❌ System Error: {str(e)}", "ERR"