Update app.py

app.py

@@ -1,10 +1,24 @@
-import gradio as gr
-import json, time
+"""
+Jarvis X — Beyond-SOTA Codex Demo
+Fully-contained Gradio app with toy multi-LLM router, constraint engine,
+and audit ledger.
+
+Companions needed in the same directory:
+  • llm_sim.py        – toy LLM provider registry
+  • contracts.dsl     – keyword safety list
+  • requirements.txt  – gradio>=4.0
+"""
+
+import json
+import time
 from pathlib import Path
 from typing import Dict, Any
 
+import gradio as gr
+from llm_sim import LLM_REGISTRY        # <-- toy LLM providers
+
 # ─────────────────────────────────────────────
-#  Λ*  ──  Contract / Safety Engine
+# Λ*  ──  Contract / Safety Engine
 # ─────────────────────────────────────────────
 CONTRACT_FILE = "contracts.dsl"
 
@@ -12,105 +26,107 @@ def load_contracts() -> list[str]:
     path = Path(CONTRACT_FILE)
     if not path.exists():
         return []
-    return [line.strip() for line in path.read_text().splitlines()
-            if line.strip() and not line.startswith("#")]
+    return [ln.strip() for ln in path.read_text().splitlines()
+            if ln.strip() and not ln.startswith("#")]
+
+def contracts_pass(text: str, rules: list[str]) -> bool:
+    return not any(rule.lower() in text.lower() for rule in rules)
 
-def contracts_pass(output: str, contracts: list[str]) -> bool:
-    """Very simple keyword-block demo."""
-    return not any(term.lower() in output.lower() for term in contracts)
+contracts_cache = load_contracts()
 
 # ─────────────────────────────────────────────
-#  Ω  ──  Immutable Audit Ledger
+# Ω  ──  Immutable Audit Ledger
 # ─────────────────────────────────────────────
 LEDGER_FILE = "ledger.jsonl"
 
-def log_event(event: Dict[str, Any]):
+def log_event(ev: Dict[str, Any]):
     with open(LEDGER_FILE, "a", encoding="utf-8") as f:
-        f.write(json.dumps(event) + "\n")
+        f.write(json.dumps(ev) + "\n")
 
 # ─────────────────────────────────────────────
-#  Meta-Learning Placeholder (disabled)
+# Meta state (α weight) — stubbed
 # ─────────────────────────────────────────────
 META_FILE = "meta.json"
-
 def load_meta() -> Dict[str, Any]:
     if Path(META_FILE).exists():
         return json.loads(Path(META_FILE).read_text())
-    return {"alpha": 0.5}          # α = LLM vs symbolic mix
+    return {"alpha": 0.5}
+
+meta_state = load_meta()   # α weight for LLM vs symbolic
 
 # ─────────────────────────────────────────────
-#  Decision Logic (Hybrid LLM / Symbolic stub)
+# Decision Logic (toy multi-LLM + symbolic blend)
 # ─────────────────────────────────────────────
 def decide(intent: str, context: str, alpha: float) -> str:
-    """Replace with real LLM call if desired."""
-    if "code" in intent.lower():
-        return f"[LLM*{alpha:.2f}] Generated code stub respecting constraints."
-    if "analyze" in intent.lower():
-        return "[Symbolic] Performed bounded system analysis."
-    return "[Explain] Bounded explanatory output."
+    # 1. Pick toy provider based on simple keywords
+    if "advanced" in intent.lower():
+        provider = LLM_REGISTRY["claude"]
+    elif "concise" in intent.lower():
+        provider = LLM_REGISTRY["mistral"]
+    else:
+        provider = LLM_REGISTRY["gpt"]
+
+    # 2. Generate toy LLM response
+    prompt = f"Intent: {intent}\nContext: {context}"
+    llm_out = provider.generate(prompt)
+
+    # 3. Symbolic stub
+    symbolic_out = "(symbolic system stub)"
+
+    # 4. Blend outputs
+    blended = (
+        f"[{provider.name} * {alpha:.2f}] {llm_out}\n"
+        f"[Symbolic * {1-alpha:.2f}] {symbolic_out}"
+    )
+    return blended
 
 # ─────────────────────────────────────────────
-#  Main Operational Engine
+# Gradio Callback
 # ─────────────────────────────────────────────
-contracts_cache = load_contracts()
-meta_state = load_meta()
-
 def codex_run(intent: str, context: str):
-    timestamp = time.time()
+    t = time.time()
     alpha = meta_state.get("alpha", 0.5)
-    decision = decide(intent, context, alpha)
-
-    output = (
-        f"Decision: {decision}\n\n"
-        f"Context:\n{context}\n\n"
-        f"System status: constraints enforced, α={alpha:.2f}"
-    )
+    output = decide(intent, context, alpha)
 
     safe = contracts_pass(output, contracts_cache)
     if not safe:
         output = "Output blocked by contract engine (Λ*)."
 
-    # Audit ledger
+    decision_trace = "provider_mix α={:.2f}".format(alpha)
     log_event({
-        "t": timestamp,
-        "intent": intent,
-        "context": context,
-        "decision": decision,
-        "output": output,
-        "safe": safe
+        "t": t, "intent": intent, "context": context,
+        "decision": decision_trace, "output": output, "safe": safe
     })
 
-    audit_snapshot = json.dumps({
-        "t": timestamp,
-        "intent": intent,
-        "decision": decision,
-        "safe": safe
-    })
-
-    return output, decision, audit_snapshot
+    audit = json.dumps({"t": t, "decision": decision_trace, "safe": safe})
+    return output, decision_trace, audit
 
 # ─────────────────────────────────────────────
-#  Gradio Interface
+# Gradio UI
 # ─────────────────────────────────────────────
-with gr.Blocks(title="Jarvis X – Beyond-SOTA Codex Demo") as demo:
+with gr.Blocks(title="Jarvis X — Beyond-SOTA Codex Demo") as demo:
     gr.Markdown("""
     # 🧠 Jarvis X — Beyond-SOTA Codex Operational Intelligence  
-    **Constraint-aware, auditable decision engine**
+    **Toy multi-LLM router, constraint engine, audit ledger**
 
-    *Edit `contracts.dsl` to modify safety rules.  All events append to `ledger.jsonl`.*
+    *Edit `contracts.dsl` to modify safety keywords.  All runs append to
+    `ledger.jsonl`.  LLMs here are simulated; replace in `llm_sim.py`
+    with real API calls when ready.*
     """)
 
-    intent_in  = gr.Textbox(label="Intent (Ψ)", placeholder="e.g. generate code")
-    ctx_in     = gr.Textbox(label="Context (χ)", lines=4)
-    run_btn    = gr.Button("Run")
+    intent_in = gr.Textbox(label="Intent (Ψ)", placeholder="e.g. generate code, advanced analysis")
+    ctx_in    = gr.Textbox(label="Context (χ)", lines=4)
+    run_btn   = gr.Button("Run")
 
-    out_box    = gr.Textbox(label="System Output (Θ)", lines=6)
-    dec_box    = gr.Textbox(label="Decision Trace", lines=1)
-    audit_box  = gr.Textbox(label="Audit Snapshot", lines=2)
+    out_box   = gr.Textbox(label="System Output (Θ)", lines=6)
+    dec_box   = gr.Textbox(label="Decision Trace", lines=1)
+    audit_box = gr.Textbox(label="Audit Snapshot", lines=2)
 
-    run_btn.click(codex_run,
-                  inputs=[intent_in, ctx_in],
-                  outputs=[out_box, dec_box, audit_box])
+    run_btn.click(
+        fn=codex_run,
+        inputs=[intent_in, ctx_in],
+        outputs=[out_box, dec_box, audit_box]
+    )
 
 if __name__ == "__main__":
     demo.launch()