Add MTL/Kernel API endpoints, enhanced logging for tool calls

logos/server.py

@@ -28,15 +28,18 @@ if sys.platform == 'win32':
         sys.stderr = codecs.getwriter("utf-8")(sys.stderr.detach())
 
 # --- CONFIGURATION ---
-HOST = "0.0.0.0"
-PORT = 5000 
+from logos.config import SERVER_HOST, SERVER_PORT, LLM_ENDPOINT, UNIFIED_MODEL_ID
+
+# --- CONFIGURATION ---
+HOST = SERVER_HOST
+PORT = SERVER_PORT 
 
 # Initialize the Flask "Manifold"
 app = Flask(__name__)
 sock = Sock(app)
 CORS(app, resources={r"/*": {"origins": "*"}}) # Full Permissive CORS for Local Swarm
 # We use the existing NeuralRouter logic but adapted for this server
-swarm_os = LogosSwarm(base_url="http://localhost:1234/v1")
+swarm_os = LogosSwarm(base_url=LLM_ENDPOINT)
 v_node = VideoAtomizer()
 
 # Global Client Manager for Broadcast Pulse
@@ -61,6 +64,46 @@ class ConnectionManager:
 
 manager = ConnectionManager()
 
+@sock.route('/neural-link')
+def neural_link(ws):
+    """
+    Protocol 19: WebSocket Neural Bridge for Realtime Telemetry.
+    """
+    manager.connect(ws)
+    try:
+        while True:
+            data = ws.receive()
+            if data:
+                # Handle Command from GUI
+                import json
+                try:
+                    payload = json.loads(data)
+                    content = payload.get('content')
+                    
+                    if content:
+                        logger.info(f"[GUI] Received Command: {content}")
+                        # Execute via Swarm (Async run in thread)
+                        # We use a simple non-blocking trigger here
+                        loop = asyncio.new_event_loop()
+                        asyncio.set_event_loop(loop)
+                        res = loop.run_until_complete(swarm_os.process(content))
+                        loop.close()
+                        
+                        # Broadcast Result Back
+                        manager.broadcast({
+                            "type": "TENSOR_UPDATE",
+                            "node": res.get('node'),
+                            "origin": swarm_os.state.get('last_node', 0),
+                            "tensor": res.get('tensor'),
+                            "status": res.get('status')
+                        })
+                except Exception as e:
+                    logger.error(f"[GUI] WS Error: {e}")
+    except:
+        pass
+    finally:
+        manager.disconnect(ws)
+
 # --- MANIFOLD STATE TRACKING ---
 from logos.manifold_state import ManifoldState
 manifold = ManifoldState()
@@ -81,10 +124,71 @@ from logos.mhc_router import execute_recursive_manifold, calculate_manifold_cons
 from logos.memory.prime_db import PrimeTokenDB
 prime_db = PrimeTokenDB()
 
+# ==========================================
+# PROTOCOL 40: MTL INTERPRETER (Genesis Kernel)
+# ==========================================
+try:
+    from logos.mtl.interpreter import MTLInterpreter
+    from logos.kernel import GenesisKernel
+    mtl_interpreter = MTLInterpreter()
+    genesis_kernel = GenesisKernel()
+    MTL_AVAILABLE = True
+    logger.info("[SERVER] MTL Interpreter and Genesis Kernel loaded")
+except ImportError as e:
+    mtl_interpreter = None
+    genesis_kernel = None
+    MTL_AVAILABLE = False
+    logger.warning(f"[SERVER] MTL not available: {e}")
+
 # Simple in-memory index for the session (Simulating the Topology Graph)
 # Map[composite_id] -> filepath
 TOPOLOGY_INDEX = {}
 
+# --- PROTOCOL 29: CONTEXT SERVICE ENDPOINTS ---
+
+@app.route('/v1/context/neurons', methods=['POST'])
+def upsert_neurons():
+    """Batch Upsert Neurons."""
+    data = request.json
+    neurons = data.get('neurons', [])
+    updated = []
+    for n in neurons:
+        updated.append(manifold.upsert_neuron(n))
+    return jsonify({"status": "success", "upserted": len(updated), "neurons": updated})
+
+@app.route('/v1/context/buffer', methods=['POST'])
+def update_context_buffer():
+    """
+    Protocol 30: Context Injection.
+    Updates the active swarm memory from external agents (like the CLI Video Atomizer).
+    """
+    data = request.json
+    atoms = data.get('atoms', [])
+    if atoms:
+        swarm_os.state['context_buffer'] = atoms
+        logger.info(f"[CONTEXT] Buffer Updated via API: {atoms}")
+        return jsonify({"status": "UPDATED", "count": len(atoms)})
+    return jsonify({"status": "NO_CHANGE"}), 400
+
+@app.route('/v1/context/query', methods=['POST'])
+def query_context():
+    """Semantic/Topological Query."""
+    data = request.json
+    results = manifold.query_neurons(
+        query_text=data.get('query_text'),
+        filters=data.get('filters'),
+        limit=data.get('limit', 10)
+    )
+    return jsonify({"results": results, "count": len(results)})
+
+@app.route('/v1/context/neuron/<int:prime_index>', methods=['GET'])
+def get_neuron_prime(prime_index):
+    """Direct Access by Prime Index."""
+    neuron = manifold.get_neuron_by_prime(prime_index)
+    if neuron:
+        return jsonify(neuron)
+    return jsonify({"error": "Not Found"}), 404
+
 # --- API ENDPOINTS ---
 
 @app.route('/', methods=['GET'])
@@ -215,6 +319,60 @@ def ingest_signal():
         "norm_minimized": True
     })
 
+# ==========================================
+# PROTOCOL 40: MTL EXECUTION ENDPOINT
+# ==========================================
+@app.route('/v1/mtl/execute', methods=['POST'])
+def execute_mtl():
+    """Execute MTL code via API."""
+    if not MTL_AVAILABLE:
+        return jsonify({"error": "MTL not available"}), 503
+    
+    data = request.json
+    code = data.get('code', '')
+    
+    if not code:
+        return jsonify({"error": "No code provided"}), 400
+    
+    logger.info(f"[MTL] Executing: {code[:100]}...")
+    
+    try:
+        result = mtl_interpreter.execute(code)
+        logger.info(f"[MTL] Result: {result}")
+        return jsonify({
+            "status": "success",
+            "result": result,
+            "code": code
+        })
+    except Exception as e:
+        logger.error(f"[MTL] Error: {e}")
+        return jsonify({"error": str(e)}), 400
+
+@app.route('/v1/kernel/process', methods=['POST'])
+def kernel_process():
+    """Process a packet through the Genesis Kernel."""
+    if not MTL_AVAILABLE or not genesis_kernel:
+        return jsonify({"error": "Kernel not available"}), 503
+    
+    data = request.json
+    packet = data.get('packet')
+    source = data.get('source', 'API')
+    
+    if not packet:
+        return jsonify({"error": "No packet provided"}), 400
+    
+    logger.info(f"[KERNEL] Processing packet {packet} from {source}")
+    
+    try:
+        result = genesis_kernel.process_packet(int(packet), source=source)
+        return jsonify({
+            "status": "success",
+            "result": result
+        })
+    except Exception as e:
+        logger.error(f"[KERNEL] Error: {e}")
+        return jsonify({"error": str(e)}), 400
+
 @app.route('/favicon.ico', methods=['GET'])
 def favicon():
     return "", 204
@@ -248,6 +406,11 @@ def chat_completions():
     messages = data.get('messages', [])
     target_model = data.get('model', UNIFIED_MODEL_ID)
     
+    # [FIX] VIRTUAL ID MAPPING
+    # If the user/CLI requests the virtual router, map it to the underlying inference engine
+    if target_model == "logos-matroska-router":
+        target_model = UNIFIED_MODEL_ID
+    
     if not messages: return jsonify({"error": "No messages provided"}), 400
     
     last_msg = next((m for m in reversed(messages) if m['role'] == 'user'), None)
@@ -263,55 +426,64 @@ def chat_completions():
     else:
         last_prompt = last_msg['content']
 
-    # --- EXECUTE PROTOCOL 25 (RLM) ---
-    final_state, trajectory, atomic_state_obj = execute_recursive_manifold(last_prompt, target_model)
+    # --- EXECUTE PROTOCOL 25 (RLM) or SWARM DELEGATION ---
     
-    # Calculate usage (Mock for now)
-    prompt_tokens = len(last_prompt) // 4
-    completion_tokens = len(final_state) // 4
-    total_tokens = prompt_tokens + completion_tokens
-    
-    # Update Global Manifold State (Persistence)
-    shell, _ = calculate_manifold_constraint(last_prompt)
-    
-    manifold.update_shell_stats(shell, total_tokens, last_prompt)
-    
-    # [FIX] Merge transient Atomic Graph -> Global Persistence
-    # This populates the "3D Manifold Structure" in the UI
-    if hasattr(atomic_state_obj, "graph"):
-        # We manually merge for now. Better would be a method in ManifoldState.
-        # manifold.graph["nodes"].update(atomic_state_obj.graph["nodes"]) 
-        # But wait, atomic_state_obj is of type ManifoldState too!
-        # So we can just merge the dictionaries.
+    # 1. Swarm Delegation (Protocols 17 & 27)
+    if last_prompt.startswith("SWARM:") or last_prompt.startswith("RUN_FLOW:"):
+        # Direct Handoff to the Neural Router / Swarm
+        # Since swarm methods are async, we run them in a new event loop
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
         
-        # Merge Nodes
-        for nid, n_data in atomic_state_obj.graph["nodes"].items():
-            manifold.graph["nodes"][nid] = n_data
+        if last_prompt.startswith("RUN_FLOW:"):
+            flow_name = last_prompt.replace("RUN_FLOW:", "").strip()
+            # Resolve path
+            flow_path = os.path.join(os.getcwd(), ".agent", "flows", flow_name)
+            if not flow_path.endswith(".json"): flow_path += ".json"
             
-            # [GEOMETRY] Ensure every node has 3D coordinates for the Plotly visualizer
-            if "geometry" not in n_data:
-                # Use Prime Resonance as coordinates
-                # X = Heat, Y = Prime (Mod 100), Z = Domain Depth
-                prime_val = n_data.get("prime", 2)
-                heat_val = n_data.get("heat", 0)
-                
-                domain_map = {"INNER_SHELL": 0, "PRIME_CHANNEL": 5, "OUTER_SHELL": 10}
-                z_depth = domain_map.get(shell, 5) + (prime_val % 5)
-                
-                n_data["geometry"] = {
-                    "position": {
-                        "x": heat_val * 10,
-                        "y": prime_val % 100, 
-                        "z": z_depth
-                    },
-                    "domain": shell
-                }
+            logger.info(f"[SERVER] Delegating Flow to Swarm: {flow_name}")
+            result = loop.run_until_complete(swarm_os.execute_flow(flow_path))
+            final_state = f"FLOW_EXECUTION_COMPLETE\nResult: {result}"
+        else:
+             # SWARM: ...
+            payload = last_prompt.replace("SWARM:", "").strip()
+            logger.info(f"[SERVER] Delegating Task to Swarm: {payload}")
+            result = loop.run_until_complete(swarm_os.process(payload))
+            final_state = f"SWARM_OP_COMPLETE\nNode: {result.get('node')}\nAlignment: {result.get('alignment')}\nTensor: {result.get('tensor')}"
             
-        # Merge Edges
-        manifold.graph["edges"].extend(atomic_state_obj.graph["edges"])
+        loop.close()
+        
+        # Create a mock trajectory for the response format
+        trajectory = [{"iter": 0, "shell": "SWARM_DELEGATE"}]
         
-        # Update Resonance Product
-        manifold.resonance_product = atomic_state_obj.resonance_product
+    else:
+        # 2. Default Recursive Manifold (Protocol 25)
+        final_state, trajectory, atomic_state_obj = execute_recursive_manifold(last_prompt, target_model)
+        
+        # [FIX] Merge transient Atomic Graph -> Global Persistence (Only for RLM)
+        if hasattr(atomic_state_obj, "graph"):
+            # Merge Nodes
+            for nid, n_data in atomic_state_obj.graph["nodes"].items():
+                manifold.graph["nodes"][nid] = n_data
+                if "geometry" not in n_data:
+                    prime_val = n_data.get("prime", 2)
+                    heat_val = n_data.get("heat", 0)
+                    shell = trajectory[-1]['shell'] if trajectory else "INNER_SHELL"
+                    
+                    domain_map = {"INNER_SHELL": 0, "PRIME_CHANNEL": 5, "OUTER_SHELL": 10}
+                    z_depth = domain_map.get(shell, 5) + (prime_val % 5)
+                    
+                    n_data["geometry"] = {
+                        "position": {"x": heat_val * 10, "y": prime_val % 100, "z": z_depth},
+                        "domain": shell
+                    }
+            manifold.graph["edges"].extend(atomic_state_obj.graph["edges"])
+            manifold.resonance_product = atomic_state_obj.resonance_product
+
+    # Construct Token Usage
+    prompt_tokens = len(last_prompt) // 4
+    completion_tokens = len(final_state) // 4
+    total_tokens = prompt_tokens + completion_tokens
 
     return jsonify({
         "id": f"chatcmpl-logos-{int(time.time())}",