@nekzus/liop 2.4.0-alpha.25 → 2.4.0-alpha.26

package/dist/chunk-V47P2AQR.js

@@ -1,281 +0,0 @@
-import { TOOL_ALIASES } from './chunk-KR5UZUEY.js';
-import { log } from './chunk-K3DGJLUY.js';
-
-// src/runtime/routing-table.ts
-var RoutingTable = class _RoutingTable {
-  routes = /* @__PURE__ */ new Map();
-  static MAX_FAILURES = 5;
-  /**
-   * Registers or updates a collection of tools exposed via an HTTP Gateway.
-   */
-  registerGatewayTools(tools, mcpEndpoint, authRequired = true) {
-    for (const tool of tools) {
-      const existing = this.routes.get(tool.name);
-      this.routes.set(tool.name, {
-        name: tool.name,
-        provider: "http-gateway",
-        endpoint: mcpEndpoint,
-        description: tool.description ?? existing?.description,
-        inputSchema: tool.inputSchema ?? existing?.inputSchema,
-        latencyMs: existing?.latencyMs ?? 0,
-        failCount: 0,
-        lastSuccess: existing?.lastSuccess ?? Date.now(),
-        authRequired
-      });
-    }
-    log.info(
-      `[RoutingTable] Registered ${tools.length} tool(s) via HTTP Gateway (${mcpEndpoint})`
-    );
-  }
-  /**
-   * Registers tools discovered directly over the P2P Mesh (gRPC).
-   */
-  registerMeshTools(tools, grpcTarget, authRequired = false) {
-    for (const tool of tools) {
-      const existing = this.routes.get(tool.name);
-      if (existing && existing.provider === "http-gateway" && existing.failCount === 0) {
-        continue;
-      }
-      this.routes.set(tool.name, {
-        name: tool.name,
-        provider: "p2p-grpc",
-        endpoint: grpcTarget,
-        description: tool.description ?? existing?.description,
-        inputSchema: tool.inputSchema ?? existing?.inputSchema,
-        latencyMs: existing?.latencyMs ?? 0,
-        failCount: 0,
-        lastSuccess: existing?.lastSuccess ?? Date.now(),
-        authRequired
-      });
-    }
-    log.info(
-      `[RoutingTable] Registered ${tools.length} tool(s) via P2P Mesh gRPC (${grpcTarget})`
-    );
-  }
-  /**
-   * Registers an in-process local tool (e.g. LiopMeshStatus).
-   */
-  registerLocalTool(tool) {
-    this.routes.set(tool.name, {
-      name: tool.name,
-      provider: "local",
-      endpoint: "in-process",
-      description: tool.description,
-      inputSchema: tool.inputSchema,
-      latencyMs: 0,
-      failCount: 0,
-      lastSuccess: Date.now(),
-      authRequired: false
-    });
-  }
-  /**
-   * Resolves the optimal route for a specific tool.
-   */
-  resolve(toolName) {
-    const targetName = TOOL_ALIASES[toolName] || toolName;
-    const route = this.routes.get(targetName) ?? this.routes.get(toolName);
-    if (!route) return void 0;
-    if (route.failCount >= _RoutingTable.MAX_FAILURES) {
-      log.warn(
-        `[RoutingTable] Tool '${toolName}' route has tripped circuit breaker (${route.failCount} consecutive failures).`
-      );
-    }
-    return route;
-  }
-  /**
-   * Records a successful invocation on a route, resetting failures and updating latency.
-   */
-  recordSuccess(toolName, latencyMs) {
-    const route = this.routes.get(toolName);
-    if (route) {
-      route.failCount = 0;
-      route.latencyMs = latencyMs;
-      route.lastSuccess = Date.now();
-    }
-  }
-  /**
-   * Records a failed invocation on a route.
-   */
-  recordFailure(toolName) {
-    const route = this.routes.get(toolName);
-    if (route) {
-      route.failCount += 1;
-      log.warn(
-        `[RoutingTable] Failure recorded for tool '${toolName}' (failCount: ${route.failCount})`
-      );
-    }
-  }
-  /**
-   * Lists all registered tools in sorted format for tools/list.
-   */
-  getAllToolDefinitions() {
-    const list = [];
-    for (const route of this.routes.values()) {
-      list.push({
-        name: route.name,
-        description: route.description,
-        inputSchema: route.inputSchema
-      });
-    }
-    return list.sort((a, b) => a.name.localeCompare(b.name));
-  }
-  getRoute(toolName) {
-    return this.routes.get(toolName);
-  }
-  size() {
-    return this.routes.size;
-  }
-  clear() {
-    this.routes.clear();
-  }
-};
-
-// src/runtime/topology-probe.ts
-async function probeGatewayUrl(candidateUrl, options) {
-  const trimmedUrl = candidateUrl.replace(/\/+$/, "");
-  const healthUrl = `${trimmedUrl}/health`;
-  try {
-    log.info(`[TopologyProbe] Probing candidate Gateway at: ${healthUrl}`);
-    const healthRes = await fetch(healthUrl, {
-      headers: { Accept: "application/json" },
-      signal: AbortSignal.timeout(3e3)
-    });
-    if (!healthRes.ok) {
-      log.info(
-        `[TopologyProbe] Probe failed at ${healthUrl} [HTTP ${healthRes.status}]`
-      );
-      return null;
-    }
-    const healthData = await healthRes.json();
-    if (healthData.status !== "healthy") {
-      return null;
-    }
-    let issuer = healthData.auth?.issuer || "";
-    let tokenEndpoint = healthData.auth?.token_endpoint || "";
-    let audience = options.audience || "urn:liop:mesh:api";
-    let scopes = [
-      "liop:tools:list",
-      "liop:tools:call",
-      "liop:resources:read",
-      "liop:schema:read",
-      "liop:mesh:query"
-    ];
-    try {
-      const prmUrl = `${trimmedUrl}/.well-known/oauth-protected-resource`;
-      const prmRes = await fetch(prmUrl, {
-        headers: { Accept: "application/json" },
-        signal: AbortSignal.timeout(2e3)
-      });
-      if (prmRes.ok) {
-        const prmData = await prmRes.json();
-        if (prmData.resource) audience = prmData.resource;
-        if (prmData.authorization_servers?.length) {
-          issuer = prmData.authorization_servers[0];
-        }
-        if (prmData.scopes_supported?.length) {
-          scopes = prmData.scopes_supported;
-        }
-      }
-    } catch {
-    }
-    if (!tokenEndpoint && issuer) {
-      const baseIssuer = issuer.endsWith("/oidc") ? issuer : `${issuer}/oidc`;
-      tokenEndpoint = `${baseIssuer}/token`;
-    }
-    if (tokenEndpoint) {
-      try {
-        const parsedEndpoint = new URL(tokenEndpoint);
-        if (options.nexusUrl) {
-          const nexusBase = options.nexusUrl.replace(/\/+$/, "");
-          const nexusHost = new URL(nexusBase).host;
-          parsedEndpoint.host = nexusHost;
-          tokenEndpoint = parsedEndpoint.toString();
-        } else if ((parsedEndpoint.hostname === "nexus" || parsedEndpoint.hostname === "nexus-prod" || parsedEndpoint.hostname.startsWith("172.")) && trimmedUrl.includes("127.0.0.1")) {
-          parsedEndpoint.host = "127.0.0.1:15000";
-          tokenEndpoint = parsedEndpoint.toString();
-        }
-      } catch {
-      }
-    }
-    log.info(
-      `[TopologyProbe] \u2705 Verified Gateway at ${trimmedUrl} (Tools: ${healthData.tools?.length ?? 0}, Tier: ${healthData.topology?.tier ?? 2})`
-    );
-    return {
-      baseUrl: trimmedUrl,
-      mcpEndpoint: `${trimmedUrl}/mcp`,
-      healthEndpoint: `${trimmedUrl}/health`,
-      tokenEndpoint,
-      issuer,
-      audience,
-      scopes,
-      tools: healthData.tools || [],
-      tier: healthData.topology?.tier ?? 2
-    };
-  } catch (err) {
-    log.info(
-      `[TopologyProbe] Gateway probe unreachable at ${trimmedUrl}: ${err instanceof Error ? err.message : String(err)}`
-    );
-    return null;
-  }
-}
-async function probeTopology(options = {}) {
-  log.info("[TopologyProbe] Starting adaptive network topology discovery...");
-  let gatewayInfo = null;
-  if (options.blgUrl) {
-    gatewayInfo = await probeGatewayUrl(options.blgUrl, options);
-  }
-  if (!gatewayInfo && (options.autoProbeLocal ?? true)) {
-    const candidateUrls = [
-      "http://127.0.0.1:15018",
-      // Production BLG port
-      "http://127.0.0.1:15000",
-      // Production Nexus port
-      "http://127.0.0.1:13000"
-      // Demo Nexus port
-    ];
-    for (const url of candidateUrls) {
-      if (options.blgUrl && url.includes(new URL(options.blgUrl).port))
-        continue;
-      gatewayInfo = await probeGatewayUrl(url, options);
-      if (gatewayInfo) break;
-    }
-  }
-  const bootstrapNodes = options.bootstrapNodes || [];
-  const hasMeshBootstraps = bootstrapNodes.length > 0;
-  if (gatewayInfo && hasMeshBootstraps) {
-    log.info(
-      `[TopologyProbe] \u26A1 Mode Determined: HYBRID (Gateway: ${gatewayInfo.baseUrl} + ${bootstrapNodes.length} P2P bootstraps)`
-    );
-    return {
-      mode: "hybrid",
-      gateway: gatewayInfo,
-      mesh: {
-        bootstrapNodes,
-        identityPath: options.identityPath
-      }
-    };
-  }
-  if (gatewayInfo) {
-    log.info(
-      `[TopologyProbe] \u{1F680} Mode Determined: GATEWAY (Zero-P2P overhead, direct to ${gatewayInfo.baseUrl})`
-    );
-    return {
-      mode: "gateway",
-      gateway: gatewayInfo
-    };
-  }
-  log.info(
-    `[TopologyProbe] \u{1F310} Mode Determined: MESH (Standard P2P DHT, Bootstraps: ${bootstrapNodes.length})`
-  );
-  return {
-    mode: "mesh",
-    mesh: {
-      bootstrapNodes,
-      identityPath: options.identityPath
-    }
-  };
-}
-
-export { RoutingTable, probeTopology };
-//# sourceMappingURL=chunk-V47P2AQR.js.map
-//# sourceMappingURL=chunk-V47P2AQR.js.map