Update main.py

main.py

@@ -62,13 +62,13 @@ 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 Ecosystem)...")
     api_key = os.environ.get("Gemini")
     if not api_key:
         raise ValueError("The 'Gemini' API key is not set.")
     
     client = genai.Client(api_key=api_key)
-    logger.info("Google GenAI (Gemini 3.0) Client initialized successfully.")
+    logger.info("Google GenAI Client initialized successfully.")
 except Exception as e:
     logger.error(f"FATAL: Error initializing GenAI Client: {e}")
     exit(1)
@@ -79,6 +79,7 @@ ATHENA_PRO = "gemini-3-pro-image-preview"
 
 # Grounding / External API
 WOLFRAM_APP_ID = os.environ.get("WOLFRAM_APP_ID")
+OPENALEX_MAILTO = os.environ.get("OPENALEX_MAILTO", "rairo@sozofix.tech")
 
 # -----------------------------------------------------------------------------
 # 2. HELPER FUNCTIONS & GROUNDING
@@ -114,57 +115,55 @@ def upload_to_storage(data_bytes, destination_blob_name, content_type):
         return None
 
 def query_wolfram_alpha(query):
-    if not WOLFRAM_APP_ID: return "Grounded in first principles."
+    if not WOLFRAM_APP_ID: return "Grounded in physical 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-check pending..."
-    except: return "Grounding in progress."
+        return response.text if response.status_code == 200 else "Constants verifying..."
+    except: return "Grounding context pending."
 
 # -----------------------------------------------------------------------------
-# 3. TITANESS MEDIA ENGINE (CONSOLIDATED MASTER BLUEPRINT)
+# 3. TITANESS MEDIA ENGINE (CONSOLIDATED MASTER BLUEPRINT + ASYNC AUDIO)
 # -----------------------------------------------------------------------------
 
 def generate_narration_task(text, uid, epiphany_id, layer_name):
+    """Deepgram Aura-Luna task for Athena's voice."""
     if not text: return layer_name, None
     try:
         api_key = os.environ.get("DEEPGRAM_API_KEY")
         if not api_key: return layer_name, None
+        
         DEEPGRAM_URL = "https://api.deepgram.com/v1/speak?model=aura-luna-en"
         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}/audio/{layer_name}.mp3"
+
+        path = f"users/{uid}/epiphanies/{epiphany_id}/narrations/{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}")
         return layer_name, None
 
-def generate_master_blueprint_task(subject, full_data, uid, epiphany_id):
-    """Generates ONE consolidated 4K Technical Blueprint for all 4 layers."""
+def generate_master_blueprint_task(subject, flattened_data, uid, epiphany_id):
+    """Nano Banana Pro: Generates ONE consolidated 4K Technical Blueprint schematic."""
     try:
         logger.info(f"Generating Master Blueprint for: {subject}")
-        # Combine the 4 layer texts into a single prompt for context
-        summary = (
-            f"Genesis: {full_data['genesis'][:100]}... "
-            f"Core: {full_data['scientific_core'][:100]}... "
-            f"Edge: {full_data['engineering_edge'][:100]}... "
-            f"Future: {full_data['cross_pollination'][:100]}..."
-        )
+        # Build context for the visual
+        context_str = f"Genesis: {flattened_data.get('genesis', '')[:100]}... Core: {flattened_data.get('scientific_core', '')[:100]}..."
         
         prompt = (
-            f"Create a single 4K Master Technical Blueprint for '{subject}'. "
-            f"The image MUST be divided into 4 clear quadrants or a visual sequence: "
-            f"1. The Origin (Genesis), 2. The Physics (Core), 3. The Engineering (Edge), 4. The Future (Cross-Pollination). "
-            f"Context: {summary}. Style: Leonardo Da Vinci sketch meets modern CAD schematic. "
-            f"Midnight navy background, white-line technical art. Professional engineering labels."
+            f"Generate a single high-fidelity 4K Master Technical Blueprint for '{subject}'. "
+            f"Layout: A four-quadrant schematic. Zone 1: Genesis (Origins). Zone 2: Scientific Core (The Physics). "
+            f"Zone 3: Engineering Edge (Design Limits). Zone 4: Cross-Pollination (Future Tech-Tree). "
+            f"Aesthetic: White-line architectural blueprint on midnight navy background. "
+            f"Style: Leonardo Da Vinci meets modern 4K engineering software. High scientific accuracy. "
+            f"Context details: {context_str}"
         )
         
         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")
             )
         )
@@ -175,11 +174,11 @@ def generate_master_blueprint_task(subject, full_data, uid, epiphany_id):
             return upload_to_storage(image_bytes, path, 'image/png')
         return None
     except Exception as e:
-        logger.error(f"Master Blueprint Error: {e}")
+        logger.error(f"Master Blueprint Engine Error: {e}")
         return None
 
 # -----------------------------------------------------------------------------
-# 4. CORE ENDPOINTS (EPIPHANY, THEIA, PROXY)
+# 4. CORE ENDPOINTS (EPIPHANY GENERATION & THEIA)
 # -----------------------------------------------------------------------------
 
 @app.route('/api/image-proxy', methods=['GET'])
@@ -193,33 +192,52 @@ def image_proxy():
 
 @app.route('/api/epiphany/generate', methods=['POST'])
 def generate_epiphany():
-    logger.info(">>> START Titaness generate_epiphany")
+    logger.info(">>> TITANESS GENERATION INITIATED")
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
 
     user_ref = db_ref.child(f'users/{uid}')
     user_data = user_ref.get()
-    if not user_data or user_data.get('credits', 0) < 4:
-        return jsonify({'error': 'Need 4 Sparks for Synthesis.'}), 402
+    
+    # 8 Sparks for Synthesis + Feynman Scholar + Consolidated Master Blueprint
+    if not user_data or user_data.get('credits', 0) < 8:
+        return jsonify({'error': 'Need 8 Sparks for Full Master Synthesis.'}), 402
 
+    if 'image' not in request.files:
+        return jsonify({'error': 'Visual input required.'}), 400
+    
     image_file = request.files['image']
     image_bytes = image_file.read()
     pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
 
     try:
-        # Step 1: Rapid ID
-        id_prompt = "Identify this precisely. Reply with ONLY the name."
+        # Step 1: Precise Identification
+        id_prompt = "Identify this object or system. Reply with ONLY the name (max 5 words)."
         subject = client.models.generate_content(model=ATHENA_FLASH, contents=[id_prompt, pil_image]).text.strip()
+        logger.info(f"Synthesis Subject: {subject}")
 
-        # Step 2: Synthesis + Universal Search
+        # Step 2: Synthesis + Universal Scholar Search
         physics_fact = query_wolfram_alpha(f"physics laws of {subject}")
         synthesis_prompt = f"""
-        Act as Athena. Analyze '{subject}' grounded in: {physics_fact}.
-        Style: Richard Feynman.
-        Tasks: 
-        1. Search web for 3 sources (URL, Title, 2-sentence Feynman Summary).
+        Act as Athena. Reveal the first principles of '{subject}' grounded in: {physics_fact}.
+        Style: Richard Feynman. Simple analogies, profound engineering.
+        
+        Tasks:
+        1. Search the web (ArXiv, Patents, Journals) for 3 diverse sources about {subject} via Google Search.
         2. Create 4 Discovery Layers (genesis, scientific_core, engineering_edge, cross_pollination).
-        Return JSON Object ONLY.
+        3. For each research source, provide URL, Title, and a 2-sentence Feynman Summary.
+        
+        MANDATORY JSON SCHEMA (FLAT):
+        {{
+            "title": "string",
+            "genesis": "string",
+            "scientific_core": "string",
+            "engineering_edge": "string",
+            "cross_pollination": "string",
+            "scholar": [
+                {{"title": "string", "url": "string", "feynman_summary": "string"}}
+            ]
+        }}
         """
         
         res = client.models.generate_content(
@@ -231,45 +249,58 @@ def generate_epiphany():
             )
         )
         
-        # Schema Sentinel
+        # --- DATA FLATTENING SENTINEL ---
         raw_json = res.text.strip()
         if "```json" in raw_json: raw_json = re.search(r'```json\n(.*?)\n```', raw_json, re.DOTALL).group(1)
         data = json.loads(raw_json)
         if isinstance(data, list): data = data[0]
 
+        # Handle nesting variations to prevent KeyErrors
+        if "epiphany" in data: data = data["epiphany"]
+        elif "discovery_layers" in data: data = data["discovery_layers"]
+
+        # Ensure all required keys exist (Prevent 500 errors in threads)
+        required_keys = ['genesis', 'scientific_core', 'engineering_edge', 'cross_pollination']
+        for k in required_keys:
+            if k not in data: data[k] = f"First principles of the {k.replace('_', ' ')} are unfolding."
+
         epiphany_id = str(uuid.uuid4())
-        layers = ['genesis', 'scientific_core', 'engineering_edge', 'cross_pollination']
 
-        # Step 3: Parallel Media (4 Audios + 1 Master Blueprint)
+        # Step 3: Parallel Media (Titaness Execution)
         audios = {}
         master_blueprint_url = None
+        
         with ThreadPoolExecutor(max_workers=5) as executor:
-            aud_futures = [executor.submit(generate_narration_task, data.get(l), uid, epiphany_id, l) for l in layers]
+            # 4 Audio Threads
+            aud_futures = [executor.submit(generate_narration_task, data[l], uid, epiphany_id, l) for l in required_keys]
+            # 1 Master Blueprint Thread
             blu_future = executor.submit(generate_master_blueprint_task, subject, data, uid, epiphany_id)
             
-            for f in aud_futures:
+            for f in aud_futures: 
                 k, v = f.result()
                 audios[k] = v
             master_blueprint_url = blu_future.result()
 
-        # Step 4: Storage
-        orig_url = upload_to_storage(image_bytes, f"users/{uid}/epiphanies/{epiphany_id}/vision.jpg", 'image/jpeg')
+        # Step 4: Storage & Record Persistence
+        image_url = upload_to_storage(image_bytes, f"users/{uid}/epiphanies/{epiphany_id}/original.jpg", 'image/jpeg')
         epiphany_record = {
             "epiphanyId": epiphany_id,
             "uid": uid,
-            "title": data.get('title', 'System Epiphany'),
+            "title": data.get('title', 'Universal Revelation'),
             "subject": subject,
-            "imageURL": orig_url,
+            "imageURL": image_url,
             "masterBlueprint": master_blueprint_url,
             "layers": {
-                l: {"text": data.get(l, ""), "audio": audios.get(l)} for l in layers
+                l: {"text": data[l], "audio": audios.get(l)} for l in required_keys
             },
             "scholar": data.get('scholar', []),
             "createdAt": datetime.utcnow().isoformat()
         }
 
         db_ref.child(f'epiphanies/{epiphany_id}').set(epiphany_record)
-        user_ref.update({'credits': user_data.get('credits', 0) - 4})
+        user_ref.update({'credits': user_data.get('credits', 0) - 8})
+        logger.info(f"TITANESS SUCCESS: {epiphany_id}")
+
         return jsonify(epiphany_record), 201
 
     except Exception as e:
@@ -278,19 +309,26 @@ def generate_epiphany():
 
 @app.route('/api/epiphany/theia', methods=['POST'])
 def theia_sweep():
+    """Independent Theia Mode: Bounding Boxes + Micro-Epiphanies via 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 Sweep.'}), 402
 
     epiphany_id = request.form.get('epiphanyId')
     image_file = request.files['image']
+    
     context = db_ref.child(f'epiphanies/{epiphany_id}').get() or {}
     subject = context.get('subject', 'Complex System')
 
-    sweep_prompt = f"Theia Mode Activation: {subject}. Identify components via Python Code Execution. Return JSON list of annotations: label, coordinates [ymin, xmin, ymax, xmax], and 20-word Feynman Micro-Epiphany."
+    sweep_prompt = f"""
+    Theia Mode Activation: {subject}. 
+    Use Python to spatially deconstruct this image. 
+    Identify every functional component. Return JSON list:
+    [ {{ "label": "string", "coordinates": [ymin, xmin, ymax, xmax], "micro_epiphany": "20-word Feynman summary" }} ]
+    """
 
     try:
         pil_image = Image.open(io.BytesIO(image_file.read())).convert('RGB')
@@ -305,6 +343,7 @@ def theia_sweep():
         raw_json = res.text.strip()
         if "```json" in raw_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:
@@ -318,14 +357,16 @@ def deep_dive():
     image_file = request.files['image']
     try:
         pil_image = Image.open(io.BytesIO(image_file.read())).convert('RGB')
-        res = client.models.generate_content(model=ATHENA_FLASH, contents=["In 50 words Feynman style, explain this detail.", pil_image])
-        user_ref = db_ref.child(f'users/{uid}')
-        user_ref.update({'credits': max(0, (user_ref.get().get('credits', 0) or 0) - 1)})
+        res = client.models.generate_content(
+            model=ATHENA_FLASH,
+            contents=["Feynman style: Explain this zoomed-in detail in 50 words.", pil_image]
+        )
+        db_ref.child(f'users/{uid}/credits').set(max(0, (db_ref.child(f'users/{uid}/credits').get() or 0) - 1))
         return jsonify({"analysis": res.text.strip()}), 200
     except Exception as e: return jsonify({'error': str(e)}), 500
 
 # -----------------------------------------------------------------------------
-# 5. CHIRON & SYSTEM UTILS
+# 5. CHIRON & SYSTEM TOOLS
 # -----------------------------------------------------------------------------
 
 @app.route('/api/user/call-briefing', methods=['GET'])
@@ -334,11 +375,11 @@ 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 = "Exploring new frontiers."
         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."
+            ctx = f"Subject: {e['subject']}. Recent papers: {e.get('scholar', [])[:1]}"
+        prompt = f"Prep Chiron (Mentor). Context: {ctx}. 4-sentence brief for Socratic tutoring."
         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,10 +401,13 @@ def log_usage():
 def admin_dashboard():
     try:
         verify_admin(request.headers.get('Authorization'))
+        users = db_ref.child('users').get() or {}
+        epiphanies = db_ref.child('epiphanies').get() or {}
+        requests = db_ref.child('credit_requests').get() or {}
         return jsonify({
-            "users": len(db_ref.child('users').get() or {}),
-            "epiphanies": len(db_ref.child('epiphanies').get() or {}),
-            "requests": len([r for r in (db_ref.child('credit_requests').get() or {}).values() if r.get('status') == 'pending'])
+            "users": len(users),
+            "epiphanies": len(epiphanies),
+            "pending_spark_requests": len([r for r in requests.values() if r.get('status') == 'pending'])
         })
     except Exception as e: return jsonify({'error': str(e)}), 403
 
@@ -418,6 +462,10 @@ def list_epiphanies():
     res = db_ref.child('epiphanies').order_by_child('uid').equal_to(uid).get() or {}
     return jsonify(list(res.values()))
 
+# -----------------------------------------------------------------------------
+# 7. MAIN EXECUTION
+# -----------------------------------------------------------------------------
+
 if __name__ == '__main__':
-    logger.info("Titaness Master Schematic Server Active on 7860...")
+    logger.info("Titaness Paradigm Paradigm Backbone Active on 7860...")
     app.run(debug=False, host="0.0.0.0", port=7860)