@nekzus/liop 2.1.0-alpha.13 → 2.1.0-alpha.15

package/dist/{chunk-HB5DXX3Q.js → chunk-KF4DCCU3.js}

@@ -1,7 +1,8 @@
 import { LiopVerifier } from './chunk-32ADSAJS.js';
 import { Kyber768Wrapper } from './chunk-QLCOEP5J.js';
-import { authorizeRequest } from './chunk-IJHTRIZC.js';
-import { liopV1, createChannelCredentials } from './chunk-RDWCGZ2A.js';
+import { authorizeRequest, Dilithium65Wrapper } from './chunk-OIMJZ64E.js';
+import { liopV1, createChannelCredentials, GRPC_CHANNEL_OPTIONS } from './chunk-WSW6YJNY.js';
+import { MCP_PROTOCOL_VERSION, MCP_LEGACY_SUPPORT_ENABLED, isLegacyRequest, adaptResponseForLegacyClient, MCP_PROTOCOL_VERSION_LEGACY, buildLegacyInitializeResponse } from './chunk-PYKRQAER.js';
 import { log } from './chunk-72MNYFR6.js';
 import * as crypto2 from 'crypto';
 import * as grpc from '@grpc/grpc-js';
@@ -831,6 +832,9 @@ var LiopMcpRouter = class _LiopMcpRouter {
   static MANIFEST_FAILURE_BASE_COOLDOWN_MS = 15e3;
   static MANIFEST_FAILURE_MAX_COOLDOWN_MS = 5 * 6e4;
   static MANIFEST_SKIP_LOG_THROTTLE_MS = 3e4;
+  getManifestCacheSize() {
+    return this.manifestCache.size;
+  }
   shouldSkipManifestQuery(peerId) {
     const state = this.manifestFailureState.get(peerId);
     if (!state) return false;
@@ -861,6 +865,23 @@ var LiopMcpRouter = class _LiopMcpRouter {
       lastSkipLogAt: 0
     });
   }
+  /**
+   * Detects the protocol era of an incoming request.
+   * Modern requests carry '_meta' with protocol version "2026-07-28" or use modern RPCs.
+   * Legacy requests use 'initialize' handshake or lack '_meta' envelopes.
+   */
+  detectEra(request) {
+    const params = request.params;
+    const meta = params?._meta;
+    const version = meta?.["io.modelcontextprotocol/protocolVersion"];
+    if (version === MCP_PROTOCOL_VERSION) {
+      return "modern";
+    }
+    if (MCP_LEGACY_SUPPORT_ENABLED && isLegacyRequest(request)) {
+      return "legacy";
+    }
+    return "modern";
+  }
   async dispatch(request, authInfo) {
     const { method, params, id } = request;
     log.info(`[LIOP-Router] Processing: ${method}`);
@@ -882,12 +903,42 @@ var LiopMcpRouter = class _LiopMcpRouter {
       }
     }
     switch (method) {
-      case "initialize":
+      /** @mcp-legacy Initialize handshake for 2025-era clients. Remove when v1 EOL. */
+      case "initialize": {
+        if (!MCP_LEGACY_SUPPORT_ENABLED) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: {
+              code: -32601,
+              message: "Method retired: initialize (MCP 2026-07-28 is stateless)"
+            }
+          };
+        }
+        log.info(
+          "[LIOP-Router] \u26A0\uFE0F Legacy MCP client detected (2025-era initialize)."
+        );
+        return buildLegacyInitializeResponse(
+          this.liopServer.getServerInfo(),
+          id
+        );
+      }
+      /** @mcp-legacy Initialized notification for 2025-era clients. Remove when v1 EOL. */
+      case "notifications/initialized":
+        if (!MCP_LEGACY_SUPPORT_ENABLED) return null;
+        this.kickDiscoveryAfterInitialized().catch(() => {
+        });
+        return null;
+      case "notifications/cancelled":
+        return null;
+      // No-op for MCP spec compliance
+      case "server/discover":
         return {
           jsonrpc: "2.0",
           id,
           result: {
-            protocolVersion: "2025-11-25",
+            resultType: "complete",
+            supportedVersions: MCP_LEGACY_SUPPORT_ENABLED ? [MCP_PROTOCOL_VERSION, MCP_PROTOCOL_VERSION_LEGACY] : [MCP_PROTOCOL_VERSION],
             capabilities: {
               tools: { listChanged: true },
               resources: { listChanged: true },
@@ -896,13 +947,6 @@ var LiopMcpRouter = class _LiopMcpRouter {
             serverInfo: this.liopServer.getServerInfo()
           }
         };
-      case "notifications/initialized":
-        this.kickDiscoveryAfterInitialized().catch(() => {
-        });
-        return null;
-      case "notifications/cancelled":
-        return null;
-      // No-op for MCP spec compliance
       case "ping":
         return { jsonrpc: "2.0", id, result: {} };
       case "tools/list": {
@@ -924,7 +968,9 @@ var LiopMcpRouter = class _LiopMcpRouter {
             additionalProperties: false
           }
         };
-        const allTools = [diagnosticTool, ...listedLocals, ...remoteTools];
+        const allTools = [diagnosticTool, ...listedLocals, ...remoteTools].sort(
+          (a, b) => a.name.localeCompare(b.name)
+        );
         const telemetry = TokenTelemetryEngine.getInstance();
         const toolsPayload = JSON.stringify(allTools);
         const toolsResponsePayload = JSON.stringify({ tools: allTools });
@@ -934,24 +980,47 @@ var LiopMcpRouter = class _LiopMcpRouter {
           estimatedInputTokens: telemetry.countTokens(toolsPayload),
           estimatedOutputTokens: telemetry.countTokens(toolsResponsePayload)
         });
-        return {
+        const era = this.detectEra(request);
+        let response = {
           jsonrpc: "2.0",
           id,
           result: {
+            resultType: "complete",
+            ttlMs: 3e5,
+            cacheScope: "public",
             tools: allTools
           }
         };
+        if (era === "legacy" && MCP_LEGACY_SUPPORT_ENABLED) {
+          response = adaptResponseForLegacyClient(response);
+        }
+        return response;
       }
-      case "tools/call":
-        return this.transcodeMcpToLiop(
+      case "tools/call": {
+        const response = await this.transcodeMcpToLiop(
           id,
           params,
           authInfo?.token
         );
+        if (!response) return null;
+        const era = this.detectEra(request);
+        if (era === "legacy" && MCP_LEGACY_SUPPORT_ENABLED) {
+          return adaptResponseForLegacyClient(response);
+        }
+        if (response.result && typeof response.result === "object") {
+          const resObj = response.result;
+          if (!resObj.resultType) {
+            resObj.resultType = "complete";
+          }
+        }
+        return response;
+      }
       case "resources/list": {
         const localResources = this.liopServer.listResources();
         const remoteResources = await this.getRemoteResources();
-        const allResources = [...localResources, ...remoteResources];
+        const allResources = [...localResources, ...remoteResources].sort(
+          (a, b) => a.uri.localeCompare(b.uri)
+        );
         const rlTelemetry = TokenTelemetryEngine.getInstance();
         const rlPayload = JSON.stringify(allResources);
         rlTelemetry.record({
@@ -960,11 +1029,21 @@ var LiopMcpRouter = class _LiopMcpRouter {
           estimatedInputTokens: 0,
           estimatedOutputTokens: rlTelemetry.countTokens(rlPayload)
         });
-        return {
+        const era = this.detectEra(request);
+        let response = {
           jsonrpc: "2.0",
           id,
-          result: { resources: allResources }
+          result: {
+            resultType: "complete",
+            ttlMs: 3e5,
+            cacheScope: "public",
+            resources: allResources
+          }
         };
+        if (era === "legacy" && MCP_LEGACY_SUPPORT_ENABLED) {
+          response = adaptResponseForLegacyClient(response);
+        }
+        return response;
       }
       case "resources/read": {
         const typedParams = params;
@@ -987,7 +1066,23 @@ var LiopMcpRouter = class _LiopMcpRouter {
             estimatedOutputTokens: rrTelemetry.countTokens(rrOutputPayload),
             durationMs: Date.now() - rrStartTime
           });
-          return { jsonrpc: "2.0", id, result };
+          const era = this.detectEra(request);
+          const rawResult = typeof result === "object" && result !== null ? {
+            resultType: "complete",
+            ttlMs: 6e4,
+            cacheScope: "private",
+            ...result
+          } : {
+            resultType: "complete",
+            ttlMs: 6e4,
+            cacheScope: "private",
+            contents: result
+          };
+          let response = { jsonrpc: "2.0", id, result: rawResult };
+          if (era === "legacy" && MCP_LEGACY_SUPPORT_ENABLED) {
+            response = adaptResponseForLegacyClient(response);
+          }
+          return response;
         } catch (err) {
           const targetUri = typedParams.uri;
           for (const { manifest } of this.manifestCache.values()) {
@@ -998,10 +1093,14 @@ var LiopMcpRouter = class _LiopMcpRouter {
               log.info(
                 `[LIOP-Router] Resolved resource ${targetUri} from cache (Peer: ${manifest.peerId})`
               );
-              return {
+              const era = this.detectEra(request);
+              let response = {
                 jsonrpc: "2.0",
                 id,
                 result: {
+                  resultType: "complete",
+                  ttlMs: 6e4,
+                  cacheScope: "private",
                   contents: [
                     {
                       uri: remoteResource.uri,
@@ -1011,6 +1110,10 @@ var LiopMcpRouter = class _LiopMcpRouter {
                   ]
                 }
               };
+              if (era === "legacy" && MCP_LEGACY_SUPPORT_ENABLED) {
+                response = adaptResponseForLegacyClient(response);
+              }
+              return response;
             }
           }
           return {
@@ -1024,7 +1127,7 @@ var LiopMcpRouter = class _LiopMcpRouter {
         }
       }
       case "prompts/list": {
-        const promptsList = this.liopServer.listPrompts();
+        const promptsList = this.liopServer.listPrompts().sort((a, b) => a.name.localeCompare(b.name));
         const plTelemetry = TokenTelemetryEngine.getInstance();
         const plPayload = JSON.stringify(promptsList);
         plTelemetry.record({
@@ -1033,11 +1136,21 @@ var LiopMcpRouter = class _LiopMcpRouter {
           estimatedInputTokens: 0,
           estimatedOutputTokens: plTelemetry.countTokens(plPayload)
         });
-        return {
+        const era = this.detectEra(request);
+        let response = {
           jsonrpc: "2.0",
           id,
-          result: { prompts: promptsList }
+          result: {
+            resultType: "complete",
+            ttlMs: 3e5,
+            cacheScope: "public",
+            prompts: promptsList
+          }
         };
+        if (era === "legacy" && MCP_LEGACY_SUPPORT_ENABLED) {
+          response = adaptResponseForLegacyClient(response);
+        }
+        return response;
       }
       case "prompts/get": {
         const typedParams = params;
@@ -1067,7 +1180,13 @@ var LiopMcpRouter = class _LiopMcpRouter {
             estimatedOutputTokens: pgTelemetry.countTokens(pgOutputPayload),
             durationMs: Date.now() - pgStartTime
           });
-          return { jsonrpc: "2.0", id, result };
+          const era = this.detectEra(request);
+          const rawResult = typeof result === "object" && result !== null ? { resultType: "complete", ...result } : result;
+          let response = { jsonrpc: "2.0", id, result: rawResult };
+          if (era === "legacy" && MCP_LEGACY_SUPPORT_ENABLED) {
+            response = adaptResponseForLegacyClient(response);
+          }
+          return response;
         } catch (err) {
           return {
             jsonrpc: "2.0",
@@ -1079,6 +1198,37 @@ var LiopMcpRouter = class _LiopMcpRouter {
           };
         }
       }
+      case "resources/templates/list": {
+        const era = this.detectEra(request);
+        let response = {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            resultType: "complete",
+            ttlMs: 3e5,
+            cacheScope: "public",
+            resourceTemplates: []
+          }
+        };
+        if (era === "legacy" && MCP_LEGACY_SUPPORT_ENABLED) {
+          response = adaptResponseForLegacyClient(response);
+        }
+        return response;
+      }
+      case "subscriptions/listen": {
+        const era = this.detectEra(request);
+        let response = {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            resultType: "complete"
+          }
+        };
+        if (era === "legacy" && MCP_LEGACY_SUPPORT_ENABLED) {
+          response = adaptResponseForLegacyClient(response);
+        }
+        return response;
+      }
       default:
         return {
           jsonrpc: "2.0",
@@ -1224,6 +1374,24 @@ var LiopMcpRouter = class _LiopMcpRouter {
         for (const result of queryResults) {
           if (result.status === "fulfilled" && result.value?.manifest) {
             const { peerId, manifest } = result.value;
+            if (manifest.pqcSignature && manifest.pqcPublicKey) {
+              const isValid = Dilithium65Wrapper.verifyManifest(
+                manifest,
+                manifest.pqcSignature,
+                manifest.pqcPublicKey
+              );
+              if (!isValid) {
+                log.warn(
+                  `[LIOP-Router] \u26A0\uFE0F Tampered manifest rejected for peer ${peerId} (ML-DSA-65 signature invalid)`
+                );
+                this.recordManifestQueryFailure(peerId);
+                errorCount++;
+                continue;
+              }
+              log.info(
+                `[LIOP-Router] \u{1F512} ML-DSA-65 (FIPS 204) Manifest attestation verified for peer ${peerId}`
+              );
+            }
             this.manifestCache.set(peerId, {
               manifest,
               cachedAt: Date.now()
@@ -1671,28 +1839,42 @@ ${cachedToolList}` : "\nNo remote tools discovered yet.",
         manifestEntry = this.manifestCache.get(peerId);
       }
     }
-    const shouldRemapGrpcPorts = process.env.LIOP_USE_PUBLISHED_GRPC_PORTS === "1" || process.env.LIOP_DOCKER_MAP === "true" || process.env.LIOP_DEV_MODE === "true" || process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
-    if (shouldRemapGrpcPorts && manifestEntry) {
-      const providerName = manifestEntry.manifest.serverInfo?.name?.toLowerCase() || "";
-      if (providerName.includes("vault")) grpcPort = 13011;
-      else if (providerName.includes("bank")) grpcPort = 13021;
-      else if (providerName.includes("oracle")) grpcPort = 13031;
-    }
     const addrs = await this.meshNode.resolvePeer(peerId);
+    const nexusUrl = process.env.LIOP_NEXUS_URL || "";
+    const isDockerDemo = nexusUrl.includes("127.0.0.1:13000") || nexusUrl.includes("localhost:13000") || nexusUrl.includes("127.0.0.1:13001") || nexusUrl.includes("localhost:13001");
+    const isDockerPort = addrs.some(
+      (a) => a.includes("13001") || a.includes("13003") || a.includes("13004") || a.includes("13005") || a.includes("13011") || a.includes("13021") || a.includes("13031")
+    );
+    const shouldRemapGrpcPorts = process.env.LIOP_USE_PUBLISHED_GRPC_PORTS === "1" || process.env.LIOP_DOCKER_MAP === "true" || process.env.LIOP_DEV_MODE === "true" || process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test" || isDockerDemo || isDockerPort;
+    if (shouldRemapGrpcPorts) {
+      const providerName = manifestEntry?.manifest?.serverInfo?.name?.toLowerCase() || "";
+      const tn = toolName.toLowerCase();
+      if (providerName.includes("vault") || tn.includes("medical")) {
+        grpcPort = 13011;
+      } else if (providerName.includes("bank") || tn.includes("bank")) {
+        grpcPort = 13021;
+      } else if (providerName.includes("oracle") || tn.includes("hft") || tn.includes("market")) {
+        grpcPort = 13031;
+      }
+    }
     let targetAddr = null;
-    const os = await import('os');
-    const localInterfaces = Object.values(os.networkInterfaces()).flat().filter((i) => i?.family === "IPv4").map((i) => i?.address);
-    for (const addr of addrs) {
-      const parts = addr.split("/");
-      const ipIdx = parts.indexOf("ip4");
-      if (ipIdx !== -1) {
-        const advertisedIp = parts[ipIdx + 1];
-        if (advertisedIp === "127.0.0.1" || localInterfaces.includes(advertisedIp)) {
-          targetAddr = `127.0.0.1:${grpcPort}`;
-          break;
-        }
-        if (!targetAddr) {
-          targetAddr = `${advertisedIp}:${grpcPort}`;
+    if (shouldRemapGrpcPorts) {
+      targetAddr = `127.0.0.1:${grpcPort}`;
+    } else {
+      const os = await import('os');
+      const localInterfaces = Object.values(os.networkInterfaces()).flat().filter((i) => i?.family === "IPv4").map((i) => i?.address);
+      for (const addr of addrs) {
+        const parts = addr.split("/");
+        const ipIdx = parts.indexOf("ip4");
+        if (ipIdx !== -1) {
+          const advertisedIp = parts[ipIdx + 1];
+          if (advertisedIp === "127.0.0.1" || localInterfaces.includes(advertisedIp)) {
+            targetAddr = `127.0.0.1:${grpcPort}`;
+            break;
+          }
+          if (!targetAddr) {
+            targetAddr = `${advertisedIp}:${grpcPort}`;
+          }
         }
       }
     }
@@ -1704,7 +1886,8 @@ ${cachedToolList}` : "\nNo remote tools discovered yet.",
     );
     const remoteClient = new liopV1.LogicMesh(
       targetAddr,
-      createChannelCredentials()
+      createChannelCredentials(),
+      GRPC_CHANNEL_OPTIONS
     );
     return this.performTranscoding(
       id,
@@ -1868,7 +2051,8 @@ ${cachedToolList}` : "\nNo remote tools discovered yet.",
           const { ciphertext, sharedSecret } = await Kyber768Wrapper.encapsulateAsymmetric(
             response.kyber_public_key
           );
-          const embeddedArgsJson = JSON.stringify(params.arguments || {});
+          const embeddedArgs = params?.arguments ?? (params?.payload !== void 0 ? params : {});
+          const embeddedArgsJson = JSON.stringify(embeddedArgs);
           const proxyLogic = `return { "__liop_proxy_tool": "${toolName}", "__liop_proxy_args": ${embeddedArgsJson} };`;
           const nonce = crypto2.randomBytes(12);
           const sealedLogic = this.encryptWithNonce(
@@ -1972,5 +2156,5 @@ ${cachedToolList}` : "\nNo remote tools discovered yet.",
 };
 
 export { HeuristicTokenEstimator, LiopMcpRouter, LiopOTelBridge, RealTokenEstimator, TokenTelemetryEngine, createSyncTokenEstimator, createTokenEstimator };
-//# sourceMappingURL=chunk-HB5DXX3Q.js.map
-//# sourceMappingURL=chunk-HB5DXX3Q.js.map
+//# sourceMappingURL=chunk-KF4DCCU3.js.map
+//# sourceMappingURL=chunk-KF4DCCU3.js.map