Update main.py

main.py

@@ -36,7 +36,6 @@ logger = logging.getLogger("SOZO_ATHENA")
 app = Flask(__name__)
 CORS(app)
 
-# --- Firebase Initialization ---
 try:
     logger.info("Initializing Firebase Admin SDK...")
     credentials_json_string = os.environ.get("FIREBASE")
@@ -60,9 +59,8 @@ except Exception as e:
 bucket = storage.bucket()
 db_ref = db.reference()
 
-# --- Google GenAI Client Initialization (Gemini 3.0) ---
 try:
-    logger.info("Initializing Google GenAI Client...")
+    logger.info("Initializing Google GenAI Client (Gemini 3.0)...")
     api_key = os.environ.get("Gemini")
     if not api_key:
         raise ValueError("The 'Gemini' API key is not set.")
@@ -73,22 +71,20 @@ except Exception as e:
     logger.error(f"FATAL: Error initializing GenAI Client: {e}")
     exit(1)
 
-# Model Constants
+# Corrected Model Constants
 ATHENA_FLASH = "gemini-3-flash-preview"
 ATHENA_PRO = "gemini-3-pro-image-preview"
-BRIEFING_MODEL = "gemini-3-flash-preview"
 
-# Grounding / External API
+# Grounding API Keys
 WOLFRAM_APP_ID = os.environ.get("WOLFRAM_APP_ID")
 OPENALEX_MAILTO = os.environ.get("OPENALEX_MAILTO", "rairo@sozofix.tech")
 
 # -----------------------------------------------------------------------------
-# 2. HELPER FUNCTIONS & GROUNDING
+# 2. HELPER FUNCTIONS & AUTH
 # -----------------------------------------------------------------------------
 
 def verify_token(auth_header):
     if not auth_header or not auth_header.startswith('Bearer '):
-        logger.warning("Missing or invalid Authorization header.")
         return None
     token = auth_header.split('Bearer ')[1]
     try:
@@ -113,19 +109,19 @@ def upload_to_storage(data_bytes, destination_blob_name, content_type):
         blob.make_public()
         return blob.public_url
     except Exception as e:
-        logger.error(f"Failed to upload to Firebase Storage: {e}")
+        logger.error(f"Storage Upload Error: {e}")
         return None
 
 def query_wolfram_alpha(query):
-    if not WOLFRAM_APP_ID: return "Grounded in theoretical physics."
+    if not WOLFRAM_APP_ID: return "Grounded in first principles."
     try:
         url = f"http://api.wolframalpha.com/v1/result?appid={WOLFRAM_APP_ID}&i={query}"
         response = requests.get(url, timeout=5)
-        return response.text if response.status_code == 200 else "Fact-checking..."
-    except: return "Grounding context pending."
+        return response.text if response.status_code == 200 else "Constants verifying..."
+    except: return "Grounding in progress."
 
 # -----------------------------------------------------------------------------
-# 3. TITANESS MEDIA ENGINE (PARALLEL BLUEPRINTS & NARRATION)
+# 3. TITANESS MEDIA ENGINE (AUDIO + INFOGRAPHICS)
 # -----------------------------------------------------------------------------
 
 def generate_narration_task(text, uid, epiphany_id, layer_name):
@@ -136,40 +132,38 @@ def generate_narration_task(text, uid, epiphany_id, layer_name):
         headers = {"Authorization": f"Token {api_key}", "Content-Type": "text/plain"}
         response = requests.post(DEEPGRAM_URL, headers=headers, data=text.encode('utf-8'))
         response.raise_for_status()
-        path = f"users/{uid}/epiphanies/{epiphany_id}/narrations/{layer_name}.mp3"
+        path = f"users/{uid}/epiphanies/{epiphany_id}/audio/{layer_name}.mp3"
         return layer_name, upload_to_storage(response.content, path, 'audio/mpeg')
     except Exception as e:
-        logger.error(f"TTS Task Error [{layer_name}]: {e}")
+        logger.error(f"Narration Task Error: {e}")
         return layer_name, None
 
-def generate_blueprint_task(subject, text, uid, epiphany_id, layer_name):
-    """Nano Banana Pro: High-fidelity 4K blueprints."""
+def generate_blueprint_task(subject, layer_text, uid, epiphany_id, layer_name):
+    """Nano Banana Pro: Generates 4K Technical Blueprints."""
     try:
         prompt = (
-            f"Generate a technical 4K blueprint infographic of a {subject}'s {layer_name}. "
-            f"Context: {text}. Style: Leonardo Da Vinci sketch meets modern 4K schematic. "
-            f"Midnight navy background, white-line art. Use Google Search to ensure physical accuracy."
+            f"Generate a technical 4K blueprint infographic of {subject} - {layer_name}. "
+            f"Context: {layer_text}. Style: White-line schematic on midnight navy background. 4K quality."
         )
         response = client.models.generate_content(
             model=ATHENA_PRO,
             contents=prompt,
             config=types.GenerateContentConfig(
-                tools=[{"google_search": {}}],
                 image_config=types.ImageConfig(aspect_ratio="16:9", image_size="4K")
             )
         )
         image_parts = [part for part in response.parts if part.inline_data]
         if image_parts:
-            img_bytes = image_parts[0].inline_data.data
+            image_bytes = image_parts[0].inline_data.data
             path = f"users/{uid}/epiphanies/{epiphany_id}/blueprints/{layer_name}.png"
-            return layer_name, upload_to_storage(img_bytes, path, 'image/png')
+            return layer_name, upload_to_storage(image_bytes, path, 'image/png')
         return layer_name, None
     except Exception as e:
-        logger.error(f"Nano Banana Pro Task Error [{layer_name}]: {e}")
+        logger.error(f"Nano Banana Pro Error [{layer_name}]: {e}")
         return layer_name, None
 
 # -----------------------------------------------------------------------------
-# 4. EPIPHANY & THEIA ENDPOINTS
+# 4. CORE ENDPOINTS (EPIPHANY, THEIA, PROXY)
 # -----------------------------------------------------------------------------
 
 @app.route('/api/image-proxy', methods=['GET'])
@@ -183,7 +177,7 @@ def image_proxy():
 
 @app.route('/api/epiphany/generate', methods=['POST'])
 def generate_epiphany():
-    """Core Epiphany + Feynman Scholar Search."""
+    logger.info(">>> START generate_epiphany")
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
 
@@ -197,23 +191,23 @@ def generate_epiphany():
     pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
 
     try:
-        # Step 1: ID
-        id_prompt = "Identify this object/system precisely. Reply with ONLY the name."
+        # Step 1: Rapid ID
+        id_prompt = "Identify this precisely. Reply with ONLY the name."
         subject = client.models.generate_content(model=ATHENA_FLASH, contents=[id_prompt, pil_image]).text.strip()
-        logger.info(f"Subject: {subject}")
+        logger.info(f"Subject identified: {subject}")
 
-        # Step 2: Feynman Synthesis + Universal Research Search
+        # Step 2: Synthesis + Feynman Scholar (Unified Search)
         physics_fact = query_wolfram_alpha(f"physics laws of {subject}")
         synthesis_prompt = f"""
-        Act as Athena. Analyze '{subject}' grounded in this: {physics_fact}.
+        Act as Athena. Analyze '{subject}' grounded in: {physics_fact}.
         Style: Richard Feynman. Simple analogies, profound scientific truths.
         
         Tasks:
         1. Search the web (ArXiv, Patents, Journals) for 3 diverse sources about {subject} using Google Search.
         2. Create 4 Discovery Layers (JSON keys: title, genesis, scientific_core, engineering_edge, cross_pollination).
-        3. For each of the 3 research sources, provide its URL, Title, and a 2-sentence Feynman Summary.
+        3. For each research source, provide Title, URL, and a 2-sentence Feynman Summary. (JSON key: scholar).
         
-        Return JSON ONLY.
+        Return a JSON OBJECT only.
         """
         
         res = client.models.generate_content(
@@ -225,25 +219,34 @@ def generate_epiphany():
             )
         )
         
-        data = json.loads(res.text)
+        # TYPE-SAFE JSON PARSING
+        raw_json = res.text.strip()
+        if raw_json.startswith("```json"):
+            raw_json = re.search(r'```json\n(.*?)\n```', raw_json, re.DOTALL).group(1)
+        
+        data = json.loads(raw_json)
+        # Fix for "list indices" error: If Gemini returns a list, take the first object
+        if isinstance(data, list):
+            data = data[0]
+            logger.info("Handled JSON List-to-Object conversion.")
+
         epiphany_id = str(uuid.uuid4())
         layers = ['genesis', 'scientific_core', 'engineering_edge', 'cross_pollination']
 
         # Step 3: Parallel Media (Titaness Execution)
-        final_audios = {}
-        final_blueprints = {}
+        audios, blueprints = {}, {}
         with ThreadPoolExecutor(max_workers=8) as executor:
             aud_futures = [executor.submit(generate_narration_task, data[l], uid, epiphany_id, l) for l in layers]
             blu_futures = [executor.submit(generate_blueprint_task, subject, data[l], uid, epiphany_id, l) for l in layers]
             for f in aud_futures: 
                 k, v = f.result()
-                final_audios[k] = v
+                audios[k] = v
             for f in blu_futures: 
                 k, v = f.result()
-                final_blueprints[k] = v
+                blueprints[k] = v
 
         # Step 4: Storage
-        image_url = upload_to_storage(image_bytes, f"users/{uid}/epiphanies/{epiphany_id}/original.jpg", 'image/jpeg')
+        image_url = upload_to_storage(image_bytes, f"users/{uid}/epiphanies/{epiphany_id}/vision.jpg", 'image/jpeg')
         epiphany_record = {
             "epiphanyId": epiphany_id,
             "uid": uid,
@@ -253,11 +256,11 @@ def generate_epiphany():
             "layers": {
                 l: {
                     "text": data[l], 
-                    "audio": final_audios.get(l), 
-                    "blueprint": final_blueprints.get(l)
+                    "audio": audios.get(l), 
+                    "blueprint": blueprints.get(l)
                 } for l in layers
             },
-            "scholar": data.get('scholar_sources', []),
+            "scholar": data.get('scholar', []),
             "createdAt": datetime.utcnow().isoformat()
         }
 
@@ -266,39 +269,34 @@ def generate_epiphany():
         return jsonify(epiphany_record), 201
 
     except Exception as e:
-        logger.error(f"Epiphany Gen Error: {e}")
+        logger.error(f"Epiphany Gen Error: {e}\n{traceback.format_exc()}")
         return jsonify({'error': str(e)}), 500
 
 @app.route('/api/epiphany/theia', methods=['POST'])
 def theia_sweep():
-    """
-    Separate Feature: Theia Mode.
-    Takes an epiphany context and performs an annotated 'Universal Sight Sweep'.
-    """
+    """Independent Feature: Annotated deconstruction using Code Execution."""
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
-
+    
     user_ref = db_ref.child(f'users/{uid}')
     if user_ref.get().get('credits', 0) < 4:
-        return jsonify({'error': 'Need 4 Sparks for Theia Mode.'}), 402
+        return jsonify({'error': 'Need 4 Sparks for Theia Sweep.'}), 402
 
     epiphany_id = request.form.get('epiphanyId')
     image_file = request.files['image']
     
-    # Fetch context from existing epiphany
-    context_data = db_ref.child(f'epiphanies/{epiphany_id}').get() or {}
-    subject = context_data.get('subject', 'Unknown System')
+    # Context fetch
+    context = db_ref.child(f'epiphanies/{epiphany_id}').get() or {}
+    subject = context.get('subject', 'Complex System')
 
     sweep_prompt = f"""
-    Activate Theia Mode for: {subject}.
-    Task: Use Python Code Execution to perform a surgical spatial deconstruction of this image.
-    Identify every functional component.
-    For each component return:
+    Theia Mode Activation: {subject}.
+    Task: Use Python Code Execution for spatial deconstruction.
+    Identify components and for each return:
     1. Label.
     2. Bounding Box [ymin, xmin, ymax, xmax] (0-1000).
-    3. A 20-word Feynman-style 'Micro-Epiphany' about its role.
-    
-    Return JSON list ONLY.
+    3. 20-word Feynman-style Micro-Epiphany.
+    Return JSON list.
     """
 
     try:
@@ -311,11 +309,16 @@ def theia_sweep():
                 response_mime_type='application/json'
             )
         )
-        annotations = json.loads(res.text)
+        
+        raw_json = res.text.strip()
+        if raw_json.startswith("```json"):
+            raw_json = re.search(r'```json\n(.*?)\n```', raw_json, re.DOTALL).group(1)
+            
+        annotations = json.loads(raw_json)
         user_ref.update({'credits': user_ref.get().get('credits', 0) - 4})
         return jsonify({"annotations": annotations}), 200
     except Exception as e:
-        logger.error(f"Theia Mode Error: {e}")
+        logger.error(f"Theia Error: {e}")
         return jsonify({'error': str(e)}), 500
 
 @app.route('/api/epiphany/deep-dive', methods=['POST'])
@@ -327,7 +330,7 @@ def deep_dive():
         pil_image = Image.open(io.BytesIO(image_file.read())).convert('RGB')
         res = client.models.generate_content(
             model=ATHENA_FLASH,
-            contents=["Feynman style: Explain this zoomed-in detail in 50 words.", pil_image]
+            contents=["In 50 words Feynman style, explain this zoom detail.", pil_image]
         )
         user_ref = db_ref.child(f'users/{uid}')
         user_ref.update({'credits': max(0, user_ref.get().get('credits', 0) - 1)})
@@ -335,7 +338,7 @@ def deep_dive():
     except Exception as e: return jsonify({'error': str(e)}), 500
 
 # -----------------------------------------------------------------------------
-# 5. CHIRON, ADMIN & AUTH (NO REGRESSION)
+# 5. CHIRON & SYSTEM UTILS
 # -----------------------------------------------------------------------------
 
 @app.route('/api/user/call-briefing', methods=['GET'])
@@ -344,12 +347,12 @@ def get_chiron_briefing():
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
     try:
         last = db_ref.child('epiphanies').order_by_child('uid').equal_to(uid).limit_to_last(1).get() or {}
-        ctx = "New Seeker."
+        ctx = "New seeker."
         if last:
             e = list(last.values())[0]
-            ctx = f"Subject: {e['subject']}. Recent Research: {e.get('scholar', [])[:1]}"
-        prompt = f"Prep Chiron (Socratic Mentor). Context: {ctx}. 4-sentence brief."
-        res = client.models.generate_content(model=BRIEFING_MODEL, contents=[prompt])
+            ctx = f"Subject: {e['subject']}. Research: {e.get('scholar', [])}"
+        prompt = f"Prep Chiron (Mentor). Context: {ctx}. 4-sentence brief."
+        res = client.models.generate_content(model=ATHENA_FLASH, contents=[prompt])
         return jsonify({"memory_summary": res.text.strip()}), 200
     except Exception as e: return jsonify({'error': str(e)}), 500
 
@@ -360,11 +363,10 @@ def log_usage():
     data = request.json
     cost = math.ceil(data.get("durationSeconds", 0) / 60) * 3
     user_ref = db_ref.child(f'users/{uid}')
-    new_bal = max(0, user_ref.get().get('credits', 0) - cost)
-    user_ref.update({'credits': new_bal})
+    user_ref.update({'credits': max(0, (user_ref.get().get('credits', 0)) - cost)})
     if data.get("transcript"):
         db_ref.child(f'transcripts/{uid}').push({"text": data["transcript"], "at": datetime.utcnow().isoformat()})
-    return jsonify({"success": True, "remainingCredits": new_bal}), 200
+    return jsonify({"success": True})
 
 @app.route('/api/admin/dashboard', methods=['GET'])
 def admin_dashboard():
@@ -391,6 +393,10 @@ def request_sparks():
     db_ref.child('credit_requests').push({"uid": uid, "at": datetime.utcnow().isoformat(), "status": "pending"})
     return jsonify({"success": True})
 
+# -----------------------------------------------------------------------------
+# 6. AUTH & USER PROFILE
+# -----------------------------------------------------------------------------
+
 @app.route('/api/auth/signup', methods=['POST'])
 def signup():
     uid = verify_token(request.headers.get('Authorization'))
@@ -412,7 +418,7 @@ def social_signin():
     return jsonify({'uid': uid, **user_ref.get()}), 200
 
 @app.route('/api/user/profile', methods=['GET'])
-def profile():
+def get_profile():
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
     return jsonify(db_ref.child(f'users/{uid}').get())
@@ -424,10 +430,6 @@ def list_epiphanies():
     res = db_ref.child('epiphanies').order_by_child('uid').equal_to(uid).get() or {}
     return jsonify(list(res.values()))
 
-# -----------------------------------------------------------------------------
-# 8. MAIN EXECUTION
-# -----------------------------------------------------------------------------
-
 if __name__ == '__main__':
-    logger.info("Titaness Final Backbone Active on 7860...")
+    logger.info("Titaness Paradigm Server Active...")
     app.run(debug=False, host="0.0.0.0", port=7860)