@nekzus/liop 2.4.6 → 2.5.0-beta.2

package/dist/bin/agent.js

@@ -1,28 +1,41 @@
 #!/usr/bin/env node
-import { LiopServer } from '../chunk-WCCGE4QR.js';
-import '../chunk-JIJPZFR2.js';
-import { LiopMcpRouter } from '../chunk-547TYL27.js';
-import '../chunk-32ADSAJS.js';
-import '../chunk-OUUTDSOW.js';
-import '../chunk-QLCOEP5J.js';
-import '../chunk-U5BZ66VX.js';
-import '../chunk-WSW6YJNY.js';
-import '../chunk-PYKRQAER.js';
-import '../chunk-RWRRBYG4.js';
-import { MeshNode } from '../chunk-74CISO2I.js';
-import { log } from '../chunk-72MNYFR6.js';
+import { probeTopology, RoutingTable } from '../chunk-PUDETPL4.js';
+import { TokenManager } from '../chunk-3QH44NKZ.js';
+import { LiopServer } from '../chunk-5SWHE62F.js';
+import '../chunk-Y62GORQF.js';
+import { LiopMcpRouter } from '../chunk-VRB5HUYU.js';
+import '../chunk-2STZHJ24.js';
+import '../chunk-IK7CGWAZ.js';
+import '../chunk-7PITYWOV.js';
+import '../chunk-WPTOJYN5.js';
+import '../chunk-UJFWPRDM.js';
+import '../chunk-PAICJCKJ.js';
+import { isLegacyRequest } from '../chunk-2KSO3W4A.js';
+import '../chunk-FTF6AMF6.js';
+import '../chunk-ZP3VVXOI.js';
+import { MeshNode } from '../chunk-XRDN232O.js';
+import { log } from '../chunk-K3DGJLUY.js';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import * as readline from 'readline';
 import { multiaddr } from '@multiformats/multiaddr';
 
+var LIOP_MESH_STATUS_TOOL = {
+  name: "LiopMeshStatus",
+  description: "LiopMeshStatus: Returns the current dynamic diagnostic status of the Zero-Trust Neural Mesh.",
+  inputSchema: {
+    type: "object",
+    properties: {},
+    additionalProperties: false
+  }
+};
 async function resolveBootstrapFromUrl(url) {
   try {
     const healthUrl = url.endsWith("/health") ? url : `${url}/health`;
     const response = await fetch(healthUrl, {
       headers: { Accept: "application/json" },
       signal: AbortSignal.timeout(1e4)
-      // Increased to 10s
     });
     if (!response.ok) return null;
     const data = await response.json();
@@ -61,6 +74,26 @@ function normalizeBootstrap(addr) {
   return trimmed;
 }
 function industrialAddressMapper(addr) {
+  if (addr.includes("/ip4/172.23.0.10"))
+    return addr.replace(
+      /\/ip4\/172\.23\.0\.10\/tcp\/[0-9]+/,
+      "/ip4/127.0.0.1/tcp/15001"
+    );
+  if (addr.includes("/ip4/172.23.0.20"))
+    return addr.replace(
+      /\/ip4\/172\.23\.0\.20\/tcp\/[0-9]+/,
+      "/ip4/127.0.0.1/tcp/15011"
+    );
+  if (addr.includes("/ip4/172.21.0.13"))
+    return addr.replace(
+      /\/ip4\/172\.21\.0\.13\/tcp\/[0-9]+/,
+      "/ip4/127.0.0.1/tcp/15031"
+    );
+  if (addr.includes("/ip4/172.21.0.14"))
+    return addr.replace(
+      /\/ip4\/172\.21\.0\.14\/tcp\/[0-9]+/,
+      "/ip4/127.0.0.1/tcp/15041"
+    );
   if (addr.includes("/ip4/172.20.0.10"))
     return addr.replace(
       /\/ip4\/172\.20\.0\.10\/tcp\/[0-9]+/,
@@ -89,7 +122,7 @@ function industrialAddressMapper(addr) {
 function isDockerDemoHost(urlStr) {
   try {
     const u = new URL(urlStr);
-    return (u.hostname === "127.0.0.1" || u.hostname === "localhost") && (u.port === "13000" || u.port === "13001");
+    return (u.hostname === "127.0.0.1" || u.hostname === "localhost") && (u.port === "13000" || u.port === "13001" || u.port === "15000" || u.port === "15018");
   } catch {
     return false;
   }
@@ -97,45 +130,14 @@ function isDockerDemoHost(urlStr) {
 function shouldEnableDockerMap() {
   return process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test" || process.env.LIOP_DOCKER_MAP === "true" || process.env.LIOP_DEV_MODE === "true" || !!process.env.LIOP_NEXUS_URL && isDockerDemoHost(process.env.LIOP_NEXUS_URL);
 }
-async function main() {
-  if ((process.platform === "win32" || process.platform === "darwin") && !process.execArgv.includes("--use-system-ca") && !(process.env.NODE_OPTIONS ?? "").includes("--use-system-ca")) {
-    const { spawn } = await import('child_process');
-    const child = spawn(
-      process.execPath,
-      ["--use-system-ca", ...process.argv.slice(1)],
-      { stdio: "inherit", env: process.env }
-    );
-    child.on("exit", (code) => process.exit(code ?? 1));
-    child.on("error", () => process.exit(1));
-    await new Promise(() => {
-    });
-    return;
-  }
-  const buildTime = (/* @__PURE__ */ new Date()).toISOString();
-  log.info(`[LIOP-Agent] \u{1F680} Version 1.2.0-alpha.9 | Build: ${buildTime}`);
-  const liopDir = path.join(os.homedir(), ".liop");
-  const identityPath = path.join(liopDir, "identity.json");
-  if (!fs.existsSync(liopDir)) {
-    fs.mkdirSync(liopDir, { recursive: true });
-  }
+async function resolveBootstrapNodes(liopDir) {
   let bootstrapNodes = [];
   const args = process.argv.slice(2);
   if (args.length > 0) {
     bootstrapNodes = args.filter((a) => a.startsWith("/"));
   }
   if (bootstrapNodes.length === 0) {
-    const searchDirs = [];
-    if (process.env.LIOP_BOOTSTRAP_FILE) {
-      log.warn(
-        "LIOP_BOOTSTRAP_FILE is deprecated and will be removed in the next major version. Use LIOP_NEXUS_URL for Auto-Discovery instead."
-      );
-      const filePath = path.resolve(process.env.LIOP_BOOTSTRAP_FILE);
-      if (fs.existsSync(filePath)) {
-        const addr = fs.readFileSync(filePath, "utf8").trim();
-        if (addr) bootstrapNodes.push(normalizeBootstrap(addr));
-      }
-    }
-    searchDirs.push(
+    const searchDirs = [
       process.cwd(),
       path.join(process.cwd(), "tests/infra/nexus-data"),
       liopDir,
@@ -143,7 +145,7 @@ async function main() {
         path.dirname(new URL(import.meta.url).pathname).replace(/^\/([A-Z]:)/, "$1"),
         "../../tests/infra/nexus-data"
       )
-    );
+    ];
     for (const dir of searchDirs) {
       try {
         if (fs.existsSync(dir)) {
@@ -162,15 +164,12 @@ async function main() {
           }
           if (bootstrapNodes.length > 0) break;
         }
-      } catch (_e) {
+      } catch {
       }
     }
   }
   if (process.env.LIOP_NEXUS_URL) {
     const nexusUrl = process.env.LIOP_NEXUS_URL;
-    log.info(
-      `[LIOP-Agent] \u{1F310} Running parallel discovery from: ${nexusUrl} (Sources Found: ${bootstrapNodes.length})`
-    );
     const resolved = await resolveBootstrapFromUrl(nexusUrl);
     if (resolved) {
       const normalized = normalizeBootstrap(resolved);
@@ -185,36 +184,322 @@ async function main() {
   if (bootstrapNodes.length === 0 && process.env.LIOP_BOOTSTRAP) {
     bootstrapNodes.push(process.env.LIOP_BOOTSTRAP.trim());
   }
-  if (bootstrapNodes.length === 0) {
-    bootstrapNodes.push(
-      "/ip4/127.0.0.1/tcp/13001/p2p/12D3KooWD8FUFdnLQzzLFNdicsaTknM5cpD7os9sK9NWVSVABJMD"
-    );
-  }
-  bootstrapNodes = bootstrapNodes.filter((addr) => {
+  return bootstrapNodes.filter((addr) => {
     try {
       multiaddr(addr);
       return true;
     } catch {
-      log.warn(`[LIOP-Agent] Ignoring invalid bootstrap multiaddr: ${addr}`);
       return false;
     }
   });
-  if (bootstrapNodes.length === 0) {
-    log.info(
-      "[LIOP-Agent] No bootstrap nodes configured. Operating in standalone mode."
+}
+async function forwardToGateway(mcpEndpoint, request, tokenManager) {
+  const send = async (token2) => {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (token2) {
+      headers.Authorization = `Bearer ${token2}`;
+    }
+    if (request.method) {
+      headers["Mcp-Method"] = request.method;
+    }
+    const params = request.params;
+    if (params?.name) {
+      headers["Mcp-Name"] = params.name;
+    }
+    return await fetch(mcpEndpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request),
+      signal: AbortSignal.timeout(3e4)
+    });
+  };
+  let token;
+  try {
+    token = await tokenManager.getToken();
+  } catch (err) {
+    log.warn(
+      `[LIOP-Agent] Token acquisition warning: ${err instanceof Error ? err.message : String(err)}`
     );
+  }
+  let response = await send(token);
+  if (response.status === 401 && token) {
     log.info(
-      "[LIOP-Agent] Pass a multiaddr as argument or create 'nexus.multiaddr' file."
+      "[LIOP-Agent] \u{1F504} 401 received from Gateway. Refreshing token and retrying..."
     );
+    tokenManager.invalidate();
+    try {
+      token = await tokenManager.getToken();
+      response = await send(token);
+    } catch {
+    }
   }
+  if (!response.ok) {
+    const errorBody = await response.text();
+    let parsedError = null;
+    try {
+      parsedError = JSON.parse(errorBody);
+    } catch {
+    }
+    const errorObj = parsedError?.error;
+    return {
+      jsonrpc: "2.0",
+      id: request.id,
+      error: {
+        code: errorObj?.code ?? -32603,
+        message: errorObj?.message ?? `Gateway returned HTTP ${response.status}: ${errorBody}`
+      }
+    };
+  }
+  return await response.json();
+}
+async function runGatewayMode(gateway, tokenManager, routingTable) {
+  log.info(
+    `[LIOP-Agent] \u{1F6E1}\uFE0F Running in ADAPTIVE GATEWAY MODE -> ${gateway.mcpEndpoint}`
+  );
+  routingTable.registerLocalTool(LIOP_MESH_STATUS_TOOL);
+  routingTable.registerGatewayTools(
+    gateway.tools.map((t) => ({ name: t })),
+    gateway.mcpEndpoint
+  );
+  let lastToolCount = gateway.tools.length;
+  const pollInterval = setInterval(async () => {
+    try {
+      const res = await fetch(gateway.healthEndpoint, {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(4e3)
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (data.tools && data.tools.length !== lastToolCount) {
+          log.info(
+            `[LIOP-Agent] Gateway tools topology updated (${lastToolCount} -> ${data.tools.length})`
+          );
+          lastToolCount = data.tools.length;
+          routingTable.registerGatewayTools(
+            data.tools.map((t) => ({ name: t })),
+            gateway.mcpEndpoint
+          );
+          process.stdout.write(
+            `{"jsonrpc":"2.0","method":"notifications/tools/list_changed"}
+`
+          );
+          process.stdout.write(
+            `{"jsonrpc":"2.0","method":"notifications/resources/list_changed"}
+`
+          );
+        }
+      }
+    } catch {
+    }
+  }, 15e3);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    terminal: false
+  });
+  process.stdout.on("error", (err) => {
+    if (err.code === "EPIPE") {
+      clearInterval(pollInterval);
+      process.exit(0);
+    }
+  });
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let request;
+    try {
+      request = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    const { id, method } = request;
+    if (method === "server/discover") {
+      const discoverResponse = {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          resultType: "complete",
+          supportedVersions: ["2026-07-28", "2025-11-25"],
+          capabilities: {
+            tools: { listChanged: true },
+            resources: { listChanged: true, subscribe: true },
+            prompts: { listChanged: true }
+          },
+          serverInfo: {
+            name: "liop-adaptive-agent",
+            version: "2.5.0"
+          }
+        }
+      };
+      process.stdout.write(`${JSON.stringify(discoverResponse)}
+`);
+      return;
+    }
+    if (method === "initialize") {
+      const clientVersion = request.params?.protocolVersion ?? request.params?._meta?.["io.modelcontextprotocol/protocolVersion"];
+      const protocolVersion = clientVersion === "2026-07-28" ? "2026-07-28" : "2025-11-25";
+      const initResponse = {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          protocolVersion,
+          capabilities: {
+            tools: { listChanged: true },
+            resources: { listChanged: true, subscribe: true },
+            prompts: { listChanged: true }
+          },
+          serverInfo: {
+            name: "liop-adaptive-agent",
+            version: "2.5.0"
+          }
+        }
+      };
+      process.stdout.write(`${JSON.stringify(initResponse)}
+`);
+      return;
+    }
+    if (method === "notifications/initialized" || method === "notifications/cancelled") {
+      return;
+    }
+    if (method === "ping") {
+      process.stdout.write(
+        `${JSON.stringify({ jsonrpc: "2.0", id, result: {} })}
+`
+      );
+      return;
+    }
+    if (method === "resources/templates/list") {
+      const templatesResponse = {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          resultType: "complete",
+          ttlMs: 3e5,
+          cacheScope: "public",
+          resourceTemplates: []
+        }
+      };
+      process.stdout.write(`${JSON.stringify(templatesResponse)}
+`);
+      return;
+    }
+    if (method === "subscriptions/listen") {
+      const listenResponse = {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          resultType: "complete"
+        }
+      };
+      process.stdout.write(`${JSON.stringify(listenResponse)}
+`);
+      return;
+    }
+    if (method === "tools/call") {
+      const params = request.params;
+      if (params?.name === "LiopMeshStatus") {
+        const statusResponse = {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  mode: "adaptive-gateway",
+                  gatewayUrl: gateway.baseUrl,
+                  tier: gateway.tier,
+                  toolsAvailable: routingTable.getAllToolDefinitions().length,
+                  authenticated: true,
+                  status: "ONLINE"
+                })
+              }
+            ]
+          }
+        };
+        process.stdout.write(`${JSON.stringify(statusResponse)}
+`);
+        return;
+      }
+    }
+    try {
+      const response = await forwardToGateway(
+        gateway.mcpEndpoint,
+        request,
+        tokenManager
+      );
+      if (method === "tools/list" && response.result && typeof response.result === "object") {
+        const resObj = response.result;
+        const toolsList = resObj.tools;
+        if (Array.isArray(toolsList)) {
+          const hasStatus = toolsList.some((t) => t.name === "LiopMeshStatus");
+          if (!hasStatus) {
+            toolsList.unshift(LIOP_MESH_STATUS_TOOL);
+          }
+          routingTable.registerGatewayTools(toolsList, gateway.mcpEndpoint);
+        }
+        if (!isLegacyRequest(request)) {
+          if (!resObj.resultType) {
+            resObj.resultType = "complete";
+          }
+          if (!resObj.ttlMs) {
+            resObj.ttlMs = 3e5;
+          }
+          if (!resObj.cacheScope) {
+            resObj.cacheScope = "public";
+          }
+        }
+      }
+      process.stdout.write(`${JSON.stringify(response)}
+`);
+    } catch (err) {
+      if (method === "tools/list") {
+        const isLegacy = isLegacyRequest(request);
+        const fallbackResult = isLegacy ? { tools: routingTable.getAllToolDefinitions() } : {
+          resultType: "complete",
+          ttlMs: 3e5,
+          cacheScope: "public",
+          tools: routingTable.getAllToolDefinitions()
+        };
+        const fallbackResponse = {
+          jsonrpc: "2.0",
+          id,
+          result: fallbackResult
+        };
+        process.stdout.write(`${JSON.stringify(fallbackResponse)}
+`);
+      } else {
+        const errResponse = {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32603,
+            message: `Forwarding failed: ${err instanceof Error ? err.message : String(err)}`
+          }
+        };
+        process.stdout.write(`${JSON.stringify(errResponse)}
+`);
+      }
+    }
+  });
+  rl.on("close", () => {
+    clearInterval(pollInterval);
+    process.exit(0);
+  });
+}
+async function runMeshMode(mesh) {
+  log.info(
+    `[LIOP-Agent] \u{1F310} Running in P2P MESH MODE (${mesh.bootstrapNodes.length} bootstraps)`
+  );
   const liopServer = new LiopServer({
     name: "@nekzus/liop",
-    version: "1.0.0"
+    version: "2.5.0"
   });
   liopServer.enableZeroShotAutonomy();
   const meshNode = new MeshNode({
-    identityPath,
-    bootstrapNodes,
+    identityPath: mesh.identityPath,
+    bootstrapNodes: mesh.bootstrapNodes,
     addressMapper: shouldEnableDockerMap() ? industrialAddressMapper : void 0
   });
   await meshNode.start();
@@ -230,8 +515,6 @@ async function main() {
     );
   };
   setTimeout(() => {
-    const rtSize = meshNode.getRoutingTableSize?.() || 0;
-    log.info(`[LIOP-Agent] Warm-up complete. Routing Table size: ${rtSize}`);
     router.refreshManifestCache(true).catch(() => {
     });
   }, 2e3);
@@ -246,9 +529,6 @@ async function main() {
       const newSize = router.getCacheSize();
       if (newSize !== prevSize) {
         pollIntervalMs = POLL_BASE_MS;
-        log.info(
-          `[LIOP-Agent] Topology change detected (${prevSize} \u2192 ${newSize}). Resetting poll to ${POLL_BASE_MS / 1e3}s.`
-        );
       } else {
         pollIntervalMs = Math.min(
           Math.round(pollIntervalMs * 1.5),
@@ -259,15 +539,12 @@ async function main() {
     }, pollIntervalMs);
   };
   scheduleAdaptivePoll();
-  const readline = await import('readline');
   const rl = readline.createInterface({
     input: process.stdin,
     terminal: false
   });
   process.stdout.on("error", (err) => {
-    if (err.code === "EPIPE") {
-      process.exit(0);
-    }
+    if (err.code === "EPIPE") process.exit(0);
   });
   rl.on("line", async (line) => {
     const trimmed = line.trim();
@@ -281,22 +558,336 @@ async function main() {
 `);
         }
       }
-    } catch (_err) {
+    } catch {
     }
   });
-  rl.on("close", () => {
+  rl.on("close", () => process.exit(0));
+  process.on("SIGINT", async () => {
+    await meshNode.stop();
     process.exit(0);
   });
-  log.info(`[LIOP-Agent] Guarding Claude Desktop via STDIO.`);
+}
+async function runHybridMode(topology, tokenManager, routingTable) {
+  const gateway = topology.gateway;
+  const mesh = topology.mesh;
+  if (!gateway || !mesh) {
+    if (gateway) return runGatewayMode(gateway, tokenManager, routingTable);
+    if (mesh) return runMeshMode(mesh);
+    return;
+  }
   log.info(
-    `[LIOP-Agent] P2P Mesh: Joined (${bootstrapNodes.length} bootstraps)`
+    `[LIOP-Agent] \u26A1 Running in HYBRID MODE (Gateway: ${gateway.baseUrl} + Mesh P2P)`
   );
-  log.info("[LIOP-Agent] Tool discovery: Dynamic via /liop/manifest/1.0.0");
-  process.on("SIGINT", async () => {
-    await meshNode.stop();
+  routingTable.registerLocalTool(LIOP_MESH_STATUS_TOOL);
+  routingTable.registerGatewayTools(
+    gateway.tools.map((t) => ({ name: t })),
+    gateway.mcpEndpoint
+  );
+  let meshNode = null;
+  let router = null;
+  const initMeshPromise = (async () => {
+    try {
+      const liopServer = new LiopServer({
+        name: "@nekzus/liop-hybrid",
+        version: "2.5.0"
+      });
+      liopServer.enableZeroShotAutonomy();
+      meshNode = new MeshNode({
+        identityPath: mesh.identityPath,
+        bootstrapNodes: mesh.bootstrapNodes,
+        addressMapper: shouldEnableDockerMap() ? industrialAddressMapper : void 0
+      });
+      await meshNode.start();
+      router = new LiopMcpRouter(liopServer, meshNode);
+      router.onToolsChanged = () => {
+        process.stdout.write(
+          `{"jsonrpc":"2.0","method":"notifications/tools/list_changed"}
+`
+        );
+        process.stdout.write(
+          `{"jsonrpc":"2.0","method":"notifications/resources/list_changed"}
+`
+        );
+      };
+      await router.refreshManifestCache(true).catch(() => {
+      });
+      log.info("[LIOP-Agent] \u2705 Background P2P Mesh initialization completed.");
+    } catch (err) {
+      log.warn(
+        `[LIOP-Agent] Background Mesh init warning: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  })();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    terminal: false
+  });
+  process.stdout.on("error", (err) => {
+    if (err.code === "EPIPE") process.exit(0);
+  });
+  rl.on("line", async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let request;
+    try {
+      request = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    const { id, method } = request;
+    if (method === "server/discover") {
+      const discoverResponse = {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          resultType: "complete",
+          supportedVersions: ["2026-07-28", "2025-11-25"],
+          capabilities: {
+            tools: { listChanged: true },
+            resources: { listChanged: true, subscribe: true },
+            prompts: { listChanged: true }
+          },
+          serverInfo: {
+            name: "liop-hybrid-agent",
+            version: "2.5.0"
+          }
+        }
+      };
+      process.stdout.write(`${JSON.stringify(discoverResponse)}
+`);
+      return;
+    }
+    if (method === "initialize") {
+      const clientVersion = request.params?.protocolVersion ?? request.params?._meta?.["io.modelcontextprotocol/protocolVersion"];
+      const protocolVersion = clientVersion === "2026-07-28" ? "2026-07-28" : "2025-11-25";
+      const initResponse = {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          protocolVersion,
+          capabilities: {
+            tools: { listChanged: true },
+            resources: { listChanged: true, subscribe: true },
+            prompts: { listChanged: true }
+          },
+          serverInfo: {
+            name: "liop-hybrid-agent",
+            version: "2.5.0"
+          }
+        }
+      };
+      process.stdout.write(`${JSON.stringify(initResponse)}
+`);
+      return;
+    }
+    if (method === "notifications/initialized" || method === "notifications/cancelled") {
+      return;
+    }
+    if (method === "ping") {
+      process.stdout.write(
+        `${JSON.stringify({ jsonrpc: "2.0", id, result: {} })}
+`
+      );
+      return;
+    }
+    if (method === "resources/templates/list") {
+      const templatesResponse = {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          resultType: "complete",
+          ttlMs: 3e5,
+          cacheScope: "public",
+          resourceTemplates: []
+        }
+      };
+      process.stdout.write(`${JSON.stringify(templatesResponse)}
+`);
+      return;
+    }
+    if (method === "subscriptions/listen") {
+      const listenResponse = {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          resultType: "complete"
+        }
+      };
+      process.stdout.write(`${JSON.stringify(listenResponse)}
+`);
+      return;
+    }
+    if (method === "tools/call") {
+      const params = request.params;
+      const toolName = params?.name || "";
+      const route = routingTable.resolve(toolName);
+      if (route?.provider === "http-gateway") {
+        const start = Date.now();
+        try {
+          const res = await forwardToGateway(
+            gateway.mcpEndpoint,
+            request,
+            tokenManager
+          );
+          routingTable.recordSuccess(toolName, Date.now() - start);
+          process.stdout.write(`${JSON.stringify(res)}
+`);
+          return;
+        } catch (_err) {
+          routingTable.recordFailure(toolName);
+          log.warn(
+            `[LIOP-Agent] Gateway call failed for '${toolName}'. Checking P2P fallback...`
+          );
+        }
+      }
+      await initMeshPromise;
+      if (router) {
+        const res = await router.dispatch(request);
+        if (res) process.stdout.write(`${JSON.stringify(res)}
+`);
+        return;
+      }
+    }
+    if (method === "tools/list") {
+      let gatewayTools = [];
+      try {
+        const gwRes = await forwardToGateway(
+          gateway.mcpEndpoint,
+          request,
+          tokenManager
+        );
+        const resObj = gwRes.result;
+        if (Array.isArray(resObj?.tools)) {
+          gatewayTools = resObj.tools;
+          routingTable.registerGatewayTools(gatewayTools, gateway.mcpEndpoint);
+        }
+      } catch {
+        gatewayTools = routingTable.getAllToolDefinitions();
+      }
+      let meshTools = [];
+      if (router) {
+        const meshRes = await router.dispatch(request);
+        const meshObj = meshRes?.result;
+        if (Array.isArray(meshObj?.tools)) {
+          meshTools = meshObj.tools;
+        }
+      }
+      const toolMap = /* @__PURE__ */ new Map();
+      toolMap.set("LiopMeshStatus", LIOP_MESH_STATUS_TOOL);
+      for (const t of gatewayTools) toolMap.set(t.name, t);
+      for (const t of meshTools)
+        if (!toolMap.has(t.name)) toolMap.set(t.name, t);
+      const merged = Array.from(toolMap.values()).sort(
+        (a, b) => a.name.localeCompare(b.name)
+      );
+      const isLegacy = isLegacyRequest(request);
+      const toolsResult = isLegacy ? { tools: merged } : {
+        resultType: "complete",
+        ttlMs: 3e5,
+        cacheScope: "public",
+        tools: merged
+      };
+      process.stdout.write(
+        `${JSON.stringify({ jsonrpc: "2.0", id, result: toolsResult })}
+`
+      );
+      return;
+    }
+    try {
+      const res = await forwardToGateway(
+        gateway.mcpEndpoint,
+        request,
+        tokenManager
+      );
+      if (!isLegacyRequest(request) && res.result && typeof res.result === "object") {
+        const resObj = res.result;
+        if (!resObj.resultType) {
+          resObj.resultType = "complete";
+        }
+      }
+      process.stdout.write(`${JSON.stringify(res)}
+`);
+    } catch {
+      await initMeshPromise;
+      if (router) {
+        const res = await router.dispatch(request);
+        if (res) process.stdout.write(`${JSON.stringify(res)}
+`);
+      }
+    }
+  });
+  rl.on("close", async () => {
+    if (meshNode) await meshNode.stop();
     process.exit(0);
   });
 }
+async function main() {
+  if ((process.platform === "win32" || process.platform === "darwin") && !process.execArgv.includes("--use-system-ca") && !(process.env.NODE_OPTIONS ?? "").includes("--use-system-ca")) {
+    const { spawn } = await import('child_process');
+    const child = spawn(
+      process.execPath,
+      ["--use-system-ca", ...process.argv.slice(1)],
+      { stdio: "inherit", env: process.env }
+    );
+    child.on("exit", (code) => process.exit(code ?? 1));
+    child.on("error", () => process.exit(1));
+    await new Promise(() => {
+    });
+    return;
+  }
+  const buildTime = (/* @__PURE__ */ new Date()).toISOString();
+  log.info(
+    `[LIOP-Agent] \u{1F680} Version 2.5.0 (Adaptive Zero-Config) | Build: ${buildTime}`
+  );
+  const liopDir = path.join(os.homedir(), ".liop");
+  const identityPath = path.join(liopDir, "identity.json");
+  if (!fs.existsSync(liopDir)) {
+    fs.mkdirSync(liopDir, { recursive: true });
+  }
+  const bootstrapNodes = await resolveBootstrapNodes(liopDir);
+  const blgUrl = process.env.LIOP_BLG_URL;
+  const nexusUrl = process.env.LIOP_NEXUS_URL;
+  const clientId = process.env.LIOP_CLIENT_ID || process.env.LIOP_OAUTH_CLIENT_ID || "liop-agent";
+  const clientSecret = process.env.LIOP_CLIENT_SECRET || process.env.LIOP_OAUTH_CLIENT_SECRET || "dev-secret-change-me";
+  const staticToken = process.env.LIOP_TOKEN || process.env.LIOP_OAUTH_TOKEN;
+  const topology = await probeTopology({
+    blgUrl,
+    nexusUrl,
+    clientId,
+    clientSecret,
+    staticToken,
+    bootstrapNodes,
+    identityPath
+  });
+  const routingTable = new RoutingTable();
+  const tokenManager = new TokenManager({
+    tokenEndpoint: topology.gateway?.tokenEndpoint || `${nexusUrl || "http://127.0.0.1:15000"}/oidc/token`,
+    clientId,
+    clientSecret,
+    audience: topology.gateway?.audience,
+    scopes: topology.gateway?.scopes,
+    staticToken
+  });
+  switch (topology.mode) {
+    case "gateway":
+      if (!topology.gateway)
+        throw new Error(
+          "Topology probe indicated gateway mode without gateway info."
+        );
+      await runGatewayMode(topology.gateway, tokenManager, routingTable);
+      break;
+    case "mesh":
+      if (!topology.mesh)
+        throw new Error(
+          "Topology probe indicated mesh mode without mesh info."
+        );
+      await runMeshMode(topology.mesh);
+      break;
+    case "hybrid":
+      await runHybridMode(topology, tokenManager, routingTable);
+      break;
+  }
+}
 main().catch((err) => {
   log.error(`[LIOP-Agent] Fatal Error: ${err.message}`);
   process.exit(1);