Update main.py

main.py

@@ -188,7 +188,7 @@ def generate_narration_task(text, uid, epiphany_id, 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"
+        DEEPGRAM_URL = "https://api.deepgram.com/v1/speak?model=aura-2-theia-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()
@@ -477,17 +477,56 @@ def validate_odysseus_v6(t: dict) -> (bool, str):
 # -----------------------------------------------------------------------------
 
 # -----------------------------------------------------------------------------
-# ODYSSEUS ENGINE V10: THE SOCRATIC INSTRUMENT (DYNAMIC CODE GEN)
+# ODYSSEUS ENGINE V10.1: HARDENED GAME CONSOLE (SYNTAX GUARD + VICTORY HOOKS)
 # -----------------------------------------------------------------------------
 
+# Enhanced Forbidden Patterns to prevent "Unexpected Token" errors in Babel
+FORBIDDEN_CODE_PATTERNS = [
+    r"<!--[\s\S]*?-->",       # No HTML comments (Babel killer)
+    r"\bonclick\b",           # Must be onClick
+    r"\bonmousedown\b",       # Must be onMouseDown
+    r"\bclass=",              # Must be className
+    r"\bfetch\s*\(",          # Security
+    r"\bXMLHttpRequest\b",
+    r"\bWebSocket\b",
+    r"\beval\s*\(",
+    r"\bnew\s+Function\s*\(",
+]
+
+REQUIRED_CODE_PATTERNS = [
+    r"\bexport\s+default\s+Instrument\b",
+    r"props\.onAction",       # Must implement handshake
+    r"props\.onWin"           # Must implement victory
+]
+
+def lint_component_code(code: str) -> (bool, list):
+    """Surgical syntax check for codegen reliability."""
+    errors = []
+    if not isinstance(code, str) or len(code.strip()) < 50:
+        return False, ["component_code missing or too short"]
+
+    for pat in FORBIDDEN_CODE_PATTERNS:
+        if re.search(pat, code, re.IGNORECASE):
+            errors.append(f"Syntax Violation: Found illegal pattern '{pat}'")
+
+    for pat in REQUIRED_CODE_PATTERNS:
+        if not re.search(pat, code):
+            errors.append(f"Protocol Violation: Missing required pattern '{pat}'")
+
+    # Ensure no raw HTML-style comments are present
+    if "<!--" in code or "-->" in code:
+        errors.append("Syntax Error: Use {/* */} for comments in JSX, not <!-- -->")
+
+    return len(errors) == 0, errors
+
 @app.route('/api/trial/generate', methods=['POST'])
 def generate_trial():
     """
-    Odysseus v10: The Self-Repairing Instrumentalist.
-    Generates bespoke Vanilla React components with a 3-pass repair loop.
+    Odysseus v10.1: The Hardened Instrumentalist.
+    Architects bespoke, interactive React games with a 3-pass syntax repair loop.
     Cost: 1 Spark.
     """
-    logger.info(">>> ODYSSEUS V10: GENERATING TRIAL")
+    logger.info(">>> ODYSSEUS V10.1: FORGING HARDENED INSTRUMENT")
     uid = verify_token(request.headers.get('Authorization'))
     if not uid: return jsonify({"error": "Unauthorized"}), 401
 
@@ -507,39 +546,44 @@ def generate_trial():
     if lock_ref.get(): return jsonify({"status": "locked"}), 409
     lock_ref.set({"uid": uid, "at": datetime.utcnow().isoformat()})
 
-    # 3. Context Retrieval
+    # 3. Load Scientific Context
     layer_obj = db_ref.child(f"epiphanies/{ep_id}/layers/{layer_key}").get() or {}
     ctx_text = layer_obj.get("text", "General scientific principles.")
 
-    # 4. Forge & Repair Loop
-    attempts, forged, last_raw = 0, None, ""
+    attempts, forged, last_raw, last_errs = 0, None, "", []
     
     base_prompt = f"""
-    You are Athena's Master Instrumentalist. Forge a tactile scientific Instrument for {subject}.
-    Layer Context: {ctx_text}
+    You are Athena's Master Game Architect. Forge an interactive scientific 'Instrument' for {subject}.
+    Context: {ctx_text}
 
     TASK: Write a React component named 'Instrument'. 
-    REQUIREMENTS:
-    1. Vanilla React ONLY. No external libraries (No Matter.js). Use SVG/Canvas for visuals.
-    2. Tactile: The system must fail/decay if user does nothing.
-    3. Handshake: Must accept and call `props.onAction()` (on touch) and `props.onWin()` (on success).
-    4. Design: Midnight Navy #0B1120, Gold #D4AF37. 
-
-    JSON SCHEMA:
+    This is a GAME that requires user interaction to achieve a scientific victory.
+
+    TECHNICAL CONSTRAINTS (STRICT):
+    1. REACT ONLY: Use React hooks (useState, useEffect, useRef). No external libs. Use SVG/Canvas.
+    2. HANDSHAKE: Component receives `{{ onAction, onWin }}` as props. 
+       - Call `props.onAction()` the moment the user interacts.
+       - Call `props.onWin()` when the specific scientific goal is reached.
+    3. WIN CONDITION: You MUST define a logic state (e.g., matching a frequency) that triggers `onWin()`.
+    4. NO COMMENTS: Do not use HTML comments <!-- -->. Use {{/* */}} if needed.
+    5. CAMELCASE: Use className, onClick, onMouseDown, etc.
+    6. ENTROPY: The system must fail/decay if the user stops interacting.
+
+    JSON OUTPUT SCHEMA:
     {{
-      "engine": "odysseus_v10",
+      "engine": "odysseus_v10.1",
       "instrument_name": "Title",
-      "mission_brief": "Goal",
-      "instrument_manifest": {{ "engine": "odysseus_v10", "interaction": "drag|tap|hold", "win_rule": {{ "type": "zone_dwell" }} }},
+      "mission_brief": "Goal description.",
+      "controls_guide": "Manual: 'Drag the X to the Y', 'Tap the Z to pulse', 'Hold the X until Y'.",
       "component_code": "const Instrument = (props) => {{ ... }}; export default Instrument;",
-      "feynman_truth": "The law proven."
+      "feynman_truth": "Scientific revelation."
     }}
     """
 
     try:
         while attempts < 3 and not forged:
             attempts += 1
-            current_prompt = base_prompt if attempts == 1 else f"REPAIR THIS CODE: {last_raw}\nERRORS: {last_errs}"
+            current_prompt = base_prompt if attempts == 1 else f"REPAIR LOGIC ERROR: {last_errs}\nPREVIOUS CODE: {last_raw}"
             
             res = client.models.generate_content(
                 model=ATHENA_FLASH,
@@ -550,41 +594,43 @@ def generate_trial():
             last_raw = _strip_json_fences(res.text)
             candidate = json.loads(last_raw)
             
-            # Validation logic
-            ok_m, _ = validate_manifest(candidate.get("instrument_manifest"))
-            ok_c, last_errs = lint_component_code(candidate.get("component_code"))
+            # Validation Step
+            code = candidate.get("component_code", "")
+            ok_c, last_errs = lint_component_code(code)
             
-            if ok_m and ok_c:
+            if ok_c:
                 forged = candidate
                 break
+            else:
+                logger.warning(f"Attempt {attempts} failed syntax check: {last_errs}")
 
         if not forged:
             lock_ref.delete()
-            return jsonify({"status": "failed", "reason": "Compilation failure"}), 422
+            return jsonify({"status": "failed", "errors": last_errs}), 422
 
-        # 5. Atomic Credit Deduction (1 Spark)
+        # 4. Atomic Credit Check & Deduction (1 Spark)
         user_ref = db_ref.child(f'users/{uid}')
         def credits_txn(cur):
-            cur = cur or 0
-            return cur - 1 if cur >= 1 else cur
+            if (cur or 0) < 1: return cur
+            return cur - 1
         
-        result = user_ref.child('credits').transaction(credits_txn)
-        if result < 0:
+        updated_credits = user_ref.child('credits').transaction(credits_txn)
+        if updated_credits is None: # Transaction aborted/failed sparks
             lock_ref.delete()
             return jsonify({"error": "Insufficient Sparks"}), 402
 
-        # 6. Finalize
+        # 5. Persist & Return
         forged["createdAt"] = datetime.utcnow().isoformat()
         db_ref.child(trial_path).set(forged)
         lock_ref.delete()
         
-        logger.info(f"Odysseus v10 forged for {subject} in {attempts} attempts.")
+        logger.info(f"Odysseus v10.1 success for {subject} in {attempts} attempt(s).")
         return jsonify(forged), 201
 
     except Exception as e:
         lock_ref.delete()
-        logger.error(f"Forging Global Error: {e}")
-        return jsonify({"error": "The laws of physics failed to compile."}), 500
+        logger.error(f"v10.1 Global Failure: {e}")
+        return jsonify({"error": "The laws of the universe failed to stabilize. Retry."}), 500
 
 # -----------------------------------------------------------------------------
 # 5. THE CHIRON MENTOR & SYSTEM UTILS