revamped

app.py

@@ -12,129 +12,128 @@ MODEL_ID = "Qwen/Qwen2.5-7B-Instruct"
 client_primary = InferenceClient(MODEL_ID, token=HF_TOKEN)
 client_competitor = InferenceClient(MODEL_ID, token=HF_TOKEN)
 
-# 2. Logic Controller (T3 Architecture)
+# 2. THE RESTORED T3 KERNEL (Local Deterministic Logic)
 class StateController:
-    __slots__ = ("_state", "_metric", "_batch", "_reg", "_rendered", "_rom60", "_symbols")
+    __slots__ = ("_state", "_rom60", "_symbols", "_rendered")
     def __init__(self):
         self._state      = array("B", [0]) * 121
-        self._metric     = 60
-        self._batch      = 10
-        self._reg        = {}
-        self._rendered   = "".join(" [NODE_120] " if i == 120 else ("<" if i % 10 == 0 else ".") for i in range(121))
         self._rom60      = tuple(tuple((i * j) % 60 for j in range(60)) for i in range(60))
         self._symbols    = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567"
+        # THE GLYPHS: Restoring the visual grid
+        self._rendered   = "".join(" [NODE_120] " if i == 120 else ("<" if i % 10 == 0 else ".") for i in range(121))
 
-    def diagnostic(self) -> str:
-        return f"Diagnostic sequence initiated.\n\nGrid initialized.\n\n{self._rendered}\n\nSystem resolved."
+    def compute_distribution(self, total, nodes) -> str:
+        base, rem = divmod(total, nodes)
+        res = f"T3 Logic Kernel resolved {total} units across {nodes} nodes:\n\n"
+        for i in range(nodes):
+            res += f"NODE_{i+1:02}: {base + (1 if i < rem else 0)} units\n"
+        return res
 
-    def generate_receipt(self, a: int, b: int, c: int) -> str:
+    def get_glyphs(self) -> str:
+        return f"Rendering 121-point state array:\n\n{self._rendered}\n\nSystem State: RESOLVED"
+
+    def generate_receipt(self, a, b, c) -> str:
         idx = (self._rom60[a % 60][b % 60] ^ (c % 60)) % 60
         return f"0{self._symbols[idx]}"
 
-    def validate_receipt(self, receipt: str, a: int, b: int, c: int) -> str:
+    def validate_receipt(self, receipt, a, b, c) -> str:
         expected = self.generate_receipt(a, b, c)
         if receipt == expected:
-            return f"[NODE_120: ACTIVE] Checksum Validated. Receipt {receipt} matches."
-        return f"[NODE_120: INACTIVE] Verification Failed. Expected {expected}."
+            return f"√ CHECKSUM VALID: Receipt {receipt} verified for allocation ({a}, {b}, {c})."
+        return f"× CHECKSUM INVALID: Expected {expected}, received {receipt}."
 
 controller = StateController()
 
-PRIMARY_SYS = {"role": "system", "content": "You are a logic-focused inference engine. Use strict state-hold memory."}
-VANILLA_SYS = {"role": "system", "content": "You are a standard helpful AI assistant."}
-
-# 3. Response Generation (Gradio 6.x Dictionary Format)
-def generate_responses(user_message, primary_history, competitor_history):
+# 3. Core Response Logic (The Local Interceptor)
+def generate_responses(user_message, p_hist, c_hist):
     msg = user_message.strip()
-    if not msg:
-        yield primary_history, competitor_history, ""
-        return
-
-    # Ensure history is initialized
-    if primary_history is None: primary_history = []
-    if competitor_history is None: competitor_history = []
-
-    # Format: Dict-based history required for Gradio 6
-    primary_history.append({"role": "user", "content": msg})
-    primary_history.append({"role": "assistant", "content": ""})
-    competitor_history.append({"role": "user", "content": msg})
-    competitor_history.append({"role": "assistant", "content": ""})
-    
-    yield primary_history, competitor_history, ""
+    if not msg: yield p_hist, c_hist, ""; return
+
+    # Correct Gradio 6.5.1 History initialization
+    p_hist = p_hist or []
+    c_hist = c_hist or []
+    p_hist.append({"role": "user", "content": msg})
+    p_hist.append({"role": "assistant", "content": ""})
+    c_hist.append({"role": "user", "content": msg})
+    c_hist.append({"role": "assistant", "content": ""})
+    yield p_hist, c_hist, ""
     
     start_time = time.perf_counter()
 
-    # Diagnostic & Checksum Intercepts
-    if msg.lower() == "run grid diagnostic":
-        primary_history[-1]["content"] = f"{controller.diagnostic()}\n\n---\n*Telemetry: {time.perf_counter()-start_time:.4f}s*"
-        competitor_history[-1]["content"] = "Hardware diagnostics not supported."
-        yield primary_history, competitor_history, ""
-        return
-
-    verify_match = re.search(r"verify receipt\s+([a-zA-Z0-9]{2})\s+for\s+(\d+),\s*(\d+),\s*(\d+)", msg, re.IGNORECASE)
-    if verify_match:
-        receipt, a, b, c = verify_match.group(1), int(verify_match.group(2)), int(verify_match.group(3)), int(verify_match.group(4))
-        res = controller.validate_receipt(receipt, a, b, c)
-        primary_history[-1]["content"] = f"{res}\n\n---\n*Telemetry: {time.perf_counter()-start_time:.6f}s*"
-        competitor_history[-1]["content"] = "Verification not supported."
-        yield primary_history, competitor_history, ""
-        return
-
-    # Engine 1: Augmented
-    try:
-        msgs = [PRIMARY_SYS] + primary_history[:-1]
-        response_text = ""
-        stream = client_primary.chat_completion(messages=msgs, max_tokens=1024, stream=True, temperature=0.1)
-        for chunk in stream:
-            response_text += (chunk.choices[0].delta.content or "")
-            primary_history[-1]["content"] = response_text
-            yield primary_history, competitor_history, ""
-        primary_history[-1]["content"] += f"\n\n---\n*Telemetry: {time.perf_counter()-start_time:.2f}s | Augmented Engine*"
-        yield primary_history, competitor_history, ""
-    except Exception as e:
-        primary_history[-1]["content"] = f"Primary Error: {str(e)}"
-
-    # Engine 2: Vanilla
+    # --- THE T3 INTERCEPTORS (100x SPEED BOOST) ---
+    dist_match = re.search(r"(\d+)\s+units\s+across\s+(\d+)\s+nodes", msg, re.IGNORECASE)
+    diag_match = "diagnostic" in msg.lower() or "grid" in msg.lower()
+    rcpt_match = re.search(r"verify receipt\s+([a-zA-Z0-9]{2})\s+for\s+(\d+),\s*(\d+),\s*(\d+)", msg, re.IGNORECASE)
+
+    if dist_match or diag_match or rcpt_match:
+        # LOCAL CPU EXECUTION - Bypasses Cloud API
+        if dist_match:
+            res = controller.compute_distribution(int(dist_match.group(1)), int(dist_match.group(2)))
+        elif rcpt_match:
+            res = controller.validate_receipt(rcpt_match.group(1), int(rcpt_match.group(2)), int(rcpt_match.group(3)), int(rcpt_match.group(4)))
+        else:
+            res = controller.get_glyphs()
+        
+        elapsed = time.perf_counter() - start_time
+        p_hist[-1]["content"] = f"{res}\n\n---\n*Telemetry: {elapsed:.6f}s | Source: LOCAL T3 KERNEL*"
+        yield p_hist, c_hist, ""
+    else:
+        # Cloud API Fallback for non-math text
+        try:
+            stream = client_primary.chat_completion(messages=[{"role":"system","content":"T3 Augmented Logic Engine"}] + p_hist[:-1], max_tokens=512, stream=True, temperature=0.1)
+            res_text = ""
+            for chunk in stream:
+                res_text += (chunk.choices[0].delta.content or "")
+                p_hist[-1]["content"] = res_text
+                yield p_hist, c_hist, ""
+            p_hist[-1]["content"] += f"\n\n---\n*Telemetry: {time.perf_counter()-start_time:.2f}s | Source: AUGMENTED CLOUD*"
+        except Exception as e:
+            p_hist[-1]["content"] = f"Primary Error: {str(e)}"
+        yield p_hist, c_hist, ""
+
+    # --- COMPETITOR ENGINE (VANILLA CLOUD) ---
     comp_start = time.perf_counter()
-    competitor_history[-1]["content"] = "*Connecting to vanilla infrastructure...*"
-    yield primary_history, competitor_history, ""
+    c_hist[-1]["content"] = "*Routing through standard infrastructure...*"
+    yield p_hist, c_hist, ""
     
     try:
-        msgs = [VANILLA_SYS] + competitor_history[:-1]
-        response_text = ""
-        stream = client_competitor.chat_completion(messages=msgs, max_tokens=1024, stream=True, temperature=0.7)
+        stream = client_competitor.chat_completion(messages=[{"role":"system","content":"Vanilla AI"}] + c_hist[:-1], max_tokens=512, stream=True, temperature=0.7)
+        res_text = ""
         for chunk in stream:
-            response_text += (chunk.choices[0].delta.content or "")
-            competitor_history[-1]["content"] = response_text
-            yield primary_history, competitor_history, ""
-        competitor_history[-1]["content"] += f"\n\n---\n*Telemetry: {time.perf_counter()-comp_start:.2f}s | Vanilla Engine*"
-        yield primary_history, competitor_history, ""
+            res_text += (chunk.choices[0].delta.content or "")
+            c_hist[-1]["content"] = res_text
+            yield p_hist, c_hist, ""
+        c_hist[-1]["content"] += f"\n\n---\n*Telemetry: {time.perf_counter()-comp_start:.2f}s | Source: VANILLA CLOUD*"
     except Exception as e:
-        competitor_history[-1]["content"] = f"Competitor Error: {str(e)}"
+        c_hist[-1]["content"] = f"Competitor Error: {str(e)}"
     
-    yield primary_history, competitor_history, ""
+    yield p_hist, c_hist, ""
 
-# 4. Interface Build
+# 4. Interface Styling (Amber/Orange)
 custom_css = """
 body, .gradio-container { background-color: #110c08 !important; color: #fb923c !important; }
 footer { display: none !important; }
+.message-row { gap: 15px !important; }
 """
 
 with gr.Blocks() as demo:
     gr.Markdown("# [ GLYPH.IO ]\n### Dual-Engine Hardware Benchmark")
     
-    p_chat = gr.Chatbot(label="Augmented Logic Kernel", height=320)
+    # Restoring the Augmented Output window
+    p_chat = gr.Chatbot(label="Augmented Logic Kernel (T3 Architecture)", height=350)
     
     with gr.Row():
-        msg_in = gr.Textbox(label="Message", placeholder="Enter task...", scale=8)
+        msg_in = gr.Textbox(label="Message", placeholder="Test math, distribution, or receipt validation...", scale=8)
         btn = gr.Button("Execute", scale=1, variant="primary")
-        
-    c_chat = gr.Chatbot(label="Vanilla Qwen 2.5", height=320)
+    
+    gr.Examples(examples=["Run grid diagnostic", "Calculate distribution for 120 units across 3 nodes.", "Verify receipt 0e for 60, 30, 30"], inputs=msg_in)
+    
+    # Restoring the Vanilla Output window
+    c_chat = gr.Chatbot(label="Vanilla Qwen 2.5 (Standard Infrastructure)", height=350)
 
     msg_in.submit(generate_responses, [msg_in, p_chat, c_chat], [p_chat, c_chat, msg_in])
     btn.click(generate_responses, [msg_in, p_chat, c_chat], [p_chat, c_chat, msg_in])
 
 if __name__ == "__main__":
-    demo.queue().launch(
-        theme=gr.themes.Soft(primary_hue="orange"), 
-        css=custom_css
-    )
+    # Theme and CSS passed correctly to launch() to prevent version warnings
+    demo.queue().launch(theme=gr.themes.Soft(primary_hue="orange"), css=custom_css)