Update main.py

main.py

@@ -421,6 +421,342 @@ def deep_dive():
     except Exception as e:
         return jsonify({'error': str(e)}), 500
 
+
+# -----------------------------------------------------------------------------
+# ODYSSEUS TRIAL ENGINE: REASONING-BASED GAME GENERATOR (NO FALLBACK)
+# - Generates a Trial once per (epiphanyId, layerKey) and persists it forever
+# - Cache hit returns existing Trial (no re-charge)
+# - If Gemini output can't "compile" into schema: return 422 + store diagnostics
+# - Credits are deducted ONLY after schema validation passes
+# - Uses an RTDB lock (transaction) to avoid double-click / concurrent generation
+# -----------------------------------------------------------------------------
+
+TRIAL_RENDERERS = {"thermal", "electrical", "mechanical", "chemical", "biological"}
+TRIAL_GRAMMARS = {"accumulate", "balance", "transform"}
+
+def _strip_json_fences(s: str) -> str:
+    s = (s or "").strip()
+    if "```" in s:
+        m = re.search(r"```(?:json)?\s*(.*?)\s*```", s, re.DOTALL)
+        if m:
+            return m.group(1).strip()
+    return s
+
+def _is_num(x):
+    return isinstance(x, (int, float)) and not isinstance(x, bool)
+
+def validate_trial_schema(t: dict) -> (bool, str):
+    """
+    Minimal v1 compiler checks (deterministic frontend assumptions):
+    - renderer must be in fixed set (so UI knows which canvas renderer to use)
+    - grammar must be one of three
+    - 1 variable + 1 slider control bound to that variable
+    - win zone + dwell
+    """
+    if not isinstance(t, dict):
+        return False, "trial is not an object"
+
+    engine = t.get("engine")
+    if not isinstance(engine, dict):
+        return False, "engine missing/invalid"
+
+    renderer = t.get("renderer")
+    grammar = t.get("grammar")
+    labels = t.get("labels")
+    logic = t.get("logic")
+
+    if renderer not in TRIAL_RENDERERS:
+        return False, f"renderer must be one of {sorted(TRIAL_RENDERERS)} (got {renderer})"
+    if grammar not in TRIAL_GRAMMARS:
+        return False, f"grammar must be one of {sorted(TRIAL_GRAMMARS)} (got {grammar})"
+
+    if not isinstance(labels, dict):
+        return False, "labels missing/invalid"
+    if not isinstance(labels.get("title"), str) or len(labels["title"].strip()) < 2:
+        return False, "labels.title missing/invalid"
+    if not isinstance(labels.get("goal"), str) or len(labels["goal"].strip()) < 3:
+        return False, "labels.goal missing/invalid"
+    if not isinstance(labels.get("controls"), list) or len(labels["controls"]) < 1:
+        return False, "labels.controls missing/invalid"
+
+    if not isinstance(logic, dict):
+        return False, "logic missing/invalid"
+
+    variables = logic.get("variables")
+    controls = logic.get("controls")
+    win = logic.get("win")
+    fail = logic.get("fail")
+
+    if not isinstance(variables, list) or len(variables) != 1:
+        return False, "logic.variables must be a list of exactly 1 variable for v1"
+    if not isinstance(controls, list) or len(controls) != 1:
+        return False, "logic.controls must be a list of exactly 1 control for v1"
+    if not isinstance(win, dict):
+        return False, "logic.win missing/invalid"
+    if not isinstance(fail, dict):
+        return False, "logic.fail missing/invalid"
+
+    v = variables[0]
+    if not isinstance(v, dict):
+        return False, "variable[0] invalid"
+    for k in ("id", "label", "min", "max", "start"):
+        if k not in v:
+            return False, f"variable[0].{k} missing"
+    if not isinstance(v["id"], str) or not v["id"].strip():
+        return False, "variable[0].id invalid"
+    if not isinstance(v["label"], str) or len(v["label"].strip()) < 2:
+        return False, "variable[0].label invalid"
+    if not _is_num(v["min"]) or not _is_num(v["max"]) or not _is_num(v["start"]):
+        return False, "variable[0] numeric fields invalid"
+    if v["min"] >= v["max"]:
+        return False, "variable[0] min>=max"
+    if not (v["min"] <= v["start"] <= v["max"]):
+        return False, "variable[0] start out of range"
+
+    c = controls[0]
+    if not isinstance(c, dict):
+        return False, "control[0] invalid"
+    for k in ("id", "label", "type", "min", "max", "step", "binds_to", "gain"):
+        if k not in c:
+            return False, f"control[0].{k} missing"
+    if c.get("type") != "slider":
+        return False, "control[0].type must be 'slider' for v1"
+    if not isinstance(c["label"], str) or len(c["label"].strip()) < 2:
+        return False, "control[0].label invalid"
+    if not _is_num(c["min"]) or not _is_num(c["max"]) or not _is_num(c["step"]) or not _is_num(c["gain"]):
+        return False, "control[0] numeric fields invalid"
+    if c["min"] >= c["max"]:
+        return False, "control[0] min>=max"
+    if c.get("binds_to") != v["id"]:
+        return False, "control[0].binds_to must match variable id"
+
+    if win.get("type") != "zone":
+        return False, "win.type must be 'zone' for v1"
+    if win.get("var") != v["id"]:
+        return False, "win.var must match variable id"
+    if not _is_num(win.get("min")) or not _is_num(win.get("max")):
+        return False, "win.min/win.max invalid"
+    if win["min"] >= win["max"]:
+        return False, "win min>=max"
+    dwell = win.get("dwell_ms", 0)
+    if not _is_num(dwell) or dwell < 0:
+        return False, "win.dwell_ms invalid"
+
+    if not isinstance(fail.get("reason"), str) or len(fail["reason"].strip()) < 3:
+        return False, "fail.reason missing/invalid"
+
+    return True, "ok"
+
+
+@app.route('/api/trial/generate', methods=['POST'])
+def generate_trial():
+    logger.info(">>> ODYSSEUS TRIAL GENERATION INITIATED")
+
+    # 1) AUTH
+    uid = verify_token(request.headers.get('Authorization'))
+    if not uid:
+        return jsonify({"error": "Unauthorized"}), 401
+
+    payload = request.get_json(silent=True) or {}
+    epiphany_id = payload.get("epiphanyId")
+    layer_key = payload.get("layerKey")  # genesis | scientific_core | engineering_edge | cross_pollination
+    subject = payload.get("subject")
+
+    if not all([epiphany_id, layer_key, subject]):
+        return jsonify({"error": "Missing context (epiphanyId, layerKey, subject)."}), 400
+
+    # 2) OWNERSHIP CHECK
+    ep_ref = db_ref.child(f"epiphanies/{epiphany_id}")
+    ep = ep_ref.get() or {}
+    if not ep or ep.get("uid") != uid:
+        return jsonify({"error": "Forbidden: epiphany not found or not owned by user."}), 403
+
+    # 3) CACHE FOREVER
+    trial_path = f"epiphanies/{epiphany_id}/trials/{layer_key}"
+    trial_ref = db_ref.child(trial_path)
+    existing = trial_ref.get()
+    if existing:
+        return jsonify(existing), 200
+
+    # 4) LOCK (atomic via transaction)
+    lock_id = str(uuid.uuid4())
+    lock_path = f"epiphanies/{epiphany_id}/trialLocks/{layer_key}"
+    lock_ref = db.reference(lock_path)
+
+    lock_payload = {"uid": uid, "lockId": lock_id, "at": datetime.utcnow().isoformat()}
+
+    def lock_txn(cur):
+        # If a lock already exists, keep it (do not overwrite)
+        if cur:
+            return cur
+        return lock_payload
+
+    lock_result = lock_ref.transaction(lock_txn)
+    # If someone else already holds the lock, return 409
+    if lock_result and lock_result.get("lockId") != lock_id:
+        return jsonify({
+            "status": "locked",
+            "error": "Trial is being generated. Please retry shortly.",
+            "cooldown_ms": 1200
+        }), 409
+
+    def cleanup_lock_best_effort():
+        try:
+            cur = lock_ref.get()
+            if cur and cur.get("lockId") == lock_id:
+                lock_ref.delete()
+        except Exception:
+            pass
+
+    # 5) GEMINI GENERATION (2 attempts), NO FALLBACK
+    model_name = ATHENA_FLASH
+    attempts = 0
+    raw_outputs = []
+    last_validation_error = None
+    last_exception = None
+
+    trial_prompt = f"""
+You are designing a short, playable scientific Trial for: {subject}
+Layer: {layer_key}
+
+Output JSON ONLY (no markdown).
+
+Rules:
+- Choose a FREE domain_label (any string) describing the concept (e.g., "orbital mechanics", "distillation").
+- Choose renderer from EXACTLY: thermal, mechanical, electrical, chemical, biological
+- Choose grammar from EXACTLY: accumulate, balance, transform
+- Must be solvable in <= 30 seconds.
+- v1 STRICT: 1 variable and 1 slider control.
+
+JSON SCHEMA:
+{{
+  "engine": {{"name":"odysseus","version":"v1"}},
+  "renderer":"thermal|mechanical|electrical|chemical|biological",
+  "domain_label":"free text",
+  "grammar":"accumulate|balance|transform",
+  "labels": {{
+    "title":"Short Title",
+    "goal":"One-line goal",
+    "controls":["Single control label"]
+  }},
+  "logic": {{
+    "variables":[{{"id":"x","label":"Label (include units)","min":number,"max":number,"start":number}}],
+    "controls":[{{"id":"c1","label":"Same as labels.controls[0]","type":"slider","min":number,"max":number,"step":number,"binds_to":"x","gain":number}}],
+    "win":{{"type":"zone","var":"x","min":number,"max":number,"dwell_ms":number}},
+    "fail":{{"type":"out_of_range","reason":"Scientific reason for instability"}},
+    "difficulty": number
+  }},
+  "narrative": {{
+    "on_win":"One sentence insight.",
+    "on_fail":"One sentence failure explanation."
+  }}
+}}
+"""
+
+    try:
+        trial_json = None
+
+        for _ in range(2):
+            attempts += 1
+            try:
+                res = client.models.generate_content(
+                    model=model_name,
+                    contents=trial_prompt,
+                    config=types.GenerateContentConfig(response_mime_type="application/json")
+                )
+                raw = _strip_json_fences(res.text)
+                raw_outputs.append(raw[:2000])  # keep a preview for logging
+
+                candidate = json.loads(raw)
+                candidate["createdAt"] = datetime.utcnow().isoformat()
+
+                ok, why = validate_trial_schema(candidate)
+                if ok:
+                    trial_json = candidate
+                    break
+                last_validation_error = why
+
+            except Exception as e:
+                last_exception = str(e)
+
+        # 6) IF INVALID: LOG FAILURE + RETURN 422 (no charge)
+        if not trial_json:
+            failure_doc = {
+                "status": "failed",
+                "uid": uid,
+                "epiphanyId": epiphany_id,
+                "layerKey": layer_key,
+                "subject": subject,
+                "model": model_name,
+                "attempts": attempts,
+                "validation_error": last_validation_error,
+                "exception": last_exception,
+                "raw_output_preview": raw_outputs[-1] if raw_outputs else None,
+                "at": datetime.utcnow().isoformat()
+            }
+            db_ref.child(f"trial_failures/{uid}/{epiphany_id}/{layer_key}").push(failure_doc)
+
+            cleanup_lock_best_effort()
+            return jsonify({
+                "status": "failed",
+                "epiphanyId": epiphany_id,
+                "layerKey": layer_key,
+                "subject": subject,
+                "reason": "schema_invalid" if last_validation_error else "model_error",
+                "details": {
+                    "validation_error": last_validation_error,
+                    "exception": last_exception,
+                    "attempts": attempts,
+                    "raw_output_preview": raw_outputs[-1] if raw_outputs else None
+                },
+                "next": {"action": "regenerate", "cooldown_ms": 1200}
+            }), 422
+
+        # 7) CHARGE (atomic) ONLY AFTER VALID TRIAL EXISTS
+        credits_ref = db.reference(f"users/{uid}/credits")
+        did_deduct = {"ok": False}
+
+        def credits_txn(cur):
+            cur = cur or 0
+            if cur < 1:
+                return cur
+            did_deduct["ok"] = True
+            return cur - 1
+
+        credits_ref.transaction(credits_txn)
+
+        if not did_deduct["ok"]:
+            cleanup_lock_best_effort()
+            return jsonify({"error": "Insufficient Sparks. (Trial requires 1 spark)"}), 402
+
+        # 8) PERSIST TRIAL FOREVER
+        trial_ref.set(trial_json)
+
+        cleanup_lock_best_effort()
+        logger.info(f"Trial manifested & persisted: {trial_path}")
+        return jsonify(trial_json), 201
+
+    except Exception as e:
+        # Hard failure path (still no fallback)
+        failure_doc = {
+            "status": "failed",
+            "uid": uid,
+            "epiphanyId": epiphany_id,
+            "layerKey": layer_key,
+            "subject": subject,
+            "model": model_name,
+            "attempts": attempts,
+            "validation_error": last_validation_error,
+            "exception": str(e),
+            "raw_output_preview": raw_outputs[-1] if raw_outputs else None,
+            "at": datetime.utcnow().isoformat()
+        }
+        db_ref.child(f"trial_failures/{uid}/{epiphany_id}/{layer_key}").push(failure_doc)
+
+        cleanup_lock_best_effort()
+        logger.error(f"Trial Generation Failure: {e}")
+        return jsonify({"error": "Trial generation failed."}), 500
+
 # -----------------------------------------------------------------------------
 # 5. THE CHIRON MENTOR & SYSTEM UTILS
 # -----------------------------------------------------------------------------