@nekzus/liop 1.0.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,810 @@
+export { LiopBridgeOptions, LiopMcpBridge, LiopStreamBridge, LiopStreamBridgeOptions } from './bridge.js';
+import { L as LiopTlsOptions } from './index-CX43dvMs.js';
+export { C as CertInfo, a as CertManager, b as CertManagerOptions, c as LiopClient } from './index-CX43dvMs.js';
+import * as http from 'node:http';
+export { I as InMemoryRateLimiter, L as LiopHybridGateway, a as LiopMcpRouter, R as RateLimitStatus, b as RateLimiterOptions } from './hybrid-CrKB50nh.js';
+export { L as LiopManifest, a as MeshNode, M as MeshNodeConfig } from './node-B0b2vUFS.js';
+export { SWARM_KEY_BYTE_LENGTH, createSwarmKey, deserializeSwarmKey, loadSwarmKey, parseSwarmKey, saveSwarmKey, serializeSwarmKey } from './mesh.js';
+import * as grpc from '@grpc/grpc-js';
+export { A as AUTH_DEFAULTS, b as AggregationPolicy, c as AuditEntry, d as AuditLogger, e as AuditRecordParams, f as AuditStatus, g as AuthRole, G as GENESIS_HASH, h as LiopAuthConfig, L as LiopServer, a as LiopServerOptions, i as LogicExecutionPolicy, N as NerScanner, O as OAuthClientConfig, j as OutputSanitizerConfig, P as PII_PATTERNS, k as PII_PRESETS, l as PiiRule, m as PiiScanner, T as ToolHandler, n as computeEntryHash, o as globalAuditLogger, s as sanitizeOutput } from './index-DoW2gzBZ.js';
+import { A as AuthInfo } from './types-lJIxBlWF.js';
+export { e as CacheableResult, C as CallToolRequest, a as CallToolResult, D as DiscoverResult, G as GetPromptRequest, d as GetPromptResult, I as InputRequest, f as InputRequiredResult, g as InputResponse, J as JwtValidator, h as MCP_LEGACY_SUPPORT_ENABLED, i as MCP_PROTOCOL_VERSION, j as MCP_PROTOCOL_VERSION_LEGACY, M as McpEra, b as McpRequest, k as McpRequestMeta, c as McpResponse, P as Prompt, l as PromptSchema, R as Resource, m as ResourceSchema, S as ServerInfo, T as Tool, n as ToolSchema } from './types-lJIxBlWF.js';
+import * as jose from 'jose';
+import Provider from 'oidc-provider';
+import '@modelcontextprotocol/sdk/server/mcp.js';
+import 'zod';
+import './verifier-COnid_dg.js';
+import 'node:events';
+
+/**
+ * TokenEstimator — Pluggable strategy for counting tokens in text content.
+ *
+ * Implementations range from exact BPE tokenization to lightweight heuristics,
+ * allowing the SDK to choose the best trade-off for the runtime environment.
+ */
+interface TokenEstimator {
+    /** Count the number of tokens in the given text */
+    countTokens(text: string): number;
+    /** Human-readable name of the estimation strategy */
+    readonly name: string;
+}
+/**
+ * Exact BPE tokenizer using inlined o200k_base encoding.
+ *
+ * o200k_base is the standard encoding for all modern OpenAI models
+ * (GPT-4o, GPT-4.1, o1, o3, o4) and provides a reasonable baseline
+ * for Anthropic/Google models as well (~±5% variance).
+ *
+ * - Synchronous: safe for hot-path usage without async overhead
+ * - Merge cache reduced to 10K entries for long-running server processes
+ * - Inlined at build-time: zero external runtime dependencies in node_modules
+ */
+declare class RealTokenEstimator implements TokenEstimator {
+    readonly name = "o200k_base";
+    private countFn;
+    constructor(countFn: (text: string) => number, setMergeCacheSizeFn?: (size: number) => void);
+    countTokens(text: string): number;
+}
+/**
+ * Fallback heuristic estimator: ~4 characters per token.
+ *
+ * Industry-standard approximation (±10% for English/code content).
+ * Used only when tokenizer fails in constrained environments.
+ */
+declare class HeuristicTokenEstimator implements TokenEstimator {
+    readonly name = "heuristic (chars/4)";
+    countTokens(text: string): number;
+}
+/**
+ * Factory: creates a RealTokenEstimator with inlined o200k_base,
+ * falling back to HeuristicTokenEstimator if an unexpected error occurs.
+ */
+declare function createTokenEstimator(): Promise<TokenEstimator>;
+/**
+ * Synchronous factory: creates a RealTokenEstimator immediately.
+ */
+declare function createSyncTokenEstimator(): TokenEstimator;
+
+/**
+ * LiopOTelBridge — OpenTelemetry gen_ai.* metric emitter.
+ *
+ * Pattern: Library Instrumentation (uses global MeterProvider only).
+ * Per official OTel JS documentation:
+ * - Libraries MUST NOT create their own MeterProvider
+ * - Libraries SHOULD use metrics.getMeter() from the global API
+ * - If no MeterProvider is registered by the application, all operations are NoOp
+ *   with zero runtime overhead (confirmed by OTel JS source: NoopMeterProvider)
+ *
+ * Follows OpenTelemetry Generative AI Semantic Conventions (Development status).
+ * @see https://opentelemetry.io/docs/specs/semconv/gen-ai/
+ */
+declare class LiopOTelBridge {
+    private tokenUsage;
+    private operationDuration;
+    private active;
+    constructor();
+    /**
+     * Record token usage with gen_ai.* standard attributes.
+     *
+     * @param tokens - Number of tokens consumed
+     * @param tokenType - "input" or "output" (gen_ai.token.type)
+     * @param operationName - gen_ai.operation.name (e.g., "execute_tool", "chat")
+     * @param toolName - Optional LIOP-specific tool name for attribution
+     */
+    recordTokens(tokens: number, tokenType: "input" | "output", operationName: string, toolName?: string): void;
+    /**
+     * Record operation duration with gen_ai.* standard attributes.
+     *
+     * @param durationMs - Duration in milliseconds (converted to seconds for OTel)
+     * @param operationName - gen_ai.operation.name
+     * @param error - Optional error type string if the operation failed
+     */
+    recordDuration(durationMs: number, operationName: string, error?: string): void;
+    /** Whether the OTel bridge is actively connected to a MeterProvider */
+    isActive(): boolean;
+}
+
+/** Single MCP operation token footprint */
+interface TokenOperationMetric {
+    readonly type: "tools_list" | "tool_call" | "resource_read" | "resource_list" | "prompt_get" | "prompt_list" | "diagnostic";
+    readonly method: string;
+    readonly estimatedInputTokens: number;
+    readonly estimatedOutputTokens: number;
+    readonly timestamp: number;
+    readonly toolName?: string;
+    readonly peerId?: string;
+    readonly durationMs?: number;
+    readonly originDatasetTokens?: number;
+}
+/** Session-level aggregate report */
+interface TokenSessionReport {
+    readonly sessionId: string;
+    readonly operations: ReadonlyArray<TokenOperationMetric>;
+    readonly totalInputTokens: number;
+    readonly totalOutputTokens: number;
+    readonly estimatorName: string;
+    readonly sessionUptimeMs: number;
+}
+/** Per-tool aggregate breakdown */
+interface ToolTokenBreakdown {
+    readonly input: number;
+    readonly output: number;
+    readonly calls: number;
+    readonly avgDurationMs: number;
+}
+/**
+ * TokenTelemetryEngine — Full-spectrum observational singleton for token cost measurement.
+ *
+ * Design principles:
+ * - Pure observer pattern: NEVER mutates MCP payloads or protocol flow.
+ * - Real tokenization: o200k_base BPE via gpt-tokenizer (async init, sync counting).
+ * - OTel gen_ai.* emission: standard metrics via @opentelemetry/api (NoOp if no provider).
+ * - Error isolation: telemetry failures never propagate to protocol operations.
+ */
+declare class TokenTelemetryEngine {
+    private static instance;
+    private operations;
+    private readonly sessionId;
+    private readonly startedAt;
+    private estimator;
+    private otelBridge;
+    private constructor();
+    /** Async upgrade from heuristic to real BPE tokenizer */
+    private initRealEstimator;
+    static getInstance(): TokenTelemetryEngine;
+    /**
+     * Count tokens in a string using the active estimator.
+     * Delegates to o200k_base BPE tokenizer (or heuristic fallback).
+     */
+    countTokens(content: string): number;
+    /**
+     * Record a single MCP operation's token footprint.
+     * Emits both internal metrics and OTel gen_ai.* histograms.
+     */
+    record(metric: Omit<TokenOperationMetric, "timestamp">): void;
+    /**
+     * @deprecated Use countTokens() instead. Kept for backward compatibility.
+     */
+    estimateTokens(content: string): number;
+    /** Generate the full session report */
+    getReport(): TokenSessionReport;
+    /** Get per-tool token breakdown for diagnostic display */
+    getPerToolReport(): Map<string, ToolTokenBreakdown>;
+    /**
+     * Format a rich, human-readable summary block for LiopMeshStatus diagnostic.
+     * Returns empty string when no operations have been recorded.
+     */
+    formatStatusBlock(): string;
+    /** Format milliseconds into human-readable uptime string */
+    private formatUptime;
+    /** Reset all recorded metrics (used in tests) */
+    reset(): void;
+    /** Destroy the singleton (used in tests to guarantee isolation) */
+    static destroy(): void;
+}
+
+declare enum ErrorCode {
+    CapabilityViolation = "CapabilityViolation",
+    SandboxEscape = "SandboxEscape",
+    PiiLeak = "PiiLeak",
+    InvalidIntent = "InvalidIntent",
+    Throttled = "Throttled",
+    ZkVerificationFailed = "ZkVerificationFailed",
+    MeshUnavailable = "MeshUnavailable",
+    ConnectionFailed = "ConnectionFailed"
+}
+declare class LiopError extends Error {
+    readonly code: ErrorCode;
+    constructor(code: ErrorCode, message: string);
+}
+
+/**
+ * LIOP gRPC-Web Protocol Adapter (HTTP/1.1 Fallback)
+ *
+ * Implements standard gRPC-Web framing per the official gRPC-Web specification:
+ * https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-WEB.md
+ *
+ * Allows web browsers, corporate Layer 7 HTTP/1.1 proxies, and enterprise WAFs
+ * to invoke LIOP nodes over HTTP/1.1 without requiring HTTP/2 streaming or h2c.
+ *
+ * Frame Format:
+ * - 1 byte: Frame Flag (0x00 = Data Frame, 0x80 = Trailers Frame)
+ * - 4 bytes: 32-bit Big-Endian Unsigned Integer (payload length in bytes)
+ * - N bytes: Message or Trailer payload
+ */
+
+declare const GRPC_WEB_CONSTANTS: {
+    readonly FLAG_DATA: 0;
+    readonly FLAG_TRAILERS: 128;
+    readonly HEADER_LENGTH: 5;
+    readonly CONTENT_TYPE_PREFIX: "application/grpc-web";
+    readonly STATUS_OK: 0;
+    readonly STATUS_CANCELLED: 1;
+    readonly STATUS_UNKNOWN: 2;
+    readonly STATUS_INVALID_ARGUMENT: 3;
+    readonly STATUS_DEADLINE_EXCEEDED: 4;
+    readonly STATUS_NOT_FOUND: 5;
+    readonly STATUS_PERMISSION_DENIED: 7;
+    readonly STATUS_UNAUTHENTICATED: 16;
+    readonly STATUS_INTERNAL: 13;
+};
+interface GrpcWebFrame {
+    isTrailer: boolean;
+    payload: Buffer;
+}
+/**
+ * Checks if an incoming HTTP request is a gRPC-Web request.
+ */
+declare function isGrpcWebRequest(contentType?: string): boolean;
+/**
+ * Encodes a binary payload into a standard 5-byte framed gRPC-Web Data Frame.
+ */
+declare function encodeDataFrame(payload: Buffer | Uint8Array): Buffer;
+/**
+ * Encodes gRPC status and optional message into a 5-byte framed gRPC-Web Trailer Frame.
+ */
+declare function encodeTrailerFrame(status?: number, message?: string, customTrailers?: Record<string, string>): Buffer;
+/**
+ * Parses raw gRPC-Web byte streams into an array of frames.
+ */
+declare function decodeFrames(buffer: Buffer): GrpcWebFrame[];
+/**
+ * Dispatches an HTTP/1.1 gRPC-Web request to an underlying protocol handler
+ * and serializes data and trailer frames back to the client.
+ */
+declare function dispatchGrpcWebRequest(req: http.IncomingMessage, res: http.ServerResponse, handler: (path: string, payload: Buffer) => Promise<{
+    status: number;
+    message?: string;
+    data?: Buffer;
+}>): Promise<void>;
+
+/**
+ * LIOP Prometheus Metrics Registry (Phase Beta-3)
+ * Lightweight, zero-dependency, high-performance metrics collector
+ * complying with Prometheus and OpenMetrics exposition format.
+ */
+type MetricLabels = Record<string, string | number>;
+interface MetricDefinition {
+    name: string;
+    help: string;
+    type: "counter" | "gauge" | "histogram";
+    buckets?: number[];
+}
+declare class Counter {
+    readonly name: string;
+    readonly help: string;
+    private values;
+    constructor(name: string, help: string);
+    inc(labels?: MetricLabels, value?: number): void;
+    get(labels?: MetricLabels): number;
+    reset(): void;
+    toPrometheus(): string[];
+}
+declare class Gauge {
+    readonly name: string;
+    readonly help: string;
+    private values;
+    constructor(name: string, help: string);
+    set(labelsOrValue: MetricLabels | number, maybeValue?: number): void;
+    inc(labels?: MetricLabels, value?: number): void;
+    dec(labels?: MetricLabels, value?: number): void;
+    get(labels?: MetricLabels): number;
+    reset(): void;
+    toPrometheus(): string[];
+}
+declare class Histogram {
+    readonly name: string;
+    readonly help: string;
+    readonly buckets: number[];
+    private observations;
+    constructor(name: string, help: string, buckets?: number[]);
+    observe(labelsOrValue: MetricLabels | number, maybeValue?: number): void;
+    reset(): void;
+    toPrometheus(): string[];
+}
+declare class MetricsRegistry {
+    private counters;
+    private gauges;
+    private histograms;
+    counter(name: string, help: string): Counter;
+    gauge(name: string, help: string): Gauge;
+    histogram(name: string, help: string, buckets?: number[]): Histogram;
+    collectProcessMetrics(): void;
+    exportPrometheusText(): string;
+    resetAll(): void;
+}
+declare const protocolMetrics: MetricsRegistry;
+declare const toolCallsTotal: Counter;
+declare const toolCallErrorsTotal: Counter;
+declare const fuelConsumed: Histogram;
+declare const meshPeersConnected: Gauge;
+declare const manifestCacheSize: Gauge;
+declare const egressBlocksTotal: Counter;
+declare const zkVerificationDurationMs: Histogram;
+declare const zkVerificationsTotal: Counter;
+declare const tokensInputTotal: Counter;
+declare const tokensOutputTotal: Counter;
+declare const tokensSavedTotal: Counter;
+declare const operationDurationMs: Histogram;
+declare const pqcHandshakeDurationMs: Histogram;
+declare const pqcHandshakesTotal: Counter;
+declare const wireEgressBytesTotal: Counter;
+declare const wireSavedBytesTotal: Counter;
+
+interface SpanContext {
+    traceId: string;
+    spanId: string;
+    sampled: boolean;
+}
+interface LiopSpan {
+    readonly name: string;
+    readonly context: SpanContext;
+    readonly startTime: number;
+    endTime?: number;
+    attributes: Record<string, string | number | boolean>;
+    status: "OK" | "ERROR";
+    error?: string;
+    setAttribute(key: string, value: string | number | boolean): LiopSpan;
+    recordException(error: Error | string): LiopSpan;
+    end(): void;
+}
+declare class LiopTracer {
+    static generateTraceId(): string;
+    static generateSpanId(): string;
+    static formatTraceparent(traceId: string, spanId: string, sampled?: boolean): string;
+    static parseTraceparent(header?: string | null): SpanContext | null;
+    static injectTraceparent(carrier: Record<string, string | string[] | undefined>, context: SpanContext): void;
+    static extractTraceparent(carrier: Record<string, string | string[] | undefined>): SpanContext | null;
+    startSpan(name: string, parent?: SpanContext | null, attributes?: Record<string, string | number | boolean>): LiopSpan;
+}
+declare const defaultTracer: LiopTracer;
+
+/**
+ * LIOP Cross-AI Prompt Adapters (Fase 92)
+ *
+ * Normalizes system instructions for different LLM providers (Claude, OpenAI, Gemini)
+ * to ensure they understand how to generate "Logic-on-Origin" WASM-compatible payload structures.
+ */
+type AIProvider = "claude" | "openai" | "gemini";
+interface PromptConfig {
+    xmlStandard: boolean;
+    jsonSchemaPreferred: boolean;
+}
+/**
+ * Generates specific System Prompts optimized for the provided AI.
+ * This instructs the LLM on how to bypass Context-Pulling and use Logic-Injection (Zero-Shot).
+ */
+declare function generateSystemInstructions(provider: AIProvider): string;
+
+/**
+ * LIOP Production-Grade gRPC Channel Options
+ *
+ * Enforces bidirectional symmetry between LiopRpcServer, LiopRpcClient,
+ * and gateway proxy channels per NIST SP 800-207 continuous verification.
+ * Prevents silent disconnections behind corporate stateful firewalls and NAT gateways.
+ */
+declare const GRPC_CHANNEL_OPTIONS: Readonly<Record<string, string | number>>;
+
+/**
+ * TypeScript interfaces reflecting liop_core.proto (LIOP v1)
+ * Optimized for logic-on-origin and high-performance serialization.
+ */
+interface IntentRequest {
+    agent_did: string;
+    capability_hash: string;
+    proof_of_intent: Uint8Array;
+}
+interface IntentResponse {
+    accepted: boolean;
+    session_token: string;
+    error_message: string;
+    kyber_public_key: Uint8Array;
+}
+interface LogicRequest {
+    session_token: string;
+    wasm_binary: Uint8Array;
+    inputs: Record<string, Uint8Array>;
+    pqc_ciphertext: Uint8Array;
+    aes_nonce: Uint8Array;
+}
+interface LogicResponse {
+    semantic_evidence: string;
+    cryptographic_proof: Uint8Array;
+    zk_receipt: Uint8Array;
+    is_error: boolean;
+}
+
+type TokenProvider = string | (() => Promise<string | undefined> | string | undefined);
+/**
+ * LIOP gRPC Client Implementation
+ * Provides a high-level interface for secure intent negotiation and logic execution.
+ */
+declare class LiopRpcClient {
+    private client;
+    private token?;
+    private lastResolvedToken?;
+    readonly address: string;
+    constructor(address: string, tls?: LiopTlsOptions, token?: TokenProvider);
+    setToken(token?: TokenProvider): void;
+    private resolveToken;
+    /**
+     * Negotiates intent with the remote host.
+     * Returns the ephemeral Kyber public key for payload encryption.
+     */
+    negotiateIntent(request: IntentRequest): Promise<IntentResponse>;
+    /**
+     * Pushes the encrypted Logic-on-Origin payload to the origin.
+     * Returns a stream of semantic responses and ZK proofs.
+     */
+    executeLogic(request: LogicRequest): grpc.ClientReadableStream<LogicResponse>;
+    close(): void;
+}
+
+/**
+ * LIOP Symmetric Payload Encryption Wrapper
+ * Uses AES-256-GCM to secure WASM Code transport over Zero-Trust networks.
+ * Fully compatible with the `aes-gcm` Rust crate used by Wasmtime.
+ */
+declare const AesGcmWrapper: {
+    /**
+     * Encrypts a raw WASM payload using the shared secret negotiated via Kyber768.
+     *
+     * @param payload Raw incoming WASM byte array or string.
+     * @param sharedSecret A perfectly derived 32-byte (256-bit) shared secret array
+     * @returns The encrypted buffer to push to the GRPc stream, along with the 12-byte initialization vector natively generated.
+     */
+    encryptPayload(payload: Uint8Array | Buffer, sharedSecret: Uint8Array): {
+        ciphertext: Buffer;
+        nonce: Buffer;
+    };
+    /**
+     * Decrypts a remote Zero-Knowledge receipt using AES-256-GCM.
+     */
+    decryptPayload(ciphertextBuffer: Buffer, nonce: Buffer, sharedSecret: Uint8Array): Buffer;
+};
+
+declare const DILITHIUM65_CONSTANTS: {
+    readonly PUBLIC_KEY_BYTES: 1952;
+    readonly SECRET_KEY_BYTES: 4032;
+    readonly SIGNATURE_BYTES: 3309;
+    readonly DEFAULT_CONTEXT: Uint8Array<ArrayBuffer>;
+};
+declare const Dilithium65Wrapper: {
+    /** Constants */
+    PUBLIC_KEY_BYTES: 1952;
+    SECRET_KEY_BYTES: 4032;
+    SIGNATURE_BYTES: 3309;
+    /**
+     * Generates a new ML-DSA-65 (FIPS 204) key pair.
+     * Optionally accepts a 32-byte seed for deterministic key generation.
+     */
+    generateKeyPair(seed?: Uint8Array): {
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    };
+    /**
+     * Validates and imports a raw ML-DSA-65 public key.
+     */
+    importPublicKey(buffer: Uint8Array): Uint8Array;
+    /**
+     * Signs a message using the post-quantum secret key.
+     * Supports optional domain separation context (up to 255 bytes).
+     */
+    sign(message: Uint8Array | string, secretKey: Uint8Array, context?: Uint8Array): Uint8Array;
+    /**
+     * Verifies an ML-DSA-65 post-quantum digital signature.
+     */
+    verify(signature: Uint8Array, message: Uint8Array | string, publicKey: Uint8Array, context?: Uint8Array): boolean;
+    /**
+     * Signs a structured manifest (LiopManifest) using canonical JSON serialization.
+     * Returns base64-encoded signature and public key for transport over gRPC/MCP.
+     */
+    signManifest(manifest: Record<string, unknown>, secretKey: Uint8Array, publicKey: Uint8Array): {
+        signature: string;
+        publicKey: string;
+    };
+    /**
+     * Verifies the post-quantum signature of a structured manifest.
+     */
+    verifyManifest(manifest: Record<string, unknown>, signatureBase64: string, publicKeyBase64: string): boolean;
+};
+
+declare const Kyber768Wrapper: {
+    /**
+     * Extracts and validates the 1184-byte Public Key from the Rust LIOP Data Node
+     * @param buffer Raw buffer sent via gRPC IntentResponse
+     */
+    importPublicKey(buffer: Uint8Array): Uint8Array;
+    /**
+     * Encapsulates a shared secret using the server's public key.
+     * Returns the 1088-byte ciphertext to be sent back, and the 32-byte shared AES secret.
+     */
+    encapsulateAsymmetric(publicKey: Uint8Array): Promise<{
+        ciphertext: Uint8Array;
+        sharedSecret: Uint8Array;
+    }>;
+    /**
+     * Generates a Kyber768 KeyPair for the server to accept intents.
+     */
+    generateKeyPair(): Promise<{
+        publicKey: Uint8Array;
+        secretKey: Uint8Array;
+    }>;
+    /**
+     * Decapsulates the shared secret using the server's secret key.
+     * Zero-fills the shared secret buffer after extraction for side-channel protection.
+     */
+    decapsulateSymmetric(ciphertext: Uint8Array, secretKey: Uint8Array): Promise<Uint8Array>;
+};
+
+declare class LiopRpcServer {
+    private server;
+    constructor();
+    addService(handlers: {
+        negotiateIntent: (call: grpc.ServerUnaryCall<IntentRequest, IntentResponse>, callback: grpc.sendUnaryData<IntentResponse>) => void;
+        executeLogic: (call: grpc.ServerWritableStream<LogicRequest, LogicResponse>) => void;
+    }): void;
+    listen(port?: number, tls?: LiopTlsOptions): Promise<number>;
+    gracefulShutdown(timeoutMs?: number): Promise<void>;
+    stop(): Promise<void>;
+}
+
+type TransportProvider = "http-gateway" | "p2p-grpc" | "local";
+interface ToolDefinition {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+}
+interface ToolRoute {
+    name: string;
+    provider: TransportProvider;
+    endpoint: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    latencyMs: number;
+    failCount: number;
+    lastSuccess: number;
+    authRequired?: boolean;
+}
+declare class RoutingTable {
+    private routes;
+    private static readonly MAX_FAILURES;
+    /**
+     * Registers or updates a collection of tools exposed via an HTTP Gateway.
+     */
+    registerGatewayTools(tools: ToolDefinition[], mcpEndpoint: string, authRequired?: boolean): void;
+    /**
+     * Registers tools discovered directly over the P2P Mesh (gRPC).
+     */
+    registerMeshTools(tools: ToolDefinition[], grpcTarget: string, authRequired?: boolean): void;
+    /**
+     * Registers an in-process local tool (e.g. LiopMeshStatus).
+     */
+    registerLocalTool(tool: ToolDefinition): void;
+    /**
+     * Resolves the optimal route for a specific tool.
+     */
+    resolve(toolName: string): ToolRoute | undefined;
+    /**
+     * Records a successful invocation on a route, resetting failures and updating latency.
+     */
+    recordSuccess(toolName: string, latencyMs: number): void;
+    /**
+     * Records a failed invocation on a route.
+     */
+    recordFailure(toolName: string): void;
+    /**
+     * Lists all registered tools in sorted format for tools/list.
+     */
+    getAllToolDefinitions(): ToolDefinition[];
+    getRoute(toolName: string): ToolRoute | undefined;
+    size(): number;
+    clear(): void;
+}
+
+interface TokenManagerOptions {
+    tokenEndpoint: string;
+    clientId: string;
+    clientSecret: string;
+    audience?: string;
+    scopes?: string | string[];
+    staticToken?: string;
+}
+declare class TokenManager {
+    private cachedToken;
+    private expiresAt;
+    private pendingPromise;
+    private readonly tokenEndpoint;
+    private readonly clientId;
+    private readonly clientSecret;
+    private readonly audience;
+    private readonly scope;
+    private staticToken?;
+    private static readonly REFRESH_BUFFER_MS;
+    constructor(options: TokenManagerOptions);
+    /**
+     * Returns a valid OAuth 2.1 access token.
+     * Automatically performs preemptive refresh if the token is close to expiry.
+     */
+    getToken(): Promise<string>;
+    /**
+     * Force-invalidates cached token, e.g. after receiving a 401 Unauthorized response.
+     */
+    invalidate(): void;
+    /**
+     * Returns true if the token is absent or has passed the refresh threshold.
+     */
+    isExpired(): boolean;
+    getExpiresAt(): number;
+    private fetchNewToken;
+}
+
+interface GatewayTopologyInfo {
+    baseUrl: string;
+    mcpEndpoint: string;
+    healthEndpoint: string;
+    tokenEndpoint: string;
+    issuer: string;
+    audience: string;
+    scopes: string[];
+    tools: string[];
+    tier: number;
+}
+interface MeshTopologyInfo {
+    bootstrapNodes: string[];
+    identityPath?: string;
+}
+interface TopologyProbeResult {
+    mode: "gateway" | "mesh" | "hybrid";
+    gateway?: GatewayTopologyInfo;
+    mesh?: MeshTopologyInfo;
+}
+interface TopologyProbeOptions {
+    blgUrl?: string;
+    nexusUrl?: string;
+    clientId?: string;
+    clientSecret?: string;
+    audience?: string;
+    staticToken?: string;
+    bootstrapNodes?: string[];
+    identityPath?: string;
+    autoProbeLocal?: boolean;
+}
+/**
+ * Probes the runtime environment and determines the optimal architecture mode.
+ */
+declare function probeTopology(options?: TopologyProbeOptions): Promise<TopologyProbeResult>;
+
+/**
+ * Returns a filtered environment object containing only safe system variables,
+ * preventing exposure of sensitive credentials and shell function injection.
+ */
+declare function getDefaultEnvironment(): Record<string, string>;
+/**
+ * Calculates deterministic execution fuel units based on AST instruction complexity.
+ * Guarantees identical fuel consumption for the same logic across different hardware.
+ */
+declare function calculateAstInstructionFuel(code: string): number;
+interface SandboxConfig {
+    allowEnv?: boolean;
+    allowedDirectories?: Record<string, string>;
+    memoryLimitMb?: number;
+}
+/**
+ * LIOP WasiSandbox (Industrial Grade)
+ *
+ * Provides a production-grade isolated environment for executing untrusted logic.
+ * Primarily uses WebAssembly (WASI) for byte-code isolation, with a hardened
+ * V8 Isolate fallback for dynamic JS-to-WASM logic injection.
+ */
+declare class WasiSandbox {
+    private wasi;
+    private sandboxId;
+    private workingDir;
+    private config;
+    private stdoutHandle;
+    private stderrHandle;
+    constructor(config?: SandboxConfig);
+    /**
+     * Initializes the physical sandbox environment with strict directory lockdown.
+     */
+    init(): Promise<void>;
+    /**
+     * Executes logic (WASM or JS-Wrapped) with hard resource limits.
+     */
+    execute(compiledLogic: Buffer | string, records?: Record<string, unknown>[], inputs?: Record<string, unknown>): Promise<{
+        output: unknown;
+        fuelConsumed: number;
+    }>;
+    /**
+     * Physically cleans up the sandbox and releases resources.
+     */
+    teardown(): Promise<void>;
+}
+
+interface OAuthServerClientConfig {
+    client_id: string;
+    client_secret: string;
+    grant_types: string[];
+    scope: string;
+}
+interface OAuthServerConfig {
+    issuer: string;
+    clients: OAuthServerClientConfig[];
+}
+interface OAuthServerResult {
+    provider: Provider;
+    jwks: jose.JSONWebKeySet;
+}
+/**
+ * Creates and configures the embedded node-oidc-provider instance for the Nexus.
+ *
+ * @param config - Server configuration containing the issuer URL and allowed M2M clients.
+ */
+declare function createOAuthServer(config: OAuthServerConfig): OAuthServerResult;
+
+/**
+ * RFC 9728 Protected Resource Metadata response.
+ *
+ * @see https://datatracker.ietf.org/doc/rfc9728
+ */
+interface ProtectedResourceMetadata {
+    /** Identifier for the protected resource. */
+    resource: string;
+    /** Array of authorization server issuer URLs that can issue tokens for this resource. */
+    authorization_servers: string[];
+    /** OAuth scopes accepted by this resource. */
+    scopes_supported: readonly string[];
+    /** Methods of presenting the bearer token (always "header" for LIOP). */
+    bearer_methods_supported: string[];
+    /** URL to the resource documentation. */
+    resource_documentation: string;
+}
+/**
+ * Builds the Protected Resource Metadata document (RFC 9728).
+ *
+ * @param issuer - OIDC issuer URL of the Nexus authorization server
+ * @param audience - JWT audience claim (resource identifier)
+ */
+declare function buildProtectedResourceMetadata(issuer: string, audience: string): ProtectedResourceMetadata;
+
+/**
+ * LIOP RBAC Engine — Scope-Based Authorization
+ *
+ * Maps MCP JSON-RPC methods to required LIOP OAuth scopes.
+ * Enforces least-privilege access at the router level before
+ * any tool execution or resource read occurs.
+ *
+ * Standards: NIST SP 800-207 §4.3 (least privilege), OWASP LLM06 (Excessive Agency),
+ *            OWASP API-A01 (Broken Access Control)
+ */
+
+/**
+ * Authorization result with optional denial reason for audit logging.
+ */
+interface AuthorizationResult {
+    allowed: boolean;
+    reason?: string;
+}
+/**
+ * Evaluates whether a request is authorized based on JWT scopes.
+ *
+ * Decision logic:
+ * 1. Methods with no required scopes (initialize, ping) → always allowed.
+ * 2. Methods with required scopes but no auth → denied.
+ * 3. Methods with required scopes → all scopes must be present in the JWT.
+ * 4. Unknown methods with no auth → denied (fail-closed per NIST SP 800-207).
+ *
+ * @param method - MCP JSON-RPC method name (e.g., "tools/call")
+ * @param auth - Validated JWT context, or null if unauthenticated
+ * @param additionalScopes - Extra scopes required by specific node configuration
+ */
+declare function authorizeRequest(method: string, auth: AuthInfo | null, additionalScopes?: readonly string[]): AuthorizationResult;
+/**
+ * All LIOP OAuth scopes supported by the protocol.
+ * Used for PRM metadata and client registration.
+ */
+declare const LIOP_SCOPES: readonly ["liop:tools:list", "liop:tools:call", "liop:resources:read", "liop:schema:read", "liop:mesh:query"];
+type LiopScope = (typeof LIOP_SCOPES)[number];
+
+export { type AIProvider, AesGcmWrapper, AuthInfo, Counter, DILITHIUM65_CONSTANTS, Dilithium65Wrapper, ErrorCode, GRPC_CHANNEL_OPTIONS, GRPC_WEB_CONSTANTS, type GatewayTopologyInfo, Gauge, type GrpcWebFrame, HeuristicTokenEstimator, Histogram, Kyber768Wrapper, LIOP_SCOPES, LiopError, LiopOTelBridge, LiopRpcClient, LiopRpcServer, type LiopScope, type LiopSpan, LiopTracer, type MeshTopologyInfo, type MetricDefinition, type MetricLabels, MetricsRegistry, type PromptConfig, RealTokenEstimator, RoutingTable, type SandboxConfig, type SpanContext, type TokenEstimator, TokenManager, type TokenManagerOptions, type TokenOperationMetric, type TokenProvider, type TokenSessionReport, TokenTelemetryEngine, type ToolDefinition, type ToolRoute, type ToolTokenBreakdown, type TopologyProbeOptions, type TopologyProbeResult, type TransportProvider, WasiSandbox, authorizeRequest, buildProtectedResourceMetadata, calculateAstInstructionFuel, createOAuthServer, createSyncTokenEstimator, createTokenEstimator, decodeFrames, defaultTracer, dispatchGrpcWebRequest, egressBlocksTotal, encodeDataFrame, encodeTrailerFrame, fuelConsumed, generateSystemInstructions, getDefaultEnvironment, isGrpcWebRequest, manifestCacheSize, meshPeersConnected, operationDurationMs, pqcHandshakeDurationMs, pqcHandshakesTotal, probeTopology, protocolMetrics, tokensInputTotal, tokensOutputTotal, tokensSavedTotal, toolCallErrorsTotal, toolCallsTotal, wireEgressBytesTotal, wireSavedBytesTotal, zkVerificationDurationMs, zkVerificationsTotal };