Update main.py

main.py

@@ -60,7 +60,7 @@ except Exception as e:
 bucket = storage.bucket()
 db_ref = db.reference()
 
-# --- Google GenAI Client Initialization (Gemini 3.0 Ecosystem) ---
+# --- Google GenAI Client Initialization (Gemini 3.0) ---
 try:
     logger.info("Initializing Google GenAI Client...")
     api_key = os.environ.get("Gemini")
@@ -79,10 +79,9 @@ 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 & AUTH
+# 2. HELPER FUNCTIONS & GROUNDING
 # -----------------------------------------------------------------------------
 
 def verify_token(auth_header):
@@ -111,7 +110,7 @@ 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"Storage Upload Error: {e}")
+        logger.error(f"Failed to upload to Firebase Storage: {e}")
         return None
 
 def query_wolfram_alpha(query):
@@ -123,55 +122,61 @@ def query_wolfram_alpha(query):
     except: return "Grounding in progress."
 
 # -----------------------------------------------------------------------------
-# 3. TITANESS MEDIA ENGINE (PARALLEL BLUEPRINTS & NARRATION)
+# 3. TITANESS MEDIA ENGINE (CONSOLIDATED MASTER BLUEPRINT)
 # -----------------------------------------------------------------------------
 
 def generate_narration_task(text, uid, epiphany_id, layer_name):
-    """Async task for Deepgram Athena Voice generation."""
     if not text: return layer_name, None
     try:
-        logger.info(f"Thread started: Narration for {layer_name}")
         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"
-        url = upload_to_storage(response.content, path, 'audio/mpeg')
-        return layer_name, url
+        return layer_name, upload_to_storage(response.content, path, 'audio/mpeg')
     except Exception as e:
-        logger.error(f"Narration Task Error [{layer_name}]: {e}")
+        logger.error(f"TTS Task Error [{layer_name}]: {e}")
         return layer_name, None
 
-def generate_blueprint_task(subject, text, uid, epiphany_id, layer_name):
-    """Async task for Nano Banana Pro technical blueprint generation."""
-    if not text: 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."""
     try:
-        logger.info(f"Thread started: Nano Banana Blueprint for {layer_name}")
+        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]}..."
+        )
+        
         prompt = (
-            f"Generate a technical 4K blueprint infographic of {subject} - {layer_name}. "
-            f"Context: {text}. Style: White-line schematic on midnight navy background. 4K quality."
+            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."
         )
+        
         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:
             image_bytes = image_parts[0].inline_data.data
-            path = f"users/{uid}/epiphanies/{epiphany_id}/blueprints/{layer_name}.png"
-            url = upload_to_storage(image_bytes, path, 'image/png')
-            return layer_name, url
-        return layer_name, None
+            path = f"users/{uid}/epiphanies/{epiphany_id}/master_blueprint.png"
+            return upload_to_storage(image_bytes, path, 'image/png')
+        return None
     except Exception as e:
-        logger.error(f"Nano Banana Pro Task Error [{layer_name}]: {e}")
-        return layer_name, None
+        logger.error(f"Master Blueprint Error: {e}")
+        return None
 
 # -----------------------------------------------------------------------------
 # 4. CORE ENDPOINTS (EPIPHANY, THEIA, PROXY)
@@ -188,49 +193,33 @@ def image_proxy():
 
 @app.route('/api/epiphany/generate', methods=['POST'])
 def generate_epiphany():
-    logger.info(">>> START generate_epiphany request")
+    logger.info(">>> START Titaness generate_epiphany")
     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()
-    
-    # 4 Sparks for Synthesis + Research + Blueprints
     if not user_data or user_data.get('credits', 0) < 4:
-        return jsonify({'error': 'Need 4 Sparks for Titaness Synthesis.'}), 402
+        return jsonify({'error': 'Need 4 Sparks for Synthesis.'}), 402
 
     image_file = request.files['image']
     image_bytes = image_file.read()
     pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
 
     try:
-        # Step 1: ID
+        # 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 Identified: {subject}")
 
-        # Step 2: Synthesis + Feynman Scholar Search
+        # Step 2: Synthesis + Universal 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. Simple analogies, profound scientific truths.
-        
-        Tasks:
-        1. Search for 3 diverse sources (ArXiv, Patents, Journals) about {subject} using Google Search.
-        2. Create 4 Discovery Layers.
-        3. For each research source, provide Title, URL, and a 2-sentence Feynman Summary.
-        
-        MANDATORY JSON SCHEMA (NO NESTING):
-        {{
-            "title": "string",
-            "genesis": "string",
-            "scientific_core": "string",
-            "engineering_edge": "string",
-            "cross_pollination": "string",
-            "scholar": [
-                {{"title": "string", "url": "string", "feynman_summary": "string"}}
-            ]
-        }}
+        Style: Richard Feynman.
+        Tasks: 
+        1. Search web for 3 sources (URL, Title, 2-sentence Feynman Summary).
+        2. Create 4 Discovery Layers (genesis, scientific_core, engineering_edge, cross_pollination).
+        Return JSON Object ONLY.
         """
         
         res = client.models.generate_content(
@@ -242,58 +231,38 @@ def generate_epiphany():
             )
         )
         
-        # SCHEMA SENTINEL: Robust JSON Parsing
+        # Schema 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)
-        
+        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
-        if "epiphany" in data: data = data["epiphany"]
-        elif "discovery_layers" in data: data = data["discovery_layers"]
-
-        layers = ['genesis', 'scientific_core', 'engineering_edge', 'cross_pollination']
-        # Verification to avoid KeyError
-        for l in layers:
-            if l not in data:
-                logger.warning(f"AI omitted key '{l}'. Adding placeholder.")
-                data[l] = f"The details of the {l.replace('_', ' ')} are unfolding."
-
         epiphany_id = str(uuid.uuid4())
+        layers = ['genesis', 'scientific_core', 'engineering_edge', 'cross_pollination']
 
-        # Step 3: PARALLEL MEDIA ENGINE (The Async Core)
-        logger.info(f"Step 3: Launching 8 media threads for {epiphany_id}...")
-        audios, blueprints = {}, {}
-        with ThreadPoolExecutor(max_workers=8) as executor:
-            # Submit 4 Audio Tasks
+        # Step 3: Parallel Media (4 Audios + 1 Master Blueprint)
+        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]
-            # Submit 4 Blueprint Tasks
-            blu_futures = [executor.submit(generate_blueprint_task, subject, data.get(l), uid, epiphany_id, l) for l in layers]
+            blu_future = executor.submit(generate_master_blueprint_task, subject, data, uid, epiphany_id)
             
-            # Reassemble Results
-            for f in aud_futures: 
+            for f in aud_futures:
                 k, v = f.result()
                 audios[k] = v
-            for f in blu_futures: 
-                k, v = f.result()
-                blueprints[k] = v
+            master_blueprint_url = blu_future.result()
 
-        # Step 4: Storage & Finalization
-        image_url = upload_to_storage(image_bytes, f"users/{uid}/epiphanies/{epiphany_id}/vision.jpg", 'image/jpeg')
+        # Step 4: Storage
+        orig_url = upload_to_storage(image_bytes, f"users/{uid}/epiphanies/{epiphany_id}/vision.jpg", 'image/jpeg')
         epiphany_record = {
             "epiphanyId": epiphany_id,
             "uid": uid,
             "title": data.get('title', 'System Epiphany'),
             "subject": subject,
-            "imageURL": image_url,
+            "imageURL": orig_url,
+            "masterBlueprint": master_blueprint_url,
             "layers": {
-                l: {
-                    "text": data.get(l, ""), 
-                    "audio": audios.get(l), 
-                    "blueprint": blueprints.get(l)
-                } for l in layers
+                l: {"text": data.get(l, ""), "audio": audios.get(l)} for l in layers
             },
             "scholar": data.get('scholar', []),
             "createdAt": datetime.utcnow().isoformat()
@@ -301,8 +270,6 @@ def generate_epiphany():
 
         db_ref.child(f'epiphanies/{epiphany_id}').set(epiphany_record)
         user_ref.update({'credits': user_data.get('credits', 0) - 4})
-        logger.info(f"TITANESS SUCCESS: {epiphany_id}")
-
         return jsonify(epiphany_record), 201
 
     except Exception as e:
@@ -311,7 +278,6 @@ def generate_epiphany():
 
 @app.route('/api/epiphany/theia', methods=['POST'])
 def theia_sweep():
-    """Independent Feature: Theia Mode Annotated deconstruction."""
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
     
@@ -321,19 +287,10 @@ def theia_sweep():
 
     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}.
-    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. 20-word Feynman-style Micro-Epiphany.
-    Return JSON list ONLY.
-    """
+    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."
 
     try:
         pil_image = Image.open(io.BytesIO(image_file.read())).convert('RGB')
@@ -345,11 +302,8 @@ def theia_sweep():
                 response_mime_type='application/json'
             )
         )
-        
         raw_json = res.text.strip()
-        if "```json" in raw_json:
-            raw_json = re.search(r'```json\n(.*?)\n```', raw_json, re.DOTALL).group(1)
-            
+        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
@@ -364,10 +318,7 @@ 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=["Feynman style: Explain this zoom detail in 50 words.", pil_image]
-        )
+        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)})
         return jsonify({"analysis": res.text.strip()}), 200
@@ -386,8 +337,8 @@ def get_chiron_briefing():
         ctx = "New seeker."
         if last:
             e = list(last.values())[0]
-            ctx = f"Subject: {e['subject']}. Scholar: {e.get('scholar', [])[:1]}"
-        prompt = f"Prep Chiron (Mentor). Context: {ctx}. 4-sentence brief."
+            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=ATHENA_FLASH, contents=[prompt])
         return jsonify({"memory_summary": res.text.strip()}), 200
     except Exception as e: return jsonify({'error': str(e)}), 500
@@ -431,7 +382,7 @@ def request_sparks():
     return jsonify({"success": True})
 
 # -----------------------------------------------------------------------------
-# 6. AUTH & USER PROFILE
+# 6. AUTH & PROFILE
 # -----------------------------------------------------------------------------
 
 @app.route('/api/auth/signup', methods=['POST'])
@@ -455,7 +406,7 @@ def social_signin():
     return jsonify({'uid': uid, **user_ref.get()}), 200
 
 @app.route('/api/user/profile', methods=['GET'])
-def get_profile():
+def 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())
@@ -468,5 +419,5 @@ def list_epiphanies():
     return jsonify(list(res.values()))
 
 if __name__ == '__main__':
-    logger.info("Titaness Final Backbone Active on 7860...")
+    logger.info("Titaness Master Schematic Server Active on 7860...")
     app.run(debug=False, host="0.0.0.0", port=7860)