Update app.py

app.py

@@ -10,7 +10,8 @@ Architecture:
 """
 
 import os, time, threading, json, re, textwrap, copy
-import traceback, html, itertools, math
+import traceback, html
+import requests
 from collections import deque, defaultdict
 from typing import Dict, List, Tuple, Any, Optional, Set
 from dataclasses import dataclass, field
@@ -159,7 +160,6 @@ def build_core_problem(axl_def: AXLProblemDef) -> core.Problem:
     var_names = list(bounds.keys())
     compiled_constraints = []
     
-    # Bug 2 Fix: Safe, mathematically accurate EQ/GEQ/LEQ kinds translation
     kind_map = {'EQ': 'equality', 'GEQ': 'inequality', 'LEQ': 'inequality'}
     dir_map  = {'EQ': 'eq',       'GEQ': 'geq',        'LEQ': 'leq'}
     
@@ -176,20 +176,68 @@ def build_core_problem(axl_def: AXLProblemDef) -> core.Problem:
     return prob
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 3: LLM BRIDGE
+# SECTION 3: EXTERNAL / INTERNAL LLM BRIDGE
 # ══════════════════════════════════════════════════════════════════════
-def encode_problem(text: str, api_key: str) -> AXLProblemDef:
-    client = genai.Client(api_key=api_key)
-    config = types.GenerateContentConfig(
-        system_instruction=[types.Part.from_text(text=oracle.ENCODER_PROMPT)],
-        response_mime_type="application/json", temperature=0.1)
-    resp = client.models.generate_content(
-        model=GEMINI_MODEL,
-        contents=[types.Content(role="user", parts=[types.Part.from_text(text=text)])],
-        config=config)
-    
-    raw = resp.text.strip()
+
+def call_external_ai(url: str, model: str, system_prompt: str, prompt: str) -> str:
+    """Interfaces with the external Express.js server."""
+    url = url.rstrip("/")
+    try:
+        # 1. Create chat
+        res = requests.post(f"{url}/api/chats", timeout=10)
+        res.raise_for_status()
+        chat_id = res.json()["id"]
+
+        # 2. Trigger stream & wait for completion
+        payload = {"model": model, "prompt": prompt, "system_prompt": system_prompt}
+        stream_res = requests.post(f"{url}/api/chats/{chat_id}/stream", json=payload, stream=True, timeout=180)
+        stream_res.raise_for_status()
+        for _ in stream_res.iter_content(chunk_size=8192):
+            pass  # Exhaust stream
+
+        # 3. Fetch clean chat object from DB
+        chat_res = requests.get(f"{url}/api/chats/{chat_id}", timeout=10)
+        chat_res.raise_for_status()
+        chat_data = chat_res.json()
+
+        # 4. Clean up (delete chat politely)
+        try:
+            requests.delete(f"{url}/api/chats/{chat_id}", timeout=10)
+        except:
+            pass
+
+        # 5. Extract final message content
+        messages = chat_data.get("messages", [])
+        if not messages: raise ValueError("No messages returned from external AI")
+        
+        last_msg = messages[-1]
+        if last_msg.get("role") != "assistant": raise ValueError("Last message is not from assistant")
+            
+        return last_msg.get("content", "")
+        
+    except Exception as e:
+        raise RuntimeError(f"External AI Call Failed: {str(e)}")
+
+
+def encode_problem(text: str, api_key: str, use_ext: bool, ext_url: str, ext_model: str) -> AXLProblemDef:
+    if use_ext:
+        _add_log(f"Calling External AI Encoder ({ext_model})...")
+        raw = call_external_ai(ext_url, ext_model, oracle.ENCODER_PROMPT, text)
+    else:
+        _add_log("Calling Internal Gemini Encoder...")
+        client = genai.Client(api_key=api_key)
+        config = types.GenerateContentConfig(
+            system_instruction=[types.Part.from_text(text=oracle.ENCODER_PROMPT)],
+            response_mime_type="application/json", temperature=0.1)
+        resp = client.models.generate_content(
+            model=GEMINI_MODEL,
+            contents=[types.Content(role="user", parts=[types.Part.from_text(text=text)])],
+            config=config)
+        raw = resp.text
+
+    raw = raw.strip()
     if raw.startswith("```json"): raw = raw[7:-3]
+    if raw.startswith("```"): raw = raw[3:-3]
     d = json.loads(raw.strip())
     
     if "error" in d: raise ValueError(f"Isomorphism Invalid: {d['error']} - {d.get('reason', '')}")
@@ -204,36 +252,39 @@ def encode_problem(text: str, api_key: str) -> AXLProblemDef:
         scopes=[], anchors=anchors, observations=d.get("observations", {})
     )
 
-def collapse_solution(payload: dict, api_key: str) -> str:
-    client = genai.Client(api_key=api_key)
-    config = types.GenerateContentConfig(
-        system_instruction=[types.Part.from_text(text=oracle.COLLAPSER_PROMPT)],
-        temperature=0.2)
-    resp = client.models.generate_content(
-        model=GEMINI_MODEL,
-        contents=[types.Content(role="user", parts=[types.Part.from_text(text=json.dumps(payload))])],
-        config=config)
+def collapse_solution(payload: dict, api_key: str, use_ext: bool, ext_url: str, ext_model: str) -> str:
+    if use_ext:
+        _add_log(f"Calling External AI Collapser ({ext_model})...")
+        raw = call_external_ai(ext_url, ext_model, oracle.COLLAPSER_PROMPT, json.dumps(payload))
+    else:
+        _add_log("Calling Internal Gemini Collapser...")
+        client = genai.Client(api_key=api_key)
+        config = types.GenerateContentConfig(
+            system_instruction=[types.Part.from_text(text=oracle.COLLAPSER_PROMPT)],
+            temperature=0.2)
+        resp = client.models.generate_content(
+            model=GEMINI_MODEL,
+            contents=[types.Content(role="user", parts=[types.Part.from_text(text=json.dumps(payload))])],
+            config=config)
+        raw = resp.text
         
-    raw = resp.text.strip()
+    raw = raw.strip()
     if raw.startswith("```json"): raw = raw[7:-3]
+    if raw.startswith("```"): raw = raw[3:-3]
     
     try:
         data = json.loads(raw.strip())
         md = data.get("hypothesis_markdown", "No markdown generated.")
         return md
     except:
-        return "JSON Decode Error from Collapser. Raw:\n" + resp.text
+        return "JSON Decode Error from Collapser. Raw:\n" + raw
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 4: THE ORCHESTRATOR LOOP
 # ══════════════════════════════════════════════════════════════════════
-
-# Bug 1 Fix: Explicit, exact integer-propagation solve callback
 def quick_solver_callback(axl_def: AXLProblemDef, N: int) -> Dict[str, float]:
     try:
         prob = build_core_problem(axl_def)
-        
-        # Pull integer vars bounded up to width 100
         int_vars = [v for v in prob.variables if v in prob.int_vars
                     and math.isfinite(prob.bounds[v][0])
                     and prob.bounds[v][1] - prob.bounds[v][0] <= 100]
@@ -245,13 +296,13 @@ def quick_solver_callback(axl_def: AXLProblemDef, N: int) -> Dict[str, float]:
                 hi = int(math.floor(prob.bounds[v][1]))
                 grids.append([(v, float(val)) for val in range(lo, hi+1)])
                 
+            import itertools
             for combo in itertools.product(*grids):
                 pinned = dict(combo)
                 resolved, _ = core.algebraic_propagate_pinned(prob, pinned)
                 ok, msg = oracle.ground_truth_verify(resolved, N)
                 if ok: return resolved
         else:
-            # 1D single-parameter search (e.g. 1D Sine Snap)
             if 't' in prob.variables:
                 lo, hi = prob.bounds['t']
                 for t_val in range(max(2, int(lo)), min(100, int(hi)) + 1):
@@ -259,7 +310,6 @@ def quick_solver_callback(axl_def: AXLProblemDef, N: int) -> Dict[str, float]:
                     resolved, _ = core.algebraic_propagate_pinned(prob, pinned)
                     ok, msg = oracle.ground_truth_verify(resolved, N)
                     if ok: return resolved
-            # s, d Fermat grid search
             if 's' in prob.variables and 'd' in prob.variables:
                 lo_s, hi_s = prob.bounds['s']
                 lo_d, hi_d = prob.bounds['d']
@@ -274,7 +324,9 @@ def quick_solver_callback(axl_def: AXLProblemDef, N: int) -> Dict[str, float]:
         print(f"Quick solver callback error: {e}")
         return {}
 
-def global_solve_task(original_text: str, api_key: str, template_name: str = None):
+
+def global_solve_task(original_text: str, api_key: str, template_name: str = None,
+                      use_ext: bool = False, ext_url: str = "", ext_model: str = ""):
     _update_state(
         is_running=True, phase="ENCODING", high_level_logs=[], answer="",
         best_ce=float('inf'), total_fired=0, best_ray="—",
@@ -288,8 +340,7 @@ def global_solve_task(original_text: str, api_key: str, template_name: str = Non
             template_text = oracle.STRUCTURAL_HYPOTHESIS_TEMPLATES[template_name]
             axl_def = parse_template_as_axl(template_text)
         else:
-            _add_log("LLM Encoding Isomorphism...")
-            axl_def = encode_problem(original_text, api_key)
+            axl_def = encode_problem(original_text, api_key, use_ext, ext_url, ext_model)
             
         _add_log(f"`{axl_def.name}` | {len(axl_def.variables)} vars")
         if axl_def.minimize_var: _add_log(f"  MINIMIZE: {axl_def.minimize_var}")
@@ -311,14 +362,11 @@ def global_solve_task(original_text: str, api_key: str, template_name: str = Non
             _update_state(phase="RAY TRACING")
             base_prob = build_core_problem(axl_def)
             
-            # Setup initial seeds & execute exhaustive templates
             init_b, init_ce = axioms._mprt_sample(base_prob, 1000)
             _add_log("Searching continuous relaxation...")
             
             templates = axioms.generate_templates(base_prob, axioms.compute_sketch(base_prob))
-            _add_log(f"Assembled {len(templates)} integer grid mappings.")
             
-            # Restoring full 27.7 Ray Tracer engine with bandit feedback & batons
             tracer = axioms.SequenceRayTracer(
                 log_callback=_add_log,
                 update_state_callback=lambda **kwargs: _update_state(**kwargs)
@@ -351,7 +399,7 @@ def global_solve_task(original_text: str, api_key: str, template_name: str = Non
             "infeasibility_report": GLOBAL_SOLVE_STATE["infeasibility_report"]
         }
         
-        ans = collapse_solution(payload, api_key)
+        ans = collapse_solution(payload, api_key, use_ext, ext_url, ext_model)
         _update_state(answer=ans, raw_results_json=json.dumps(payload, indent=2), phase="DONE")
         _add_log("Pipeline Complete.")
 
@@ -367,15 +415,14 @@ def global_solve_task(original_text: str, api_key: str, template_name: str = Non
     finally:
         _update_state(is_running=False)
 
-def trigger_solve(problem_text, api_key):
+def trigger_solve(problem_text, api_key, template_name=None, use_ext=False, ext_url="", ext_model=""):
     if GLOBAL_SOLVE_STATE["is_running"] or not problem_text.strip(): return
-    threading.Thread(target=global_solve_task, args=(problem_text, api_key), daemon=True).start()
+    threading.Thread(target=global_solve_task, args=(problem_text, api_key, template_name, use_ext, ext_url, ext_model), daemon=True).start()
 
-def trigger_hyp_solve(template_name, api_key):
+def trigger_hyp_solve(template_name, api_key, use_ext=False, ext_url="", ext_model=""):
     if GLOBAL_SOLVE_STATE["is_running"]: return
-    threading.Thread(target=global_solve_task, args=("", api_key, template_name), daemon=True).start()
+    threading.Thread(target=global_solve_task, args=("", api_key, template_name, use_ext, ext_url, ext_model), daemon=True).start()
 
-# Bug 3 Fix: Shors Demo imports directly from oracle without ModuleNotFoundError
 def run_quantum_demo():
     _update_state(is_running=True, phase="QUANTUM SIMULATION", answer="Running Physics Simulator...\nCheck console for output.", high_level_logs=[])
     def _run():
@@ -452,12 +499,12 @@ def _reset(c):
     c.update({"finalized": False, "ans": "", "raw": ""})
     return c
 
-def handle_solve(text, key, cache):
-    trigger_solve(text, key)
+def handle_solve(text, key, use_ext, ext_url, ext_model, cache):
+    trigger_solve(text, key, template_name=None, use_ext=use_ext, ext_url=ext_url, ext_model=ext_model)
     return _reset(cache)
 
-def handle_hyp_solve(name, key, cache):
-    trigger_hyp_solve(name, key)
+def handle_hyp_solve(name, key, use_ext, ext_url, ext_model, cache):
+    trigger_hyp_solve(name, key, use_ext=use_ext, ext_url=ext_url, ext_model=ext_model)
     return _reset(cache)
 
 def handle_q_run(cache):
@@ -472,7 +519,12 @@ with gr.Blocks(title="Practicality 28.0") as demo:
 
     with gr.Row():
         with gr.Column(scale=2):
-            api_key_input = gr.Textbox(label="Gemini API Key", type="password", value=DEFAULT_GEMINI_API_KEY)
+            with gr.Group():
+                gr.Markdown("### ⚙️ AI Backend Configuration")
+                api_key_input = gr.Textbox(label="Gemini API Key (Internal)", type="password", value=DEFAULT_GEMINI_API_KEY)
+                use_ext_toggle = gr.Checkbox(label="🌐 Use External AI Server", value=False)
+                ext_url_input = gr.Textbox(label="External Server URL", value="http://localhost:7860", placeholder="http://localhost:7860")
+                ext_model_dropdown = gr.Dropdown(choices=["claude", "haiku", "maverick"], value="claude", label="External Model")
             
             gr.Markdown("### 1. Novel Discovery")
             prob_input = gr.Textbox(label="Target Description", lines=3)
@@ -490,26 +542,14 @@ with gr.Blocks(title="Practicality 28.0") as demo:
             ans_box = gr.Textbox(label="Grounded Hypothesis (LLM Output)", lines=12)
             raw_box = gr.Textbox(label="Raw JSON", lines=4)
 
-    # NATIVE PY-SIDE TIMER:
-    # Completely replaces JavaScript `setInterval` and invisible HTML button polling.
-    # Runs over standard WebSockets; fully immune to Hugging Face Spaces iframe sandboxing.
+    # NATIVE PY-SIDE TIMER
     ui_timer = gr.Timer(1.0)
-    
-    ui_timer.tick(
-        fn=fetch_dashboard, 
-        inputs=[dash_cache], 
-        outputs=[live_html, dash_cache]
-    )
-    
-    ui_timer.tick(
-        fn=fetch_answers, 
-        inputs=[ans_cache], 
-        outputs=[ans_box, raw_box, ans_cache]
-    )
+    ui_timer.tick(fn=fetch_dashboard, inputs=[dash_cache], outputs=[live_html, dash_cache])
+    ui_timer.tick(fn=fetch_answers, inputs=[ans_cache], outputs=[ans_box, raw_box, ans_cache])
 
     # Event handlers routed cleanly
-    solve_btn.click(fn=handle_solve, inputs=[prob_input, api_key_input, ans_cache], outputs=[ans_cache])
-    hyp_solve_btn.click(fn=handle_hyp_solve, inputs=[hyp_dropdown, api_key_input, ans_cache], outputs=[ans_cache])
+    solve_btn.click(fn=handle_solve, inputs=[prob_input, api_key_input, use_ext_toggle, ext_url_input, ext_model_dropdown, ans_cache], outputs=[ans_cache])
+    hyp_solve_btn.click(fn=handle_hyp_solve, inputs=[hyp_dropdown, api_key_input, use_ext_toggle, ext_url_input, ext_model_dropdown, ans_cache], outputs=[ans_cache])
     q_btn.click(fn=handle_q_run, inputs=[ans_cache], outputs=[ans_cache])
 
 if __name__ == "__main__":