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

package/dist/chunk-K3DGJLUY.js

@@ -1,106 +0,0 @@
-// src/utils/logger.ts
-var LiopLogger = class _LiopLogger {
-  static instance;
-  level = "info";
-  interceptor;
-  _isIntercepting = false;
-  constructor() {
-    this.setLevelFromEnv();
-  }
-  static getInstance() {
-    if (!_LiopLogger.instance) {
-      _LiopLogger.instance = new _LiopLogger();
-    }
-    return _LiopLogger.instance;
-  }
-  setLevelFromEnv() {
-    const envLevel = process.env.LIOP_LOG_LEVEL?.toLowerCase();
-    if (envLevel === "silent" || envLevel === "error" || envLevel === "warn" || envLevel === "info" || envLevel === "debug") {
-      this.level = envLevel;
-    } else {
-      this.level = "info";
-    }
-  }
-  setLevel(level) {
-    this.level = level;
-  }
-  /**
-   * Registers a technology-agnostic log interceptor.
-   * Pass `undefined` to disable interception (zero overhead).
-   */
-  setInterceptor(interceptor) {
-    this.interceptor = interceptor;
-  }
-  shouldLog(targetLevel) {
-    const levels = {
-      silent: 0,
-      error: 1,
-      warn: 2,
-      info: 3,
-      debug: 4
-    };
-    return levels[this.level] >= levels[targetLevel];
-  }
-  formatMessage(level, message) {
-    const ts = (/* @__PURE__ */ new Date()).toISOString();
-    return `[${ts}] [${level}] ${message}`;
-  }
-  /**
-   * Fire-and-forget async dispatch to the registered interceptor.
-   * Recursion guard prevents infinite loops when the interceptor
-   * itself triggers logging (directly or transitively).
-   */
-  emitToInterceptor(level, formattedMessage, args) {
-    if (!this.interceptor || this._isIntercepting) return;
-    this._isIntercepting = true;
-    const event = Object.freeze({
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      level,
-      message: formattedMessage,
-      args: Object.freeze([...args])
-    });
-    try {
-      const result = this.interceptor(event);
-      if (result && typeof result === "object" && "catch" in result) {
-        result.catch(() => {
-        });
-      }
-    } catch {
-    } finally {
-      this._isIntercepting = false;
-    }
-  }
-  error(message, ...args) {
-    if (this.shouldLog("error")) {
-      const formatted = this.formatMessage("ERROR", message);
-      console.error(formatted, ...args);
-      this.emitToInterceptor("error", formatted, args);
-    }
-  }
-  warn(message, ...args) {
-    if (this.shouldLog("warn")) {
-      const formatted = this.formatMessage("WARN", message);
-      console.error(formatted, ...args);
-      this.emitToInterceptor("warn", formatted, args);
-    }
-  }
-  info(message, ...args) {
-    if (this.shouldLog("info")) {
-      const formatted = this.formatMessage("INFO", message);
-      console.error(formatted, ...args);
-      this.emitToInterceptor("info", formatted, args);
-    }
-  }
-  debug(message, ...args) {
-    if (this.shouldLog("debug")) {
-      const formatted = this.formatMessage("DEBUG", message);
-      console.error(formatted, ...args);
-      this.emitToInterceptor("debug", formatted, args);
-    }
-  }
-};
-var log = LiopLogger.getInstance();
-
-export { LiopLogger, log };
-//# sourceMappingURL=chunk-K3DGJLUY.js.map
-//# sourceMappingURL=chunk-K3DGJLUY.js.map

package/dist/chunk-KR5UZUEY.js

@@ -1,98 +0,0 @@
-import { z } from 'zod';
-
-// src/types.ts
-
-// src/gateway/mcp-compat.ts
-var MCP_LEGACY_SUPPORT_ENABLED = true;
-var MCP_PROTOCOL_VERSION_LEGACY = "2025-11-25";
-function buildLegacyInitializeResponse(serverInfo, id) {
-  return {
-    jsonrpc: "2.0",
-    id: id ?? null,
-    result: {
-      protocolVersion: MCP_PROTOCOL_VERSION_LEGACY,
-      capabilities: {
-        tools: { listChanged: true },
-        resources: { listChanged: true },
-        prompts: { listChanged: true }
-      },
-      serverInfo
-    }
-  };
-}
-function isLegacyRequest(request) {
-  if (request.method === "initialize" || request.method === "notifications/initialized") {
-    return true;
-  }
-  const params = request.params;
-  const meta = params?._meta;
-  const version = meta?.["io.modelcontextprotocol/protocolVersion"];
-  if (!version || version === MCP_PROTOCOL_VERSION_LEGACY) {
-    return true;
-  }
-  return false;
-}
-function adaptResponseForLegacyClient(response) {
-  if (!response.result || typeof response.result !== "object") {
-    return response;
-  }
-  const rawResult = { ...response.result };
-  delete rawResult.resultType;
-  delete rawResult.ttlMs;
-  delete rawResult.cacheScope;
-  return {
-    ...response,
-    result: rawResult
-  };
-}
-var TOOL_ALIASES = {
-  bank_tool: "Analyze_Synthetic_Bank_Transactions",
-  bank_tool_XDwd: "Analyze_Synthetic_Bank_Transactions",
-  vault_tool: "Analyze_Synthetic_Medical_Records",
-  vault_tool_E8wP: "Analyze_Synthetic_Medical_Records",
-  oracle_tool: "Analyze_HFT_Market_Data",
-  compute_aggregate: "Analyze_Synthetic_Bank_Transactions"
-};
-function normalizeToolArguments(args) {
-  if (!args) return {};
-  const normalized = { ...args };
-  if (normalized.data !== void 0) {
-    if (normalized.payload === void 0) {
-      normalized.payload = normalized.data;
-    }
-    if (normalized.envelope === void 0) {
-      normalized.envelope = normalized.data;
-    }
-  }
-  return normalized;
-}
-
-// src/types.ts
-var MCP_PROTOCOL_VERSION = "2026-07-28";
-var ToolSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  inputSchema: z.record(z.string(), z.unknown())
-  // Represents a JSON Schema
-});
-var ResourceSchema = z.object({
-  uri: z.string(),
-  name: z.string(),
-  description: z.string().optional(),
-  mimeType: z.string().optional()
-});
-var PromptSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  arguments: z.array(
-    z.object({
-      name: z.string(),
-      description: z.string().optional(),
-      required: z.boolean().optional()
-    })
-  ).optional()
-});
-
-export { MCP_LEGACY_SUPPORT_ENABLED, MCP_PROTOCOL_VERSION, MCP_PROTOCOL_VERSION_LEGACY, PromptSchema, ResourceSchema, TOOL_ALIASES, ToolSchema, adaptResponseForLegacyClient, buildLegacyInitializeResponse, isLegacyRequest, normalizeToolArguments };
-//# sourceMappingURL=chunk-KR5UZUEY.js.map
-//# sourceMappingURL=chunk-KR5UZUEY.js.map

package/dist/chunk-NXCAFF73.js

@@ -1,59 +0,0 @@
-// src/security/rbac.ts
-var SCOPE_MAP = {
-  // Protocol lifecycle — unauthenticated (MCP spec compliance)
-  initialize: [],
-  "notifications/initialized": [],
-  "notifications/cancelled": [],
-  ping: [],
-  "server/discover": [],
-  "subscriptions/listen": [],
-  // Tool operations — require explicit authorization
-  "tools/list": ["liop:tools:list"],
-  "tools/call": ["liop:tools:call"],
-  // Resource operations — read-level access
-  "resources/list": ["liop:resources:read"],
-  "resources/read": ["liop:resources:read"],
-  "resources/templates/list": ["liop:resources:read"],
-  // Prompt/schema operations — schema-level access
-  "prompts/list": ["liop:schema:read"],
-  "prompts/get": ["liop:schema:read"]
-};
-function authorizeRequest(method, auth, additionalScopes) {
-  const methodScopes = SCOPE_MAP[method];
-  if (methodScopes !== void 0 && methodScopes.length === 0) {
-    return { allowed: true };
-  }
-  if (!auth) {
-    return {
-      allowed: false,
-      reason: `Authentication required for method: ${method}`
-    };
-  }
-  const needed = [...methodScopes ?? [], ...additionalScopes ?? []];
-  if (needed.length === 0) {
-    return {
-      allowed: false,
-      reason: `Unknown method: ${method}. Access denied (fail-closed).`
-    };
-  }
-  const clientScopes = new Set(auth.scopes);
-  const missing = needed.filter((s) => !clientScopes.has(s));
-  if (missing.length > 0) {
-    return {
-      allowed: false,
-      reason: `Insufficient scopes for ${method}. Missing: ${missing.join(", ")}`
-    };
-  }
-  return { allowed: true };
-}
-var LIOP_SCOPES = [
-  "liop:tools:list",
-  "liop:tools:call",
-  "liop:resources:read",
-  "liop:schema:read",
-  "liop:mesh:query"
-];
-
-export { LIOP_SCOPES, authorizeRequest };
-//# sourceMappingURL=chunk-NXCAFF73.js.map
-//# sourceMappingURL=chunk-NXCAFF73.js.map

package/dist/chunk-Q3FKHJ3B.js

@@ -1,345 +0,0 @@
-// src/observability/metrics.ts
-function formatLabels(labels) {
-  if (!labels || Object.keys(labels).length === 0) {
-    return "";
-  }
-  const entries = Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}="${String(v).replace(/"/g, '\\"')}"`);
-  return `{${entries.join(",")}}`;
-}
-function labelsToKey(labels) {
-  if (!labels) return "";
-  return Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}:${v}`).join("|");
-}
-var Counter = class {
-  constructor(name, help) {
-    this.name = name;
-    this.help = help;
-  }
-  name;
-  help;
-  values = /* @__PURE__ */ new Map();
-  inc(labels, value = 1) {
-    if (value < 0) {
-      throw new Error("Counter increments must be non-negative");
-    }
-    const key = labelsToKey(labels);
-    const current = this.values.get(key) || { value: 0, labels };
-    current.value += value;
-    this.values.set(key, current);
-  }
-  get(labels) {
-    const key = labelsToKey(labels);
-    return this.values.get(key)?.value || 0;
-  }
-  reset() {
-    this.values.clear();
-  }
-  toPrometheus() {
-    const lines = [
-      `# HELP ${this.name} ${this.help}`,
-      `# TYPE ${this.name} counter`
-    ];
-    if (this.values.size === 0) {
-      lines.push(`${this.name} 0`);
-      return lines;
-    }
-    for (const entry of this.values.values()) {
-      lines.push(`${this.name}${formatLabels(entry.labels)} ${entry.value}`);
-    }
-    return lines;
-  }
-};
-var Gauge = class {
-  constructor(name, help) {
-    this.name = name;
-    this.help = help;
-  }
-  name;
-  help;
-  values = /* @__PURE__ */ new Map();
-  set(labelsOrValue, maybeValue) {
-    if (typeof labelsOrValue === "number") {
-      this.values.set("", { value: labelsOrValue });
-      return;
-    }
-    const labels = labelsOrValue;
-    const val = typeof maybeValue === "number" ? maybeValue : 0;
-    const key = labelsToKey(labels);
-    this.values.set(key, { value: val, labels });
-  }
-  inc(labels, value = 1) {
-    const key = labelsToKey(labels);
-    const current = this.values.get(key) || { value: 0, labels };
-    current.value += value;
-    this.values.set(key, current);
-  }
-  dec(labels, value = 1) {
-    const key = labelsToKey(labels);
-    const current = this.values.get(key) || { value: 0, labels };
-    current.value -= value;
-    this.values.set(key, current);
-  }
-  get(labels) {
-    const key = labelsToKey(labels);
-    return this.values.get(key)?.value || 0;
-  }
-  reset() {
-    this.values.clear();
-  }
-  toPrometheus() {
-    const lines = [
-      `# HELP ${this.name} ${this.help}`,
-      `# TYPE ${this.name} gauge`
-    ];
-    if (this.values.size === 0) {
-      lines.push(`${this.name} 0`);
-      return lines;
-    }
-    for (const entry of this.values.values()) {
-      lines.push(`${this.name}${formatLabels(entry.labels)} ${entry.value}`);
-    }
-    return lines;
-  }
-};
-var Histogram = class {
-  constructor(name, help, buckets = [5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4]) {
-    this.name = name;
-    this.help = help;
-    this.buckets = [...buckets].sort((a, b) => a - b);
-  }
-  name;
-  help;
-  buckets;
-  observations = /* @__PURE__ */ new Map();
-  observe(labelsOrValue, maybeValue) {
-    let labels;
-    let val;
-    if (typeof labelsOrValue === "number") {
-      val = labelsOrValue;
-    } else {
-      labels = labelsOrValue;
-      val = typeof maybeValue === "number" ? maybeValue : 0;
-    }
-    const key = labelsToKey(labels);
-    let state = this.observations.get(key);
-    if (!state) {
-      state = {
-        count: 0,
-        sum: 0,
-        bucketCounts: new Map(this.buckets.map((b) => [b, 0])),
-        labels
-      };
-      this.observations.set(key, state);
-    }
-    state.count += 1;
-    state.sum += val;
-    for (const bound of this.buckets) {
-      if (val <= bound) {
-        const cur = state.bucketCounts.get(bound) || 0;
-        state.bucketCounts.set(bound, cur + 1);
-      }
-    }
-  }
-  reset() {
-    this.observations.clear();
-  }
-  toPrometheus() {
-    const lines = [
-      `# HELP ${this.name} ${this.help}`,
-      `# TYPE ${this.name} histogram`
-    ];
-    if (this.observations.size === 0) {
-      lines.push(`${this.name}_count 0`);
-      lines.push(`${this.name}_sum 0`);
-      return lines;
-    }
-    for (const state of this.observations.values()) {
-      const baseLabels = state.labels || {};
-      for (const bound of this.buckets) {
-        const bucketLabels = { ...baseLabels, le: String(bound) };
-        lines.push(
-          `${this.name}_bucket${formatLabels(bucketLabels)} ${state.bucketCounts.get(bound) || 0}`
-        );
-      }
-      const infLabels = { ...baseLabels, le: "+Inf" };
-      lines.push(
-        `${this.name}_bucket${formatLabels(infLabels)} ${state.count}`
-      );
-      lines.push(`${this.name}_sum${formatLabels(baseLabels)} ${state.sum}`);
-      lines.push(
-        `${this.name}_count${formatLabels(baseLabels)} ${state.count}`
-      );
-    }
-    return lines;
-  }
-};
-var MetricsRegistry = class {
-  counters = /* @__PURE__ */ new Map();
-  gauges = /* @__PURE__ */ new Map();
-  histograms = /* @__PURE__ */ new Map();
-  counter(name, help) {
-    let c = this.counters.get(name);
-    if (!c) {
-      c = new Counter(name, help);
-      this.counters.set(name, c);
-    }
-    return c;
-  }
-  gauge(name, help) {
-    let g = this.gauges.get(name);
-    if (!g) {
-      g = new Gauge(name, help);
-      this.gauges.set(name, g);
-    }
-    return g;
-  }
-  histogram(name, help, buckets) {
-    let h = this.histograms.get(name);
-    if (!h) {
-      h = new Histogram(name, help, buckets);
-      this.histograms.set(name, h);
-    }
-    return h;
-  }
-  collectProcessMetrics() {
-    const uptime = this.gauge(
-      "liop_process_uptime_seconds",
-      "Process uptime in seconds"
-    );
-    uptime.set(Math.floor(process.uptime()));
-    const health = this.gauge(
-      "liop_node_health_status",
-      "Operational health status of the LIOP node (1 = healthy, 0 = degraded)"
-    );
-    health.set(1);
-    if (typeof process.memoryUsage === "function") {
-      const mem = process.memoryUsage();
-      const rss = this.gauge(
-        "liop_process_memory_rss_bytes",
-        "Resident set size memory in bytes"
-      );
-      rss.set(mem.rss);
-      const heapUsed = this.gauge(
-        "liop_process_memory_heap_used_bytes",
-        "Heap memory used in bytes"
-      );
-      heapUsed.set(mem.heapUsed);
-      const heapTotal = this.gauge(
-        "liop_process_memory_heap_total_bytes",
-        "Total V8 allocated heap memory in bytes"
-      );
-      heapTotal.set(mem.heapTotal);
-      const external = this.gauge(
-        "liop_process_memory_external_bytes",
-        "External memory bound to C++ objects and buffers in bytes"
-      );
-      external.set(mem.external);
-    }
-  }
-  exportPrometheusText() {
-    this.collectProcessMetrics();
-    const lines = [];
-    for (const c of this.counters.values()) {
-      lines.push(...c.toPrometheus());
-    }
-    for (const g of this.gauges.values()) {
-      lines.push(...g.toPrometheus());
-    }
-    for (const h of this.histograms.values()) {
-      lines.push(...h.toPrometheus());
-    }
-    lines.push("");
-    return lines.join("\n");
-  }
-  resetAll() {
-    for (const c of this.counters.values()) c.reset();
-    for (const g of this.gauges.values()) g.reset();
-    for (const h of this.histograms.values()) h.reset();
-  }
-};
-var protocolMetrics = new MetricsRegistry();
-var toolCallsTotal = protocolMetrics.counter(
-  "liop_tool_calls_total",
-  "Total number of tool logic-injection executions"
-);
-var toolCallErrorsTotal = protocolMetrics.counter(
-  "liop_tool_call_errors_total",
-  "Total number of failed tool logic-injection executions or policy rejections"
-);
-var fuelConsumed = protocolMetrics.histogram(
-  "liop_fuel_consumed_total",
-  "Deterministic fuel units consumed by injected logic",
-  [100, 500, 1e3, 2500, 5e3, 1e4, 5e4, 1e5]
-);
-var meshPeersConnected = protocolMetrics.gauge(
-  "liop_mesh_peers_connected",
-  "Active peer connections in the P2P mesh"
-);
-var manifestCacheSize = protocolMetrics.gauge(
-  "liop_manifest_cache_size",
-  "Number of verified remote tool manifests in cache"
-);
-var egressBlocksTotal = protocolMetrics.counter(
-  "liop_egress_blocks_total",
-  "Total number of outputs blocked by Egress Shield"
-);
-var zkVerificationDurationMs = protocolMetrics.histogram(
-  "liop_zk_verification_duration_ms",
-  "Duration of ZK-Receipt and HMAC cryptographic attestation in ms",
-  [1, 2, 5, 10, 25, 50, 100, 250, 500]
-);
-var zkVerificationsTotal = protocolMetrics.counter(
-  "liop_zk_verifications_total",
-  "Total number of ZK-Receipt cryptographic attestation checks"
-);
-var zkProofsByTypeTotal = protocolMetrics.counter(
-  "liop_zk_proofs_by_type_total",
-  "Total number of verified ZK receipts partitioned by proof type (groth16, hmac)"
-);
-var zkProvingDurationMs = protocolMetrics.histogram(
-  "liop_zk_proving_duration_ms",
-  "Duration of native ZK proof generation in ms",
-  [10, 25, 50, 100, 250, 500, 1e3, 2500]
-);
-var zkVkeyCacheSize = protocolMetrics.gauge(
-  "liop_zk_vkey_cache_size",
-  "Number of registered verification keys in memory cache"
-);
-var tokensInputTotal = protocolMetrics.counter(
-  "liop_tokens_input_total",
-  "Total BPE input tokens processed by LIOP"
-);
-var tokensOutputTotal = protocolMetrics.counter(
-  "liop_tokens_output_total",
-  "Total BPE output tokens emitted by LIOP"
-);
-var tokensSavedTotal = protocolMetrics.counter(
-  "liop_tokens_saved_total",
-  "Estimated tokens saved compared to MCP context-pulling baseline"
-);
-var operationDurationMs = protocolMetrics.histogram(
-  "liop_operation_duration_ms",
-  "End-to-end operation duration in ms",
-  [5, 15, 30, 50, 100, 250, 500, 1e3, 2500, 5e3]
-);
-var pqcHandshakeDurationMs = protocolMetrics.histogram(
-  "liop_pqc_handshake_duration_ms",
-  "Duration of ML-KEM-768 post-quantum cryptographic key encapsulation in ms",
-  [1, 5, 10, 25, 50, 100, 250, 500]
-);
-var pqcHandshakesTotal = protocolMetrics.counter(
-  "liop_pqc_handshakes_total",
-  "Total number of ML-KEM-768 key encapsulation operations"
-);
-var wireEgressBytesTotal = protocolMetrics.counter(
-  "liop_wire_egress_bytes_total",
-  "Total wire egress bytes emitted by logic executions"
-);
-var wireSavedBytesTotal = protocolMetrics.counter(
-  "liop_wire_saved_bytes_total",
-  "Estimated wire egress bytes saved compared to MCP context extraction baseline"
-);
-
-export { Counter, Gauge, Histogram, MetricsRegistry, egressBlocksTotal, fuelConsumed, manifestCacheSize, meshPeersConnected, operationDurationMs, pqcHandshakeDurationMs, pqcHandshakesTotal, protocolMetrics, tokensInputTotal, tokensOutputTotal, tokensSavedTotal, toolCallErrorsTotal, toolCallsTotal, wireEgressBytesTotal, wireSavedBytesTotal, zkProofsByTypeTotal, zkProvingDurationMs, zkVerificationDurationMs, zkVerificationsTotal, zkVkeyCacheSize };
-//# sourceMappingURL=chunk-Q3FKHJ3B.js.map
-//# sourceMappingURL=chunk-Q3FKHJ3B.js.map