Update main.py

main.py

@@ -8,6 +8,7 @@ import traceback
 import math
 import requests
 import threading
+import logging
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timedelta
 
@@ -19,6 +20,15 @@ from PIL import Image
 from google import genai
 from google.genai import types
 
+# -----------------------------------------------------------------------------
+# 0. LOGGING CONFIGURATION
+# -----------------------------------------------------------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger("SOZO_ATHENA")
+
 # -----------------------------------------------------------------------------
 # 1. CONFIGURATION & INITIALIZATION
 # -----------------------------------------------------------------------------
@@ -28,6 +38,7 @@ CORS(app)
 
 # --- Firebase Initialization ---
 try:
+    logger.info("Initializing Firebase Admin SDK...")
     credentials_json_string = os.environ.get("FIREBASE")
     if not credentials_json_string:
         raise ValueError("The FIREBASE environment variable is not set.")
@@ -41,9 +52,9 @@ try:
         'databaseURL': firebase_db_url,
         'storageBucket': firebase_storage_bucket
     })
-    print("Firebase Admin SDK initialized successfully.")
+    logger.info("Firebase Admin SDK initialized successfully.")
 except Exception as e:
-    print(f"FATAL: Error initializing Firebase: {e}")
+    logger.error(f"FATAL: Error initializing Firebase: {e}")
     exit(1)
 
 bucket = storage.bucket()
@@ -51,14 +62,15 @@ db_ref = db.reference()
 
 # --- Google GenAI Client Initialization (Gemini 3.0 Flash) ---
 try:
+    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.")
     
     client = genai.Client(api_key=api_key)
-    print("Google GenAI (Gemini 3.0) Client initialized successfully.")
+    logger.info("Google GenAI (Gemini 3.0) Client initialized successfully.")
 except Exception as e:
-    print(f"FATAL: Error initializing GenAI Client: {e}")
+    logger.error(f"FATAL: Error initializing GenAI Client: {e}")
     exit(1)
 
 # Model Constants
@@ -74,42 +86,65 @@ OPENALEX_MAILTO = os.environ.get("OPENALEX_MAILTO", "rairo@sozofix.tech")
 # -----------------------------------------------------------------------------
 
 def verify_token(auth_header):
-    if not auth_header or not auth_header.startswith('Bearer '): return None
+    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:
         decoded_token = auth.verify_id_token(token)
         return decoded_token['uid']
-    except: return None
+    except Exception as e:
+        logger.error(f"Token verification failed: {e}")
+        return None
 
 def verify_admin(auth_header):
     uid = verify_token(auth_header)
     if not uid: raise PermissionError('Invalid or missing token')
     user_data = db_ref.child(f'users/{uid}').get()
     if not user_data or not user_data.get('is_admin', False):
+        logger.warning(f"Admin access denied for user: {uid}")
         raise PermissionError('Admin access required')
     return uid
 
 def upload_to_storage(data_bytes, destination_blob_name, content_type):
-    blob = bucket.blob(destination_blob_name)
-    blob.upload_from_string(data_bytes, content_type=content_type)
-    blob.make_public()
-    return blob.public_url
+    try:
+        blob = bucket.blob(destination_blob_name)
+        blob.upload_from_string(data_bytes, content_type=content_type)
+        blob.make_public()
+        return blob.public_url
+    except Exception as e:
+        logger.error(f"Failed to upload to Firebase Storage: {e}")
+        return None
 
 def query_wolfram_alpha(query):
-    if not WOLFRAM_APP_ID: return "Wolfram|Alpha grounding unavailable."
+    logger.info(f"Querying Wolfram Alpha: {query}")
+    if not WOLFRAM_APP_ID: 
+        logger.warning("WOLFRAM_APP_ID missing.")
+        return "Wolfram|Alpha grounding unavailable."
     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 timeout."
+        if response.status_code == 200:
+            logger.info("Wolfram Alpha check successful.")
+            return response.text
+        else:
+            logger.warning(f"Wolfram Alpha returned status {response.status_code}")
+            return "Fact-check pending."
+    except Exception as e:
+        logger.error(f"Wolfram Alpha query failed: {e}")
+        return "Grounding timeout."
 
 def query_openalex(topic):
+    logger.info(f"Querying OpenAlex for topic: {topic}")
     try:
         url = f"https://api.openalex.org/works?search={topic}&mailto={OPENALEX_MAILTO}"
         resp = requests.get(url, timeout=5).json()
         results = resp.get('results', [])
+        logger.info(f"OpenAlex found {len(results)} results.")
         return [{"title": r['title'], "url": r['doi'] or r['id'], "year": r['publication_year']} for r in results[:3]]
-    except: return []
+    except Exception as e:
+        logger.error(f"OpenAlex query failed: {e}")
+        return []
 
 # -----------------------------------------------------------------------------
 # 3. ASYNCHRONOUS VOICE ORCHESTRATION (ATHENA VOICE)
@@ -118,8 +153,11 @@ def query_openalex(topic):
 def generate_single_narration(text, uid, epiphany_id, layer_name):
     """Deepgram Aura-Luna generation for a single layer."""
     try:
+        logger.info(f"Generating TTS for layer: {layer_name}")
         api_key = os.environ.get("DEEPGRAM_API_KEY")
-        if not api_key: return layer_name, None
+        if not api_key:
+            logger.error("DEEPGRAM_API_KEY is not set.")
+            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"}
@@ -129,13 +167,15 @@ def generate_single_narration(text, uid, epiphany_id, layer_name):
 
         audio_path = f"users/{uid}/epiphanies/{epiphany_id}/narrations/{layer_name}.mp3"
         url = upload_to_storage(response.content, audio_path, 'audio/mpeg')
+        logger.info(f"TTS Uploaded: {url}")
         return layer_name, url
     except Exception as e:
-        print(f"TTS Error [{layer_name}]: {e}")
+        logger.error(f"TTS Error [{layer_name}]: {e}")
         return layer_name, None
 
 def generate_all_narrations_async(data_dict, uid, epiphany_id):
     """Uses ThreadPoolExecutor to generate all 4 layers in parallel."""
+    logger.info(f"Starting parallel TTS generation for epiphany: {epiphany_id}")
     layers = ['genesis', 'scientific_core', 'engineering_edge', 'cross_pollination']
     results = {}
     with ThreadPoolExecutor(max_workers=4) as executor:
@@ -151,36 +191,48 @@ def generate_all_narrations_async(data_dict, uid, epiphany_id):
 
 @app.route('/api/epiphany/generate', methods=['POST'])
 def generate_epiphany():
+    logger.info(">>> START generate_epiphany request")
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
 
+    logger.info(f"User validated: {uid}")
     user_ref = db_ref.child(f'users/{uid}')
     user_data = user_ref.get()
+    
     if not user_data or user_data.get('credits', 0) < 1:
+        logger.warning(f"User {uid} has insufficient credits.")
         return jsonify({'error': 'Insufficient sparks for an Epiphany.'}), 402
 
     if 'image' not in request.files:
+        logger.error("No image file provided in request.")
         return jsonify({'error': 'Visual input is required.'}), 400
     
     image_file = request.files['image']
     image_bytes = image_file.read()
-    pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
-
+    
     try:
+        pil_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+        logger.info("Image bytes successfully converted to PIL.")
+
         # Step 1: Rapid Identification
+        logger.info("Step 1: Running Rapid Identification...")
         id_prompt = "Identify this precisely. If biological, include the Latin name. If mechanical, include the inventor if known. Reply with ONLY the name."
-        subject = client.models.generate_content(model=ATHENA_MODEL, contents=[id_prompt, pil_image]).text.strip()
+        id_response = client.models.generate_content(model=ATHENA_MODEL, contents=[id_prompt, pil_image])
+        subject = id_response.text.strip()
+        logger.info(f"Subject Identified: {subject}")
 
         # Step 2: Grounding (Parallel Dispatch)
+        logger.info("Step 2: Grounding Dispatch...")
         physics_fact = query_wolfram_alpha(f"constants of {subject}")
         papers = query_openalex(subject)
 
         # Step 3: Synthesis (Feynman Technique)
+        logger.info("Step 3: Generating Feynman Synthesis JSON...")
         synthesis_prompt = f"""
         Act as Athena, the Systems Synthesizer. Reveal the first principles of '{subject}'.
         Style: Richard Feynman. Simple analogies, profound scientific truths.
         
-        Grounding: {physics_fact}
+        Grounding Context: {physics_fact}
         
         Output JSON:
         {{
@@ -198,26 +250,37 @@ def generate_epiphany():
             config=types.GenerateContentConfig(response_mime_type='application/json')
         )
         
-        data = json.loads(synth_response.text)
+        # Log raw response for debugging 500s
+        raw_text = synth_response.text
+        logger.info(f"Raw Synthesis Response: {raw_text}")
+
+        # Cleaning up markdown code blocks if present
+        if raw_text.startswith("```json"):
+            raw_text = raw_text.replace("```json", "").replace("```", "").strip()
+
+        data = json.loads(raw_text)
         epiphany_id = str(uuid.uuid4())
+        logger.info(f"Epiphany ID generated: {epiphany_id}")
         
-        # Step 4: Parallel Audio Generation (Hackathon Latency Optimization)
+        # Step 4: Parallel Audio Generation
+        logger.info("Step 4: Running Parallel TTS...")
         narration_urls = generate_all_narrations_async(data, uid, epiphany_id)
 
         # Step 5: Persistence
+        logger.info("Step 5: Finalizing record and uploading image...")
         image_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['title'],
+            "title": data.get('title', 'Unknown Discovery'),
             "subject": subject,
             "imageURL": image_url,
             "layers": {
-                "genesis": {"text": data['genesis'], "audio": narration_urls.get('genesis')},
-                "scientific_core": {"text": data['scientific_core'], "audio": narration_urls.get('scientific_core')},
-                "engineering_edge": {"text": data['engineering_edge'], "audio": narration_urls.get('engineering_edge')},
-                "cross_pollination": {"text": data['cross_pollination'], "audio": narration_urls.get('cross_pollination')}
+                "genesis": {"text": data.get('genesis', ''), "audio": narration_urls.get('genesis')},
+                "scientific_core": {"text": data.get('scientific_core', ''), "audio": narration_urls.get('scientific_core')},
+                "engineering_edge": {"text": data.get('engineering_edge', ''), "audio": narration_urls.get('engineering_edge')},
+                "cross_pollination": {"text": data.get('cross_pollination', ''), "audio": narration_urls.get('cross_pollination')}
             },
             "grounding": {"physics": physics_fact, "papers": papers},
             "createdAt": datetime.utcnow().isoformat()
@@ -225,30 +288,37 @@ def generate_epiphany():
 
         db_ref.child(f'epiphanies/{epiphany_id}').set(epiphany_record)
         user_ref.update({'credits': user_data.get('credits', 0) - 1})
+        logger.info(f"EP-GEN SUCCESS: {epiphany_id}")
 
         return jsonify(epiphany_record), 201
 
+    except json.JSONDecodeError as je:
+        logger.error(f"JSON Parsing Error: {je}. Raw output was: {synth_response.text}")
+        return jsonify({'error': 'AI generated invalid JSON. Try again.'}), 500
     except Exception as e:
-        print(traceback.format_exc())
+        logger.error(f"Generate Epiphany Global Error: {e}")
+        logger.error(traceback.format_exc())
         return jsonify({'error': str(e)}), 500
 
 @app.route('/api/epiphany/deep-dive', methods=['POST'])
 def deep_dive():
-    """Zoom-based recursive reasoning."""
+    logger.info(">>> START deep-dive request")
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
 
     image_file = request.files['image']
-    pil_image = Image.open(io.BytesIO(image_file.read())).convert('RGB')
-
-    dive_prompt = "Act as an Engineering Lead. In 50 words, explain the microscopic or mechanical significance of this specific detail."
-    
     try:
+        pil_image = Image.open(io.BytesIO(image_file.read())).convert('RGB')
+        dive_prompt = "Act as an Engineering Lead. In 50 words, explain the microscopic or mechanical significance of this specific detail."
+        
         res = client.models.generate_content(model=ATHENA_MODEL, contents=[dive_prompt, pil_image])
+        logger.info("Deep dive reasoning completed.")
+
         user_ref = db_ref.child(f'users/{uid}')
         user_ref.update({'credits': max(0, user_ref.get().get('credits', 0) - 1)})
         return jsonify({"analysis": res.text.strip()}), 200
     except Exception as e:
+        logger.error(f"Deep Dive Error: {e}")
         return jsonify({'error': str(e)}), 500
 
 # -----------------------------------------------------------------------------
@@ -257,12 +327,11 @@ def deep_dive():
 
 @app.route('/api/user/call-briefing', methods=['GET'])
 def get_chiron_briefing():
-    """Enhanced Briefing: Passes grounding papers to ElevenLabs context."""
+    logger.info(">>> START get_chiron_briefing request")
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
 
     try:
-        # Get last Epiphany for context
         last_epiphany = db_ref.child('epiphanies').order_by_child('uid').equal_to(uid).limit_to_last(1).get() or {}
         
         context_data = ""
@@ -273,6 +342,7 @@ def get_chiron_briefing():
             paper_titles = [p['title'] for p in papers]
             context_data = f"Current focus: {e_data['subject']}. Recent papers unlocked: {', '.join(paper_titles)}."
 
+        logger.info(f"Generating briefing with context: {context_data}")
         brief_prompt = f"""
         Prep Chiron, the Socratic Mentor.
         User Context: {context_data}
@@ -282,10 +352,12 @@ def get_chiron_briefing():
         response = client.models.generate_content(model=BRIEFING_MODEL, contents=[brief_prompt])
         return jsonify({"memory_summary": response.text.strip(), "grounding_context": context_data}), 200
     except Exception as e:
+        logger.error(f"Call Briefing Error: {e}")
         return jsonify({'error': str(e)}), 500
 
 @app.route('/api/log-call-usage', methods=['POST'])
 def log_call_usage():
+    logger.info(">>> START log_call_usage request")
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
 
@@ -294,10 +366,12 @@ def log_call_usage():
     transcript = data.get("transcript", "")
     
     cost = math.ceil(duration / 60) * 3
+    logger.info(f"Call ended for {uid}. Duration: {duration}s, Cost: {cost} sparks.")
     
     try:
         user_ref = db_ref.child(f'users/{uid}')
-        new_bal = max(0, user_ref.get().get('credits', 0) - cost)
+        user_data = user_ref.get()
+        new_bal = max(0, user_data.get('credits', 0) - cost)
         user_ref.update({'credits': new_bal})
 
         if transcript:
@@ -305,8 +379,11 @@ def log_call_usage():
                 "text": transcript,
                 "createdAt": datetime.utcnow().isoformat()
             })
+            logger.info("Transcript saved to database.")
+            
         return jsonify({"success": True, "remainingCredits": new_bal}), 200
     except Exception as e:
+        logger.error(f"Usage Logging Error: {e}")
         return jsonify({'error': str(e)}), 500
 
 # -----------------------------------------------------------------------------
@@ -318,45 +395,39 @@ def submit_feedback():
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
     data = request.get_json()
-    fb_ref = db_ref.child('feedback').push()
-    fb_ref.set({
-        "userId": uid,
-        "message": data.get('message'),
-        "type": data.get('type', 'general'),
-        "status": "open",
-        "createdAt": datetime.utcnow().isoformat()
-    })
-    return jsonify({"success": True}), 201
+    try:
+        fb_ref = db_ref.child('feedback').push()
+        fb_ref.set({
+            "userId": uid,
+            "message": data.get('message'),
+            "type": data.get('type', 'general'),
+            "status": "open",
+            "createdAt": datetime.utcnow().isoformat()
+        })
+        logger.info(f"Feedback received from user {uid}.")
+        return jsonify({"success": True}), 201
+    except Exception as e:
+        logger.error(f"Feedback Submission Error: {e}")
+        return jsonify({'error': str(e)}), 500
 
 @app.route('/api/user/request-credits', methods=['POST'])
 def request_credits():
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
     data = request.get_json()
-    req_ref = db_ref.child('credit_requests').push()
-    req_ref.set({
-        "userId": uid,
-        "requested_amount": data.get('amount', 50),
-        "status": "pending",
-        "createdAt": datetime.utcnow().isoformat()
-    })
-    return jsonify({"success": True}), 201
-
-@app.route('/api/admin/dashboard', methods=['GET'])
-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({
-            "total_users": len(users),
-            "total_epiphanies": len(epiphanies),
-            "pending_requests": len([r for r in requests.values() if r.get('status') == 'pending'])
-        }), 200
+        req_ref = db_ref.child('credit_requests').push()
+        req_ref.set({
+            "userId": uid,
+            "requested_amount": data.get('amount', 50),
+            "status": "pending",
+            "createdAt": datetime.utcnow().isoformat()
+        })
+        logger.info(f"Spark request logged for user {uid}.")
+        return jsonify({"success": True}), 201
     except Exception as e:
-        return jsonify({'error': str(e)}), 403
+        logger.error(f"Credit Request Error: {e}")
+        return jsonify({'error': str(e)}), 500
 
 # -----------------------------------------------------------------------------
 # 7. AUTHENTICATION & PROFILE
@@ -364,11 +435,7 @@ def admin_dashboard():
 
 @app.route('/api/auth/signup', methods=['POST'])
 def signup():
-    """
-    Refined Signup: Handles syncing after the Frontend creates the user.
-    Does not try to re-create the user in Firebase Auth.
-    """
-    # 1. Verify the token sent by the frontend
+    logger.info(">>> START signup sync")
     uid = verify_token(request.headers.get('Authorization'))
     if not uid:
         return jsonify({'error': 'Invalid or expired token'}), 401
@@ -377,30 +444,25 @@ def signup():
         user_ref = db_ref.child(f'users/{uid}')
         user_data = user_ref.get()
 
-        # 2. If user already exists in DB, just return it (avoid error)
         if user_data:
+            logger.info(f"User {uid} already exists, skipping initialization.")
             return jsonify({'uid': uid, **user_data}), 200
 
-        # 3. User is new to the DB, initialize their profile
         data = request.get_json()
-        email = data.get('email')
-        display_name = data.get('displayName', 'Seeker')
-
         new_user_record = {
-            'email': email,
-            'displayName': display_name,
-            'credits': 30,  # Ensure they get their starting Sparks
+            'email': data.get('email'),
+            'displayName': data.get('displayName', 'Seeker'),
+            'credits': 30,
             'is_admin': False,
             'createdAt': datetime.utcnow().isoformat()
         }
         
         user_ref.set(new_user_record)
-        print(f"Successfully initialized Seeker profile for UID: {uid}")
-        
+        logger.info(f"New seeker initialized: {uid} with 30 Sparks.")
         return jsonify({'success': True, 'uid': uid, **new_user_record}), 201
 
     except Exception as e:
-        print(f"Signup Sync Error: {e}")
+        logger.error(f"Signup Sync Error: {e}")
         return jsonify({'error': str(e)}), 400
 
 @app.route('/api/auth/social-signin', methods=['POST'])
@@ -412,6 +474,7 @@ def social_signin():
     user_data = user_ref.get()
 
     if not user_data:
+        logger.info(f"Initializing social user: {uid}")
         firebase_user = auth.get_user(uid)
         user_data = {
             'email': firebase_user.email,
@@ -434,6 +497,7 @@ def get_profile():
 def list_epiphanies():
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({'error': 'Unauthorized'}), 401
+    logger.info(f"Listing epiphanies for user {uid}.")
     results = db_ref.child('epiphanies').order_by_child('uid').equal_to(uid).get() or {}
     return jsonify(list(results.values()))
 
@@ -442,4 +506,6 @@ def list_epiphanies():
 # -----------------------------------------------------------------------------
 
 if __name__ == '__main__':
+    # Standard HF Port 7860
+    logger.info("Starting Sozo Athena Server on port 7860...")
     app.run(debug=False, host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))