Update main.py

main.py

@@ -36,6 +36,7 @@ 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")
@@ -59,8 +60,9 @@ except Exception as e:
 bucket = storage.bucket()
 db_ref = db.reference()
 
+# --- Google GenAI Client Initialization (Gemini 3.0 Ecosystem) ---
 try:
-    logger.info("Initializing Google GenAI Client (Gemini 3.0)...")
+    logger.info("Initializing Google GenAI Client...")
     api_key = os.environ.get("Gemini")
     if not api_key:
         raise ValueError("The 'Gemini' API key is not set.")
@@ -71,11 +73,11 @@ except Exception as e:
     logger.error(f"FATAL: Error initializing GenAI Client: {e}")
     exit(1)
 
-# Corrected Model Constants
+# Model Constants
 ATHENA_FLASH = "gemini-3-flash-preview"
 ATHENA_PRO = "gemini-3-pro-image-preview"
 
-# Grounding API Keys
+# Grounding / External API
 WOLFRAM_APP_ID = os.environ.get("WOLFRAM_APP_ID")
 OPENALEX_MAILTO = os.environ.get("OPENALEX_MAILTO", "rairo@sozofix.tech")
 
@@ -117,33 +119,41 @@ def query_wolfram_alpha(query):
     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 "Constants verifying..."
+        return response.text if response.status_code == 200 else "Fact-check pending..."
     except: return "Grounding in progress."
 
 # -----------------------------------------------------------------------------
-# 3. TITANESS MEDIA ENGINE (AUDIO + INFOGRAPHICS)
+# 3. TITANESS MEDIA ENGINE (PARALLEL BLUEPRINTS & NARRATION)
 # -----------------------------------------------------------------------------
 
 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"
-        return layer_name, upload_to_storage(response.content, path, 'audio/mpeg')
+        url = upload_to_storage(response.content, path, 'audio/mpeg')
+        return layer_name, url
     except Exception as e:
-        logger.error(f"Narration Task Error: {e}")
+        logger.error(f"Narration Task Error [{layer_name}]: {e}")
         return layer_name, None
 
-def generate_blueprint_task(subject, layer_text, uid, epiphany_id, layer_name):
-    """Nano Banana Pro: Generates 4K Technical Blueprints."""
+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
     try:
+        logger.info(f"Thread started: Nano Banana Blueprint for {layer_name}")
         prompt = (
             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."
+            f"Context: {text}. Style: White-line schematic on midnight navy background. 4K quality."
         )
         response = client.models.generate_content(
             model=ATHENA_PRO,
@@ -156,10 +166,11 @@ def generate_blueprint_task(subject, layer_text, uid, epiphany_id, layer_name):
         if image_parts:
             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(image_bytes, path, 'image/png')
+            url = upload_to_storage(image_bytes, path, 'image/png')
+            return layer_name, url
         return layer_name, None
     except Exception as e:
-        logger.error(f"Nano Banana Pro Error [{layer_name}]: {e}")
+        logger.error(f"Nano Banana Pro Task Error [{layer_name}]: {e}")
         return layer_name, None
 
 # -----------------------------------------------------------------------------
@@ -177,37 +188,49 @@ def image_proxy():
 
 @app.route('/api/epiphany/generate', methods=['POST'])
 def generate_epiphany():
-    logger.info(">>> START generate_epiphany")
+    logger.info(">>> START generate_epiphany request")
     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 Synthesis.'}), 402
+        return jsonify({'error': 'Need 4 Sparks for Titaness 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: Rapid ID
+        # Step 1: 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}")
+        logger.info(f"Subject Identified: {subject}")
 
-        # Step 2: Synthesis + Feynman Scholar (Unified Search)
+        # Step 2: Synthesis + Feynman 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. 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 research source, provide Title, URL, and a 2-sentence Feynman Summary. (JSON key: scholar).
+        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.
         
-        Return a JSON OBJECT only.
+        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"}}
+            ]
+        }}
         """
         
         res = client.models.generate_content(
@@ -219,25 +242,37 @@ def generate_epiphany():
             )
         )
         
-        # TYPE-SAFE JSON PARSING
+        # SCHEMA SENTINEL: Robust JSON Parsing
         raw_json = res.text.strip()
-        if raw_json.startswith("```json"):
+        if "```json" in raw_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.")
+        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"]
 
-        epiphany_id = str(uuid.uuid4())
         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."
 
-        # Step 3: Parallel Media (Titaness Execution)
+        epiphany_id = str(uuid.uuid4())
+
+        # 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:
-            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]
+            # Submit 4 Audio Tasks
+            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]
+            
+            # Reassemble Results
             for f in aud_futures: 
                 k, v = f.result()
                 audios[k] = v
@@ -245,7 +280,7 @@ def generate_epiphany():
                 k, v = f.result()
                 blueprints[k] = v
 
-        # Step 4: Storage
+        # Step 4: Storage & Finalization
         image_url = upload_to_storage(image_bytes, f"users/{uid}/epiphanies/{epiphany_id}/vision.jpg", 'image/jpeg')
         epiphany_record = {
             "epiphanyId": epiphany_id,
@@ -255,7 +290,7 @@ def generate_epiphany():
             "imageURL": image_url,
             "layers": {
                 l: {
-                    "text": data[l], 
+                    "text": data.get(l, ""), 
                     "audio": audios.get(l), 
                     "blueprint": blueprints.get(l)
                 } for l in layers
@@ -266,15 +301,17 @@ 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:
-        logger.error(f"Epiphany Gen Error: {e}\n{traceback.format_exc()}")
+        logger.error(f"Global Epiphany Error: {e}\n{traceback.format_exc()}")
         return jsonify({'error': str(e)}), 500
 
 @app.route('/api/epiphany/theia', methods=['POST'])
 def theia_sweep():
-    """Independent Feature: Annotated deconstruction using Code Execution."""
+    """Independent Feature: Theia Mode Annotated deconstruction."""
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
     
@@ -285,7 +322,6 @@ def theia_sweep():
     epiphany_id = request.form.get('epiphanyId')
     image_file = request.files['image']
     
-    # Context fetch
     context = db_ref.child(f'epiphanies/{epiphany_id}').get() or {}
     subject = context.get('subject', 'Complex System')
 
@@ -296,7 +332,7 @@ def theia_sweep():
     1. Label.
     2. Bounding Box [ymin, xmin, ymax, xmax] (0-1000).
     3. 20-word Feynman-style Micro-Epiphany.
-    Return JSON list.
+    Return JSON list ONLY.
     """
 
     try:
@@ -311,7 +347,7 @@ def theia_sweep():
         )
         
         raw_json = res.text.strip()
-        if raw_json.startswith("```json"):
+        if "```json" in raw_json:
             raw_json = re.search(r'```json\n(.*?)\n```', raw_json, re.DOTALL).group(1)
             
         annotations = json.loads(raw_json)
@@ -330,10 +366,10 @@ def deep_dive():
         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 zoom detail.", pil_image]
+            contents=["Feynman style: Explain this zoom detail in 50 words.", pil_image]
         )
         user_ref = db_ref.child(f'users/{uid}')
-        user_ref.update({'credits': max(0, user_ref.get().get('credits', 0) - 1)})
+        user_ref.update({'credits': max(0, (user_ref.get().get('credits', 0) or 0) - 1)})
         return jsonify({"analysis": res.text.strip()}), 200
     except Exception as e: return jsonify({'error': str(e)}), 500
 
@@ -350,7 +386,7 @@ def get_chiron_briefing():
         ctx = "New seeker."
         if last:
             e = list(last.values())[0]
-            ctx = f"Subject: {e['subject']}. Research: {e.get('scholar', [])}"
+            ctx = f"Subject: {e['subject']}. Scholar: {e.get('scholar', [])[:1]}"
         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
@@ -363,10 +399,11 @@ def log_usage():
     data = request.json
     cost = math.ceil(data.get("durationSeconds", 0) / 60) * 3
     user_ref = db_ref.child(f'users/{uid}')
-    user_ref.update({'credits': max(0, (user_ref.get().get('credits', 0)) - cost)})
+    new_bal = max(0, (user_ref.get().get('credits', 0) or 0) - cost)
+    user_ref.update({'credits': new_bal})
     if data.get("transcript"):
         db_ref.child(f'transcripts/{uid}').push({"text": data["transcript"], "at": datetime.utcnow().isoformat()})
-    return jsonify({"success": True})
+    return jsonify({"success": True, "remainingCredits": new_bal})
 
 @app.route('/api/admin/dashboard', methods=['GET'])
 def admin_dashboard():
@@ -431,5 +468,5 @@ def list_epiphanies():
     return jsonify(list(res.values()))
 
 if __name__ == '__main__':
-    logger.info("Titaness Paradigm Server Active...")
+    logger.info("Titaness Final Backbone Active on 7860...")
     app.run(debug=False, host="0.0.0.0", port=7860)