@kya-os/mcp-i-core 1.8.0 → 1.8.2

package/dist/runtime/base.js

@@ -1,1491 +0,0 @@
-"use strict";
-/**
- * MCPIRuntimeBase - Provider-based runtime
- *
- * Core runtime that accepts providers for all platform-specific operations.
- * This enables the same runtime logic to work across Node.js, Cloudflare Workers,
- * and other platforms.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCPIRuntimeBase = void 0;
-const tool_protection_js_1 = require("../types/tool-protection.js");
-const crypto_service_js_1 = require("../services/crypto.service.js");
-const access_control_service_js_1 = require("../services/access-control.service.js");
-const agentshield_api_1 = require("@kya-os/contracts/agentshield-api");
-const user_did_manager_1 = require("../identity/user-did-manager");
-const isRecord = (value) => typeof value === "object" && value !== null;
-class MCPIRuntimeBase {
-    crypto;
-    clock;
-    fetch;
-    storage;
-    nonceCache;
-    identity;
-    config;
-    cachedIdentity;
-    sessions = new Map();
-    lastProof;
-    userDidManager;
-    interceptedCalls = new Map(); // Store intercepted tool calls by resume token
-    cryptoService;
-    proofVerifier; // Optional ProofVerifier (injected by subclasses)
-    accessControlService; // Optional AccessControlApiService (injected by subclasses)
-    /**
-     * Cached flag indicating whether @modelcontextprotocol/ext-apps is available.
-     * Set by subclasses after a successful dynamic import (avoids require() vs ESM issues).
-     * When undefined, falls back to synchronous require() probe.
-     */
-    _extAppsAvailable;
-    constructor(config) {
-        this.config = config;
-        this.crypto = config.cryptoProvider;
-        this.clock = config.clockProvider;
-        this.fetch = config.fetchProvider;
-        this.storage = config.storageProvider;
-        this.nonceCache = config.nonceCacheProvider;
-        this.identity = config.identityProvider;
-        // Initialize CryptoService for JWS verification
-        this.cryptoService = new crypto_service_js_1.CryptoService(this.crypto);
-    }
-    /**
-     * Initialize the runtime
-     */
-    async initialize() {
-        // Load or generate identity
-        this.cachedIdentity = await this.identity.getIdentity();
-        // Initialize user DID manager if identity config enables it
-        if (this.config.identity?.generateUserDids) {
-            this.userDidManager = new user_did_manager_1.UserDidManager({
-                crypto: this.crypto,
-                storage: this.config.identity?.userDidStorage
-                    ? {
-                        get: async (key) => await this.storage.get(`userDid:${key}`),
-                        set: async (key, value, ttl) => {
-                            await this.storage.set(`userDid:${key}`, value);
-                        },
-                        delete: async (key) => await this.storage.delete(`userDid:${key}`),
-                    }
-                    : undefined,
-                useDidWeb: this.config.identity?.userDidStorage === "persistent",
-            });
-        }
-        // Initialize nonce cache if it has an initialize method
-        const nonceCacheWithInitialize = this.nonceCache;
-        if (typeof nonceCacheWithInitialize.initialize === "function") {
-            await nonceCacheWithInitialize.initialize();
-        }
-        // Log initialization if audit is enabled
-        if (this.config.audit?.enabled) {
-            this.logAudit("runtime_initialized", {
-                did: this.cachedIdentity.did,
-                environment: this.config.environment || "development",
-                userDidGeneration: this.config.identity?.generateUserDids
-                    ? "enabled"
-                    : "disabled",
-            });
-        }
-    }
-    /**
-     * Get the current agent identity
-     */
-    async getIdentity() {
-        if (!this.cachedIdentity) {
-            this.cachedIdentity = await this.identity.getIdentity();
-        }
-        return this.cachedIdentity;
-    }
-    /**
-     * Handle MCP handshake request
-     *
-     * Phase 5: Anonymous Sessions Until OAuth
-     * - Sessions start anonymous (no userDid) unless OAuth identity provided
-     * - User DID is resolved via AgentShield after OAuth completes
-     * - Eliminates DID fragmentation (same user = same DID across sessions)
-     *
-     * @param request - Handshake request object (may include oauthIdentity for persistent user DID lookup)
-     * @returns Handshake response with session ID and agent DID
-     */
-    async handleHandshake(request) {
-        const identity = await this.getIdentity();
-        const timestamp = this.clock.now();
-        const sessionId = await this.generateSessionId();
-        // Phase 5: Try to resolve user DID from existing OAuth mapping
-        // Sessions start anonymous - no ephemeral generation
-        let userDid;
-        if (this.userDidManager) {
-            try {
-                const oauthIdentity = request.oauthIdentity;
-                const resolvedDid = await this.userDidManager.getOrCreateUserDid(sessionId, oauthIdentity);
-                // Convert null to undefined for session storage
-                userDid = resolvedDid ?? undefined;
-                if (this.config.audit?.enabled) {
-                    if (userDid) {
-                        console.error("[MCP-I] Resolved existing user DID for session:", {
-                            userDid: userDid.substring(0, 20) + "...",
-                            hasOAuth: !!oauthIdentity,
-                            provider: oauthIdentity?.provider,
-                        });
-                    }
-                    else {
-                        console.error("[MCP-I] Session started anonymous (no userDid):", {
-                            sessionId: sessionId.substring(0, 8) + "...",
-                            hasOAuth: !!oauthIdentity,
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                console.warn("[MCP-I] Failed to resolve user DID:", error);
-                // Continue without user DID - session is anonymous
-            }
-        }
-        // Extract client info if available
-        const normalizeString = (value) => {
-            if (typeof value !== "string") {
-                return undefined;
-            }
-            const trimmed = value.trim();
-            return trimmed.length > 0 ? trimmed : undefined;
-        };
-        const protocolVersion = normalizeString(request.clientProtocolVersion);
-        const clientCapabilities = request.clientCapabilities;
-        const requestClientInfo = request.clientInfo;
-        const shouldPersistClientInfo = requestClientInfo ||
-            typeof protocolVersion === "string" ||
-            typeof clientCapabilities !== "undefined";
-        const clientInfo = shouldPersistClientInfo
-            ? {
-                name: normalizeString(requestClientInfo?.name) ?? "unknown",
-                title: normalizeString(requestClientInfo?.title),
-                version: normalizeString(requestClientInfo?.version),
-                platform: normalizeString(requestClientInfo?.platform),
-                vendor: normalizeString(requestClientInfo?.vendor),
-                persistentId: normalizeString(requestClientInfo?.persistentId),
-                clientId: normalizeString(requestClientInfo?.clientId) ?? crypto.randomUUID(),
-                protocolVersion,
-                capabilities: clientCapabilities,
-            }
-            : undefined;
-        // Create session with Phase 5 identity state
-        const session = {
-            id: sessionId,
-            clientDid: request.clientDid || userDid, // Use provided clientDid or generated userDid
-            userDid: userDid, // Store user DID (may be undefined for anonymous sessions)
-            agentDid: request.agentDid, // ✅ FIXED: Only agent DID, no fallback
-            serverDid: identity.did, // ✅ NEW: Server's DID (for clarity)
-            audience: request.audience,
-            createdAt: timestamp,
-            expiresAt: this.clock.calculateExpiry((this.config.session?.ttlMinutes || 30) * 60),
-            clientInfo, // Store client information
-            // Phase 5: Identity state tracking
-            identityState: userDid ? "authenticated" : "anonymous",
-            oauthIdentity: request.oauthIdentity ?? undefined,
-        };
-        this.sessions.set(sessionId, session);
-        // Create handshake response
-        const response = {
-            sessionId,
-            agentDid: identity.did,
-            timestamp,
-            capabilities: ["identity", "proof", "audit"],
-            ...(userDid && { userDid }), // Include user DID in response if generated
-        };
-        // Sign the response
-        const signature = await this.signData(response);
-        return {
-            ...response,
-            signature,
-        };
-    }
-    /**
-     * Update session identity after OAuth resolution (Phase 5)
-     *
-     * Called after AgentShield identity/resolve returns a persistent user DID.
-     * Updates the session to authenticated state with the resolved DID.
-     *
-     * @param sessionId - MCP session ID
-     * @param userDid - Persistent user DID from AgentShield
-     * @param oauthIdentity - OAuth identity information
-     * @throws Error if session not found
-     */
-    async updateSessionIdentity(sessionId, userDid, oauthIdentity) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Session not found: ${sessionId}`);
-        }
-        // Update session with resolved identity
-        session.userDid = userDid;
-        session.identityState = "authenticated";
-        if (oauthIdentity) {
-            session.oauthIdentity = oauthIdentity;
-        }
-        // Update the sessions map
-        this.sessions.set(sessionId, session);
-        // Also update UserDidManager cache if available
-        if (this.userDidManager) {
-            await this.userDidManager.setUserDidForSession(sessionId, userDid, oauthIdentity);
-        }
-        if (this.config.audit?.enabled) {
-            console.error("[MCP-I] Session identity updated (Phase 5):", {
-                sessionId: sessionId.substring(0, 8) + "...",
-                userDid: userDid.substring(0, 20) + "...",
-                provider: oauthIdentity?.provider,
-                identityState: "authenticated",
-            });
-        }
-    }
-    /**
-     * Get session by ID
-     */
-    getSession(sessionId) {
-        return this.sessions.get(sessionId);
-    }
-    /**
-     * Extract the correct provider for consent URL from tool protection config
-     *
-     * For password auth tools, the provider is in authorization.provider.
-     * For OAuth auth tools, the provider is in oauthProvider (legacy) or authorization.provider.
-     *
-     * Note: Not all authorization types have a provider field (e.g., 'none', 'mdl', 'webauthn').
-     * Only 'oauth', 'oauth2', 'password', and 'idv' types have provider.
-     *
-     * @param protection - Tool protection configuration
-     * @returns Provider name to use in consent URL, or undefined
-     */
-    getConsentProvider(protection) {
-        // Check authorization field - only some types have provider
-        if (protection.authorization) {
-            const auth = protection.authorization;
-            // Types with provider: oauth, oauth2, password, idv
-            if (auth.type === "oauth" ||
-                auth.type === "oauth2" ||
-                auth.type === "password" ||
-                auth.type === "idv") {
-                // Return auth.provider if set, otherwise fall through to legacy oauthProvider
-                if (auth.provider) {
-                    return auth.provider;
-                }
-            }
-            // Other types don't have provider (none, mdl, verifiable_credential, webauthn, siwe)
-            // Fall through to legacy oauthProvider
-        }
-        // Fall back to legacy oauthProvider (deprecated)
-        return protection.oauthProvider;
-    }
-    /**
-     * Process tool call with automatic proof generation
-     * Returns clean result only - proof is stored for out-of-band retrieval
-     *
-     * @param toolName - Name of the tool being called
-     * @param args - Tool arguments
-     * @param handler - Tool execution handler
-     * @param session - Session context (expected fields: id, audience, nonce?, delegationToken?, consentProof?)
-     */
-    async processToolCall(toolName, args, handler, session) {
-        // Check tool protection (delegation requirement)
-        if (this.config.toolProtectionService) {
-            // Get agent identity to check protection
-            const identity = await this.getIdentity();
-            if (this.config.audit?.enabled) {
-                console.error("[MCP-I] Checking tool protection:", {
-                    tool: toolName,
-                    agentDid: identity.did.slice(0, 20) + "...",
-                    hasDelegation: !!(session?.delegationToken || session?.consentProof),
-                });
-            }
-            const protection = await this.config.toolProtectionService.checkToolProtection(toolName, identity.did);
-            if (protection) {
-                // Tool requires delegation
-                const hasDelegation = session?.delegationToken || session?.consentProof;
-                if (!hasDelegation) {
-                    // No delegation provided - intercept the tool call and store context
-                    // Store intercepted tool call context for resumption
-                    const interceptedCall = {
-                        toolName,
-                        args,
-                        sessionId: session?.id || "unknown",
-                        timestamp: this.clock.now(),
-                        expiresAt: this.clock.calculateExpiry(1800), // 30 minutes
-                    };
-                    // Generate resume token
-                    const resumeToken = await this.generateResumeToken(interceptedCall);
-                    // Build consent URL with resume token
-                    // Note: projectId is not available in base class - subclasses should override buildConsentUrl
-                    // Pass oauthProvider to ensure correct auth method is selected (e.g., "credentials" vs "github")
-                    const consentUrl = this.buildConsentUrl(toolName, protection.requiredScopes, session, resumeToken, undefined, // projectId - handled by subclass override
-                    this.getConsentProvider(protection) // Provider from tool config (supports both password and oauth auth)
-                    );
-                    // Create error with intercepted call context and pre-generated resume token
-                    const error = new tool_protection_js_1.DelegationRequiredError(toolName, protection.requiredScopes, consentUrl, interceptedCall, resumeToken);
-                    // Store intercepted call for resumption
-                    this.interceptedCalls.set(resumeToken, interceptedCall);
-                    // Clean up expired intercepted calls periodically
-                    this.cleanupExpiredInterceptedCalls();
-                    if (this.config.audit?.enabled) {
-                        console.warn("[MCP-I] BLOCKED: Tool requires delegation but none provided", {
-                            tool: toolName,
-                            requiredScopes: protection.requiredScopes,
-                            agentDid: identity.did.slice(0, 20) + "...",
-                            resumeToken: error.resumeToken,
-                            consentUrl,
-                        });
-                    }
-                    // Try MCP Apps inline consent UI before falling back to error
-                    // Client capabilities are stored under session.clientInfo.capabilities (set during handleHandshake)
-                    const clientInfo = session?.clientInfo;
-                    const clientCaps = isRecord(clientInfo?.capabilities)
-                        ? clientInfo.capabilities
-                        : undefined;
-                    const uiResult = this.buildConsentUIResult(toolName, protection.requiredScopes, session, resumeToken, session?.projectId || undefined, session?.serverOrigin || undefined, clientCaps);
-                    if (uiResult) {
-                        return uiResult;
-                    }
-                    throw error;
-                }
-                // Delegation provided - verify it with AccessControlApiService
-                const delegationToken = session?.delegationToken;
-                const consentProof = session?.consentProof;
-                if (!this.accessControlService) {
-                    // Access control service not available - log warning but allow execution
-                    // This enables graceful degradation when service is not configured
-                    if (this.config.audit?.enabled) {
-                        console.warn("[MCP-I] ⚠️ Delegation token provided but AccessControlApiService not configured - skipping verification", {
-                            tool: toolName,
-                            agentDid: identity.did.slice(0, 20) + "...",
-                            hasDelegationToken: !!delegationToken,
-                            hasConsentProof: !!consentProof,
-                        });
-                    }
-                }
-                else {
-                    // Verify delegation token with AccessControlApiService
-                    try {
-                        if (this.config.audit?.enabled) {
-                            console.error("[MCP-I] 🔐 Verifying delegation token with AccessControlApiService", {
-                                tool: toolName,
-                                agentDid: identity.did.slice(0, 20) + "...",
-                                hasDelegationToken: !!delegationToken,
-                                hasConsentProof: !!consentProof,
-                                requiredScopes: protection.requiredScopes,
-                            });
-                        }
-                        // Build verification request
-                        const verifyRequest = {
-                            agent_did: identity.did,
-                            scopes: protection.requiredScopes,
-                        };
-                        // ✅ CRITICAL: Include user_did for user-scoped delegation verification
-                        // This prevents cross-user delegation leakage (Priority 3 fallback issue)
-                        // Without user_did, AgentShield cannot validate user isolation
-                        if (session?.userDid) {
-                            verifyRequest.user_did = session.userDid;
-                            if (this.config.audit?.enabled) {
-                                console.error("[MCP-I] 🔐 Including user_did in verification request", {
-                                    userDid: session.userDid.slice(0, 20) + "...",
-                                });
-                            }
-                        }
-                        // Add delegation token if available (preferred over consent proof)
-                        if (delegationToken) {
-                            verifyRequest.delegation_token = delegationToken;
-                        }
-                        else if (consentProof) {
-                            // Consent proof is a JWT credential - use as credential_jwt
-                            verifyRequest.credential_jwt = consentProof;
-                        }
-                        // Add optional timestamp for verification
-                        verifyRequest.timestamp = this.clock.now();
-                        // Add client info from session if available
-                        if (session?.clientDid || session?.clientId) {
-                            verifyRequest.client_info = {
-                                origin: session?.serverOrigin,
-                                user_agent: session?.userAgent,
-                            };
-                        }
-                        // Perform verification
-                        const verificationResult = await this.accessControlService.verifyDelegation(verifyRequest, {
-                            delegationToken: delegationToken || undefined,
-                            credentialJwt: consentProof || undefined,
-                        });
-                        // Check verification result
-                        if (!verificationResult.data.valid) {
-                            // Delegation verification failed
-                            const reason = verificationResult.data.reason ||
-                                "Delegation token invalid or expired";
-                            const errorDetails = verificationResult.data.error;
-                            if (this.config.audit?.enabled) {
-                                console.error("[MCP-I] ❌ Delegation verification FAILED", {
-                                    tool: toolName,
-                                    agentDid: identity.did.slice(0, 20) + "...",
-                                    reason,
-                                    errorCode: errorDetails?.code,
-                                    errorMessage: errorDetails?.message,
-                                    requiredScopes: protection.requiredScopes,
-                                });
-                            }
-                            // Throw DelegationRequiredError to trigger consent flow
-                            const interceptedCall = {
-                                toolName,
-                                args,
-                                sessionId: session?.id || "unknown",
-                                timestamp: this.clock.now(),
-                                expiresAt: this.clock.calculateExpiry(1800), // 30 minutes
-                            };
-                            const resumeToken = await this.generateResumeToken(interceptedCall);
-                            const consentUrl = this.buildConsentUrl(toolName, protection.requiredScopes, session, resumeToken, undefined, // projectId - handled by subclass override
-                            this.getConsentProvider(protection) // Provider from tool config (supports both password and oauth auth)
-                            );
-                            this.interceptedCalls.set(resumeToken, interceptedCall);
-                            this.cleanupExpiredInterceptedCalls();
-                            throw new tool_protection_js_1.DelegationRequiredError(toolName, protection.requiredScopes, consentUrl, interceptedCall, resumeToken);
-                        }
-                        // ✅ SECURITY: Validate user_identifier matches session userDid
-                        // This ensures delegations are user-specific and prevents user isolation bypass
-                        const credential = verificationResult.data.credential;
-                        const delegationUserIdentifier = credential?.user_identifier;
-                        // Also check for user_id field (AgentShield may return DID or ID directly)
-                        const delegationUserId = credential?.user_id;
-                        const sessionUserDid = session?.userDid;
-                        if (delegationUserIdentifier && sessionUserDid) {
-                            // Check if identifiers match (direct match or via user_id field)
-                            const identifiersMatch = delegationUserIdentifier === sessionUserDid ||
-                                delegationUserId === sessionUserDid;
-                            // Special case: If delegationUserIdentifier is NOT a DID (e.g., email),
-                            // but AgentShield verified the delegation, trust it.
-                            // AgentShield internally links email → DID, so the verification is valid.
-                            // Only fail if BOTH are DIDs and they don't match.
-                            const isDelegationIdentifierDid = delegationUserIdentifier.startsWith("did:");
-                            const shouldEnforceMatch = isDelegationIdentifierDid || delegationUserId;
-                            if (shouldEnforceMatch && !identifiersMatch) {
-                                // User identifier mismatch - potential security issue
-                                const securityError = `Delegation user_identifier mismatch: delegation has "${delegationUserIdentifier.substring(0, 20)}..." but session has "${sessionUserDid.substring(0, 20)}..."`;
-                                if (this.config.audit?.enabled) {
-                                    console.error("[MCP-I] 🔒 SECURITY: User identifier validation FAILED", {
-                                        tool: toolName,
-                                        agentDid: identity.did.slice(0, 20) + "...",
-                                        delegationUserIdentifier: delegationUserIdentifier.substring(0, 20) + "...",
-                                        delegationUserId: delegationUserId
-                                            ? delegationUserId.substring(0, 20) + "..."
-                                            : "N/A",
-                                        sessionUserDid: sessionUserDid.substring(0, 20) + "...",
-                                        sessionId: session?.id?.substring(0, 20) + "...",
-                                        reason: "user_identifier_mismatch",
-                                        severity: "high",
-                                    });
-                                }
-                                // Throw DelegationRequiredError to force re-authentication
-                                const interceptedCall = {
-                                    toolName,
-                                    args,
-                                    sessionId: session?.id || "unknown",
-                                    timestamp: this.clock.now(),
-                                    expiresAt: this.clock.calculateExpiry(1800), // 30 minutes
-                                };
-                                const resumeToken = await this.generateResumeToken(interceptedCall);
-                                const consentUrl = this.buildConsentUrl(toolName, protection.requiredScopes, session, resumeToken, undefined, // projectId - handled by subclass override
-                                this.getConsentProvider(protection) // Provider from tool config (supports both password and oauth auth)
-                                );
-                                this.interceptedCalls.set(resumeToken, interceptedCall);
-                                this.cleanupExpiredInterceptedCalls();
-                                throw new tool_protection_js_1.DelegationRequiredError(toolName, protection.requiredScopes, consentUrl, interceptedCall, resumeToken);
-                            }
-                            // User identifier validation passed (direct match or trusted AgentShield verification)
-                            if (this.config.audit?.enabled) {
-                                console.error("[MCP-I] ✅ User identifier validation PASSED", {
-                                    tool: toolName,
-                                    agentDid: identity.did.slice(0, 20) + "...",
-                                    userDid: sessionUserDid.substring(0, 20) + "...",
-                                    sessionId: session?.id?.substring(0, 20) + "...",
-                                    matchType: identifiersMatch
-                                        ? "direct"
-                                        : "trusted_agentshield_verification",
-                                    delegationIdentifierFormat: isDelegationIdentifierDid
-                                        ? "did"
-                                        : "email_or_other",
-                                });
-                            }
-                        }
-                        else if (delegationUserIdentifier && !sessionUserDid) {
-                            // Delegation has user_identifier but session doesn't - log warning
-                            if (this.config.audit?.enabled) {
-                                console.warn("[MCP-I] ⚠️ Delegation has user_identifier but session missing userDid", {
-                                    tool: toolName,
-                                    agentDid: identity.did.slice(0, 20) + "...",
-                                    delegationUserIdentifier: delegationUserIdentifier.substring(0, 20) + "...",
-                                    sessionId: session?.id?.substring(0, 20) + "...",
-                                });
-                            }
-                        }
-                        // ✅ SECURITY: Validate authorization method matches tool requirements
-                        // This prevents stale delegations from working after tool auth method changes
-                        // NOTE: Authorization validation only applies when credential is present (AgentShield API verifier).
-                        // KV/Memory verifiers don't return credential data, so we skip auth method validation for them.
-                        const toolAuth = protection.authorization;
-                        const delegationAuth = credential?.authorization;
-                        // Only validate when:
-                        // 1. Tool has authorization requirement defined
-                        // 2. Credential is present (AgentShield API verifier)
-                        if (toolAuth && credential) {
-                            // If tool requires authorization but credential doesn't have auth data, reject
-                            // This prevents bypassing auth checks with incomplete credential data
-                            if (!delegationAuth) {
-                                if (this.config.audit?.enabled) {
-                                    console.error("[MCP-I] ❌ Tool requires authorization but credential missing auth data", {
-                                        tool: toolName,
-                                        agentDid: identity.did.slice(0, 20) + "...",
-                                        toolAuth,
-                                        note: "Credential exists but missing authorization metadata - rejecting for security",
-                                    });
-                                }
-                                // Throw DelegationRequiredError to force re-authorization
-                                const interceptedCall = {
-                                    toolName,
-                                    args,
-                                    sessionId: session?.id || "unknown",
-                                    timestamp: this.clock.now(),
-                                    expiresAt: this.clock.calculateExpiry(1800),
-                                };
-                                const resumeToken = await this.generateResumeToken(interceptedCall);
-                                const consentUrl = this.buildConsentUrl(toolName, protection.requiredScopes, session, resumeToken, undefined, this.getConsentProvider(protection));
-                                this.interceptedCalls.set(resumeToken, interceptedCall);
-                                this.cleanupExpiredInterceptedCalls();
-                                throw new tool_protection_js_1.DelegationRequiredError(toolName, protection.requiredScopes, consentUrl, interceptedCall, resumeToken);
-                            }
-                            // Both tool and delegation have authorization - compare them
-                            if (!(0, access_control_service_js_1.authorizationMatches)(delegationAuth, toolAuth)) {
-                                const toolAuthRecord = toolAuth;
-                                const toolAuthProvider = typeof toolAuthRecord.provider === "string"
-                                    ? `:${toolAuthRecord.provider}`
-                                    : "";
-                                const toolAuthCredentialType = typeof toolAuthRecord.credentialType === "string"
-                                    ? `:${toolAuthRecord.credentialType}`
-                                    : "";
-                                const authMismatchReason = `Authorization method mismatch: delegation has ${delegationAuth.type}${delegationAuth.provider ? `:${delegationAuth.provider}` : ""}${delegationAuth.credentialType ? `:${delegationAuth.credentialType}` : ""} but tool requires ${toolAuth.type}${toolAuthProvider}${toolAuthCredentialType}`;
-                                if (this.config.audit?.enabled) {
-                                    console.error("[MCP-I] ❌ Authorization method validation FAILED", {
-                                        tool: toolName,
-                                        agentDid: identity.did.slice(0, 20) + "...",
-                                        reason: authMismatchReason,
-                                        delegationAuth,
-                                        toolAuth,
-                                    });
-                                }
-                                // Throw DelegationRequiredError to force re-authorization with correct method
-                                const interceptedCall = {
-                                    toolName,
-                                    args,
-                                    sessionId: session?.id || "unknown",
-                                    timestamp: this.clock.now(),
-                                    expiresAt: this.clock.calculateExpiry(1800),
-                                };
-                                const resumeToken = await this.generateResumeToken(interceptedCall);
-                                const consentUrl = this.buildConsentUrl(toolName, protection.requiredScopes, session, resumeToken, undefined, this.getConsentProvider(protection));
-                                this.interceptedCalls.set(resumeToken, interceptedCall);
-                                this.cleanupExpiredInterceptedCalls();
-                                throw new tool_protection_js_1.DelegationRequiredError(toolName, protection.requiredScopes, consentUrl, interceptedCall, resumeToken);
-                            }
-                            // Authorization method validation passed
-                            if (this.config.audit?.enabled) {
-                                console.error("[MCP-I] ✅ Authorization method validation PASSED", {
-                                    tool: toolName,
-                                    agentDid: identity.did.slice(0, 20) + "...",
-                                    authType: delegationAuth.type,
-                                    provider: delegationAuth.provider || "N/A",
-                                });
-                            }
-                        }
-                        // If credential is missing entirely (KV/Memory verifiers), skip validation for backward compatibility
-                        // Verification succeeded
-                        if (this.config.audit?.enabled) {
-                            console.error("[MCP-I] ✅ Delegation verification SUCCEEDED", {
-                                tool: toolName,
-                                agentDid: identity.did.slice(0, 20) + "...",
-                                delegationId: verificationResult.data.delegation_id,
-                                credentialScopes: verificationResult.data.credential?.scopes,
-                                requiredScopes: protection.requiredScopes,
-                            });
-                        }
-                    }
-                    catch (error) {
-                        // Handle verification errors
-                        if (error instanceof tool_protection_js_1.DelegationRequiredError) {
-                            // Re-throw DelegationRequiredError as-is (already handled above)
-                            throw error;
-                        }
-                        // Handle AgentShieldAPIError (network errors, API errors, etc.)
-                        if (error instanceof agentshield_api_1.AgentShieldAPIError) {
-                            if (this.config.audit?.enabled) {
-                                console.error("[MCP-I] ❌ Delegation verification error (API failure)", {
-                                    tool: toolName,
-                                    agentDid: identity.did.slice(0, 20) + "...",
-                                    errorCode: error.code,
-                                    errorMessage: error.message,
-                                    errorDetails: error.details,
-                                });
-                            }
-                            // On API errors, fail securely by requiring delegation
-                            // This prevents unauthorized access when verification service is unavailable
-                            const interceptedCall = {
-                                toolName,
-                                args,
-                                sessionId: session?.id || "unknown",
-                                timestamp: this.clock.now(),
-                                expiresAt: this.clock.calculateExpiry(1800),
-                            };
-                            const resumeToken = await this.generateResumeToken(interceptedCall);
-                            const consentUrl = this.buildConsentUrl(toolName, protection.requiredScopes, session, resumeToken, undefined, // projectId - handled by subclass override
-                            this.getConsentProvider(protection) // Provider from tool config (supports both password and oauth auth)
-                            );
-                            this.interceptedCalls.set(resumeToken, interceptedCall);
-                            this.cleanupExpiredInterceptedCalls();
-                            throw new tool_protection_js_1.DelegationRequiredError(toolName, protection.requiredScopes, consentUrl, interceptedCall, resumeToken);
-                        }
-                        // Unexpected error - log and fail securely
-                        if (this.config.audit?.enabled) {
-                            console.error("[MCP-I] ❌ Unexpected error during delegation verification", {
-                                tool: toolName,
-                                agentDid: identity.did.slice(0, 20) + "...",
-                                error: error instanceof Error ? error.message : String(error),
-                                errorStack: error instanceof Error ? error.stack : undefined,
-                            });
-                        }
-                        // Fail securely - require delegation on unexpected errors
-                        const interceptedCall = {
-                            toolName,
-                            args,
-                            sessionId: session?.id || "unknown",
-                            timestamp: this.clock.now(),
-                            expiresAt: this.clock.calculateExpiry(1800),
-                        };
-                        const resumeToken = await this.generateResumeToken(interceptedCall);
-                        const consentUrl = this.buildConsentUrl(toolName, protection.requiredScopes, session, resumeToken, undefined, // projectId - handled by subclass override
-                        this.getConsentProvider(protection) // Provider from tool config (supports both password and oauth auth)
-                        );
-                        this.interceptedCalls.set(resumeToken, interceptedCall);
-                        this.cleanupExpiredInterceptedCalls();
-                        throw new tool_protection_js_1.DelegationRequiredError(toolName, protection.requiredScopes, consentUrl, interceptedCall, resumeToken);
-                    }
-                }
-            }
-            else {
-                // No protection required - tool can be executed freely
-                if (this.config.audit?.enabled) {
-                    console.error("[MCP-I] Tool protection check passed (no delegation required)", {
-                        tool: toolName,
-                        agentDid: identity.did.slice(0, 20) + "...",
-                        reason: "Tool not configured to require delegation",
-                    });
-                }
-            }
-        }
-        // Execute the tool
-        const result = await handler(args);
-        // Create proof
-        const proof = await this.createProof(result, session);
-        // Store proof for out-of-band retrieval
-        this.lastProof = proof;
-        // Log if audit is enabled
-        if (this.config.audit?.enabled) {
-            this.logAudit("tool_executed", {
-                tool: toolName,
-                sessionId: session?.id,
-                timestamp: this.clock.now(),
-            });
-        }
-        // Return clean result only (no proof in LLM context)
-        return result;
-    }
-    /**
-     * Resume a tool call after authorization
-     *
-     * @param resumeToken - Token from DelegationRequiredError
-     * @param handler - Tool execution handler
-     * @param delegationToken - Delegation token from authorization
-     * @returns Tool execution result
-     */
-    async resumeToolCall(resumeToken, handler, delegationToken) {
-        const interceptedCall = this.interceptedCalls.get(resumeToken);
-        if (!interceptedCall) {
-            throw new Error(`Invalid or expired resume token: ${resumeToken}`);
-        }
-        // Check if call has expired
-        if (this.clock.hasExpired(interceptedCall.expiresAt)) {
-            this.interceptedCalls.delete(resumeToken);
-            throw new Error(`Resume token expired: ${resumeToken}`);
-        }
-        // Get session for the intercepted call
-        const session = this.sessions.get(interceptedCall.sessionId);
-        if (!session) {
-            throw new Error(`Session not found for intercepted call: ${interceptedCall.sessionId}`);
-        }
-        // Add delegation token to session
-        const enhancedSession = {
-            ...session,
-            delegationToken,
-        };
-        // Resume the tool call with delegation
-        const result = await this.processToolCall(interceptedCall.toolName, interceptedCall.args, handler, enhancedSession);
-        // Clean up intercepted call after successful resumption to prevent memory leak
-        this.interceptedCalls.delete(resumeToken);
-        return result;
-    }
-    /**
-     * Generate a resume token for intercepted tool call
-     *
-     * Uses cryptographically secure random bytes for token generation.
-     * The token is used as an opaque lookup key in the interceptedCalls Map.
-     */
-    async generateResumeToken(_call) {
-        const bytes = await this.crypto.randomBytes(16);
-        return `resume_${this.bytesToHex(bytes)}`;
-    }
-    /**
-     * Clean up expired intercepted calls
-     */
-    cleanupExpiredInterceptedCalls() {
-        const now = this.clock.now();
-        for (const [token, call] of this.interceptedCalls.entries()) {
-            if (this.clock.hasExpired(call.expiresAt)) {
-                this.interceptedCalls.delete(token);
-            }
-        }
-    }
-    /**
-     * Build consent URL for AgentShield delegation flow
-     *
-     * Note: Parameter names use snake_case for AgentShield API compatibility.
-     * This is documented in docs/API_PARITY_GUIDE.md under "Field Naming Conventions".
-     *
-     * AgentShield API requires snake_case in URL parameters:
-     * - session_id (not sessionId)
-     * - agent_did (not agentDid)
-     * - resume_token (not resumeToken)
-     * - agent_name (human-readable agent name for dashboard display)
-     *
-     * @param toolName - Tool that requires delegation
-     * @param scopes - Required scopes for the tool
-     * @param session - Current session context
-     * @param resumeToken - Token to resume after delegation
-     * @param projectId - Project ID for AgentShield API
-     * @param provider - Provider name (e.g., "github", "credentials") to select specific auth method
-     * @returns Full consent URL with snake_case parameters
-     */
-    /**
-     * MCP Apps UI consent resource URI.
-     * Single shared resource for all consent flows - tool-specific data
-     * is passed via structuredContent in the tool result.
-     */
-    static CONSENT_UI_RESOURCE_URI = "ui://mcpi-consent/authorize";
-    /**
-     * Check if the connected MCP client supports MCP Apps UI rendering.
-     * Returns false if @modelcontextprotocol/ext-apps is not installed
-     * or the client didn't advertise the io.modelcontextprotocol/ui capability.
-     *
-     * Override in subclasses to provide client capabilities from the MCP session.
-     */
-    hasUICapability(clientCapabilities) {
-        if (!clientCapabilities) {
-            console.error("[MCP-I] hasUICapability: no clientCapabilities provided");
-            return false;
-        }
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const { getUiCapability, RESOURCE_MIME_TYPE } = require("@modelcontextprotocol/ext-apps/server");
-            const uiCap = getUiCapability(clientCapabilities);
-            const hasUI = uiCap?.mimeTypes?.includes(RESOURCE_MIME_TYPE) ?? false;
-            console.error("[MCP-I] hasUICapability check:", {
-                hasUI,
-                uiCap: uiCap ? JSON.stringify(uiCap) : "null",
-                capabilityKeys: Object.keys(clientCapabilities),
-            });
-            return hasUI;
-        }
-        catch {
-            // ext-apps not installed - graceful degradation
-            console.error("[MCP-I] hasUICapability: ext-apps not available");
-            return false;
-        }
-    }
-    /**
-     * Mark the ext-apps SDK as available.
-     * Called by subclasses after a successful dynamic import() of the SDK,
-     * which avoids the CJS require() vs ESM incompatibility that causes
-     * the synchronous probe to fail in Cloudflare Workers.
-     */
-    setExtAppsAvailable(available) {
-        this._extAppsAvailable = available;
-    }
-    /**
-     * Check if the MCP Apps inline consent UI is enabled.
-     * Requires BOTH conditions:
-     *   1. The SDK is available (set via setExtAppsAvailable(true) after dynamic import)
-     *   2. The config flag is enabled (config.inlineConsent === true OR MCPI_INLINE_CONSENT env var)
-     * This allows merging the feature while keeping it off by default.
-     */
-    isExtAppsAvailable() {
-        return this._extAppsAvailable === true && this.config.inlineConsent === true;
-    }
-    /**
-     * Build an MCP Apps-compatible tool result that renders an inline consent UI.
-     * Returns null when the host doesn't support MCP Apps or the SDK is unavailable,
-     * allowing callers to fall back to DelegationRequiredError.
-     *
-     * @param toolName - Tool requiring delegation
-     * @param scopes - Required scopes
-     * @param session - Current session context
-     * @param resumeToken - Token to resume after delegation
-     * @param projectId - AgentShield project ID
-     * @param serverUrl - Server URL for consent approval POST
-     * @param clientCapabilities - MCP client capabilities from the session
-     */
-    buildConsentUIResult(toolName, scopes, session, resumeToken, projectId, serverUrl, clientCapabilities, authMode = "consent-only", provider) {
-        // Per the MCP Apps spec, always return UI metadata when the SDK is available.
-        // Clients that support MCP Apps will render the inline iframe;
-        // clients that don't will use the text content as fallback.
-        // The capability check is logged but not gating.
-        this.hasUICapability(clientCapabilities);
-        if (!this.isExtAppsAvailable())
-            return null;
-        // Build fallback URL for graceful degradation within the UI itself
-        const consentUrl = this.buildConsentUrl(toolName, scopes, session, resumeToken, projectId);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Authorization required for tool "${toolName}". Please approve in the consent form below, or open this link to authorize in your browser: ${consentUrl}`,
-                },
-            ],
-            structuredContent: {
-                type: "consent_required",
-                authMode,
-                tool: toolName,
-                scopes,
-                agentDid: session?.agentDid || "",
-                agentName: session?.agentName || "",
-                sessionId: session?.id || "",
-                projectId: projectId || "",
-                resumeToken: resumeToken || "",
-                serverUrl: serverUrl || "",
-                consentUrl,
-                ...(provider ? { provider } : {}),
-            },
-            _meta: {
-                ui: {
-                    resourceUri: MCPIRuntimeBase.CONSENT_UI_RESOURCE_URI,
-                },
-                // Legacy flat format for backward compatibility with older clients
-                "ui/resourceUri": MCPIRuntimeBase.CONSENT_UI_RESOURCE_URI,
-            },
-        };
-    }
-    buildConsentUrl(toolName, scopes, session, resumeToken, projectId, provider) {
-        // Default implementation - override in subclasses
-        // This URL should point to AgentShield's consent page
-        // Parameter names use snake_case for AgentShield API compatibility
-        const params = new URLSearchParams({
-            tool: toolName,
-            scopes: scopes.join(","),
-            session_id: session?.id || "",
-            agent_did: session?.agentDid || "",
-        });
-        // Add agent_name for AgentShield dashboard display
-        // Priority: session.agentName > "Unknown Agent"
-        const agentName = session?.agentName;
-        if (agentName) {
-            params.set("agent_name", agentName);
-        }
-        // Add project_id if provided (required for AgentShield consent endpoint)
-        if (projectId) {
-            params.set("project_id", projectId);
-        }
-        // Add resume token if provided
-        if (resumeToken) {
-            params.set("resume_token", resumeToken);
-        }
-        // Add provider if specified (allows selecting specific auth method like "credentials" or "github")
-        // This is critical when multiple providers are configured for a project
-        if (provider) {
-            params.set("provider", provider);
-        }
-        // Use AgentShield consent endpoint
-        return `https://kya.vouched.id/bouncer/consent?${params.toString()}`;
-    }
-    /**
-     * Issue a new nonce and register it in the cache
-     * Use this to get a nonce for the session context before calling processToolCall
-     */
-    async issueNonce(sessionId) {
-        const nonce = await this.generateNonce();
-        // Get session to extract agentDid for agent-scoped nonce caching
-        const session = this.sessions.get(sessionId);
-        const agentDid = session?.agentDid || (await this.getIdentity()).did;
-        await this.nonceCache.add(nonce, 300, // 5 minute expiry in seconds
-        agentDid // Agent-scoped nonce to prevent cross-agent replay attacks
-        );
-        return nonce;
-    }
-    /**
-     * Create cryptographic proof for data
-     */
-    async createProof(data, session) {
-        const identity = await this.getIdentity();
-        const timestamp = this.clock.now();
-        // Use nonce from session if provided, otherwise generate new one
-        let nonce;
-        if (session?.nonce) {
-            nonce = session.nonce;
-        }
-        else {
-            nonce = await this.generateNonce();
-            // Add nonce to cache to prevent replay (agent-scoped to prevent cross-agent replay attacks)
-            const agentDid = session?.agentDid || identity.did;
-            await this.nonceCache.add(nonce, 300, // 5 minute expiry in seconds
-            agentDid // Agent-scoped nonce to prevent cross-agent replay attacks
-            );
-        }
-        const proofData = {
-            data,
-            timestamp,
-            nonce,
-            did: identity.did,
-            sessionId: session?.id,
-            audience: session?.audience,
-        };
-        const signature = await this.signData(proofData);
-        return {
-            timestamp,
-            nonce,
-            did: identity.did,
-            signature,
-            algorithm: "Ed25519",
-            sessionId: session?.id,
-            audience: session?.audience,
-        };
-    }
-    /**
-     * Verify a proof
-     *
-     * Supports both old format (data, proof) and new DetachedProof format.
-     * When DetachedProof format is used, ProofVerifier is used if available.
-     *
-     * @param dataOrProof - Either raw data (old format) or DetachedProof (new format)
-     * @param proofOrSession - Either proof object (old format) or session context (new format)
-     * @returns true if proof is valid, false otherwise
-     */
-    async verifyProof(dataOrProof, proofOrSession) {
-        // Check if first argument is DetachedProof format
-        if (dataOrProof &&
-            typeof dataOrProof === "object" &&
-            "jws" in dataOrProof &&
-            "meta" in dataOrProof) {
-            // New DetachedProof format
-            const detachedProof = dataOrProof;
-            const session = isRecord(proofOrSession)
-                ? proofOrSession
-                : undefined;
-            // Use ProofVerifier if available
-            if (this.proofVerifier) {
-                try {
-                    // Resolve DID to get public key
-                    const didDoc = await this.fetch.resolveDID(detachedProof.meta.did);
-                    const publicKeyJwk = this.extractPublicKeyJwk(didDoc, detachedProof.meta.kid);
-                    if (!publicKeyJwk) {
-                        console.error("[MCPIRuntimeBase] Failed to extract public key JWK");
-                        return false;
-                    }
-                    // Verify proof using ProofVerifier
-                    const result = await this.proofVerifier.verifyProof(detachedProof, publicKeyJwk);
-                    if (result.valid && session) {
-                        // Store canonical payload in session for detached JWS consumers
-                        const canonicalPayload = this.proofVerifier.buildCanonicalPayload(detachedProof.meta);
-                        session.canonicalPayload = canonicalPayload;
-                    }
-                    return result.valid;
-                }
-                catch (error) {
-                    console.error("[MCPIRuntimeBase] Proof verification failed:", error);
-                    return false;
-                }
-            }
-            else {
-                // Fallback to old verification if ProofVerifier not available
-                console.warn("[MCPIRuntimeBase] ProofVerifier not available, using fallback verification");
-                return this.verifyProofLegacy(dataOrProof, isRecord(proofOrSession) ? proofOrSession : {});
-            }
-        }
-        else {
-            // Old format (data, proof)
-            return this.verifyProofLegacy(dataOrProof, isRecord(proofOrSession) ? proofOrSession : {});
-        }
-    }
-    /**
-     * Legacy proof verification (backward compatibility)
-     * @internal
-     */
-    async verifyProofLegacy(data, proof) {
-        try {
-            const nonce = typeof proof.nonce === "string" ? proof.nonce : undefined;
-            const did = typeof proof.did === "string" ? proof.did : undefined;
-            const timestamp = typeof proof.timestamp === "number" ? proof.timestamp : undefined;
-            const signature = typeof proof.signature === "string" ? proof.signature : undefined;
-            const sessionId = typeof proof.sessionId === "string" ? proof.sessionId : undefined;
-            if (!nonce || !did || !timestamp || !signature) {
-                return false;
-            }
-            // Check nonce hasn't been used (scoped to agent DID to prevent cross-agent replay attacks)
-            if (await this.nonceCache.has(nonce, did)) {
-                return false;
-            }
-            // Check timestamp is within skew
-            if (!this.clock.isWithinSkew(timestamp, this.config.session?.timestampSkewSeconds || 300)) {
-                return false;
-            }
-            // Resolve DID to get public key
-            const didDoc = await this.fetch.resolveDID(did);
-            const publicKey = this.extractPublicKey(didDoc);
-            // Verify signature
-            const proofData = {
-                data,
-                timestamp,
-                nonce,
-                did,
-                sessionId,
-            };
-            const dataBytes = new TextEncoder().encode(JSON.stringify(proofData));
-            const signatureBytes = this.base64ToBytes(signature);
-            const isValid = await this.crypto.verify(dataBytes, signatureBytes, publicKey);
-            // If signature is valid, add nonce to cache to prevent replay (scoped to agent DID)
-            if (isValid) {
-                // Pass TTL in seconds, not absolute timestamp
-                const ttlSeconds = (this.config.session?.ttlMinutes || 30) * 60; // Convert minutes to seconds
-                await this.nonceCache.add(nonce, ttlSeconds, did);
-            }
-            return isValid;
-        }
-        catch (error) {
-            console.error("Proof verification failed:", error);
-            return false;
-        }
-    }
-    /**
-     * Verify a JWS proof (full compact JWS format: header.payload.signature)
-     *
-     * This method provides full cryptographic signature verification using CryptoService.
-     * Use this when you have a DetachedProof with JWS instead of raw signature.
-     *
-     * @param jws - Full compact JWS string (header.payload.signature)
-     * @param publicKeyJwk - Ed25519 public key in JWK format
-     * @param detachedPayload - Optional detached payload for detached JWS format
-     * @returns true if signature is valid, false otherwise
-     */
-    async verifyProofJWS(jws, publicKeyJwk, detachedPayload) {
-        if (!this.cryptoService) {
-            console.error("[MCPIRuntimeBase] CryptoService not initialized");
-            return false;
-        }
-        try {
-            const options = detachedPayload !== undefined ? { detachedPayload } : undefined;
-            return await this.cryptoService.verifyJWS(jws, publicKeyJwk, options);
-        }
-        catch (error) {
-            console.error("[MCPIRuntimeBase] JWS verification failed:", error);
-            return false;
-        }
-    }
-    /**
-     * Get current session
-     */
-    async getCurrentSession() {
-        // Find non-expired session
-        for (const [id, session] of this.sessions) {
-            if (!this.clock.hasExpired(session.expiresAt)) {
-                return session;
-            }
-        }
-        return null;
-    }
-    /**
-     * Get the last generated proof for out-of-band transport
-     */
-    getLastProof() {
-        return this.lastProof;
-    }
-    /**
-     * Create well-known handler for identity verification
-     */
-    createWellKnownHandler(config) {
-        return async (path) => {
-            const identity = await this.getIdentity();
-            if (path === "/.well-known/did.json") {
-                const didDocument = this.createDIDDocument(identity);
-                return {
-                    status: 200,
-                    headers: {
-                        "Content-Type": "application/did+json",
-                        "Cache-Control": this.config.environment === "production"
-                            ? "public, max-age=300"
-                            : "no-store",
-                    },
-                    body: JSON.stringify(didDocument, null, 2),
-                };
-            }
-            if (path === "/.well-known/agent.json") {
-                const agentDocument = {
-                    id: identity.did,
-                    capabilities: {
-                        "mcp-i": ["handshake", "signing", "verification"],
-                    },
-                };
-                if (config?.serviceName || config?.serviceEndpoint) {
-                    agentDocument.metadata = {
-                        ...(config?.serviceName && { name: config.serviceName }),
-                        ...(config?.serviceEndpoint && {
-                            serviceEndpoint: config.serviceEndpoint,
-                        }),
-                    };
-                }
-                return {
-                    status: 200,
-                    headers: {
-                        "Content-Type": "application/json",
-                        "Cache-Control": this.config.environment === "production"
-                            ? "public, max-age=300"
-                            : "no-store",
-                    },
-                    body: JSON.stringify(agentDocument, null, 2),
-                };
-            }
-            if (path === "/.well-known/mcp-identity") {
-                return {
-                    did: identity.did,
-                    publicKey: identity.publicKey,
-                    serviceName: config?.serviceName || "MCP-I Service",
-                    serviceEndpoint: config?.serviceEndpoint || "https://example.com",
-                    timestamp: this.clock.now(),
-                };
-            }
-            // SEP-1649 MCP Server Card for client discovery
-            // Support both paths during spec transition:
-            // - /.well-known/mcp.json (current Cursor/Claude Desktop usage)
-            // - /.well-known/mcp/server-card.json (SEP-1649 proposed spec)
-            if (path === "/.well-known/mcp.json" || path === "/.well-known/mcp/server-card.json") {
-                const serverName = config?.serviceName || "mcp-i-server";
-                // SEP-1649 compliant MCP Server Card
-                const mcpServerCard = {
-                    $schema: "https://static.modelcontextprotocol.io/schemas/mcp-server-card/v1.json",
-                    version: "1.0",
-                    protocolVersion: config?.protocolVersion || "2025-06-18",
-                    serverInfo: {
-                        name: serverName,
-                        title: config?.serviceTitle || config?.serviceName || "MCP-I Server",
-                        version: config?.serverVersion || "1.0.0",
-                    },
-                    description: config?.description || "MCP-I enabled server with cryptographic identity",
-                    ...(config?.iconUrl && { iconUrl: config.iconUrl }),
-                    ...(config?.documentationUrl && { documentationUrl: config.documentationUrl }),
-                    transport: {
-                        type: "streamable-http",
-                        endpoint: "/mcp",
-                    },
-                    capabilities: {
-                        tools: { listChanged: true },
-                    },
-                    ...(config?.requiresAuth && {
-                        authentication: {
-                            required: true,
-                            schemes: config.authSchemes || ["oauth2"],
-                        },
-                    }),
-                    ...(config?.instructions && { instructions: config.instructions }),
-                    // Tools are dynamic - discovered via protocol
-                    tools: "dynamic",
-                    _meta: {
-                        ...config?.metadata,
-                        "mcp-i": {
-                            agentDid: identity.did,
-                            publicKey: identity.publicKey,
-                            generatedAt: this.clock.now(),
-                        },
-                    },
-                };
-                const headers = {
-                    "Content-Type": "application/json",
-                    "Cache-Control": this.config.environment === "production"
-                        ? "public, max-age=3600" // SEP-1649 recommends 1 hour
-                        : "no-store",
-                    // SEP-1649 CORS requirements for browser-based client discovery
-                    "Access-Control-Allow-Origin": "*",
-                    "Access-Control-Allow-Methods": "GET",
-                    "Access-Control-Allow-Headers": "Content-Type",
-                };
-                return {
-                    status: 200,
-                    headers,
-                    body: JSON.stringify(mcpServerCard, null, 2),
-                };
-            }
-            // Client configuration helper - ready-to-use config for Cursor/Claude Desktop
-            if (path === "/.well-known/mcp-client-config.json") {
-                const serviceEndpoint = config?.serviceEndpoint || "https://example.com";
-                const serverName = config?.serviceName || "mcp-i-server";
-                const mcpUrl = `${serviceEndpoint}/mcp`;
-                // Generate Cursor deep link
-                // Note: Base64 can contain +, /, = which have special meaning in URLs
-                // Must URL-encode the base64 string for safe transmission
-                const cursorConfig = { [serverName]: { url: mcpUrl, transport: "sse" } };
-                const encodedConfig = Buffer.from(JSON.stringify(cursorConfig)).toString("base64");
-                const cursorDeepLink = `cursor://anysphere.cursor-deeplink/mcp/install?name=${encodeURIComponent(serverName)}&config=${encodeURIComponent(encodedConfig)}`;
-                const clientConfig = {
-                    // For claude_desktop_config.json
-                    claudeDesktop: {
-                        mcpServers: {
-                            [serverName]: {
-                                url: mcpUrl,
-                                transport: "sse",
-                            },
-                        },
-                    },
-                    // For .cursor/mcp.json
-                    cursor: {
-                        mcpServers: {
-                            [serverName]: {
-                                url: mcpUrl,
-                                transport: "sse",
-                            },
-                        },
-                    },
-                    // One-click install for Cursor
-                    cursorDeepLink,
-                    // Additional info
-                    _meta: {
-                        serverName,
-                        serverUrl: serviceEndpoint,
-                        mcpEndpoint: mcpUrl,
-                        agentDid: identity.did,
-                        generatedAt: this.clock.now(),
-                        instructions: "Copy the appropriate config section to your client configuration file.",
-                    },
-                };
-                return {
-                    status: 200,
-                    headers: {
-                        "Content-Type": "application/json",
-                        "Cache-Control": this.config.environment === "production"
-                            ? "public, max-age=300"
-                            : "no-store",
-                    },
-                    body: JSON.stringify(clientConfig, null, 2),
-                };
-            }
-            return null;
-        };
-    }
-    /**
-     * Create debug endpoint (development only)
-     */
-    createDebugEndpoint() {
-        if (this.config.environment === "production") {
-            return null;
-        }
-        return async () => {
-            const identity = await this.getIdentity();
-            const session = await this.getCurrentSession();
-            return {
-                identity: {
-                    did: identity.did,
-                    publicKey: identity.publicKey,
-                },
-                session,
-                config: {
-                    environment: this.config.environment,
-                    timestampSkewSeconds: this.config.session?.timestampSkewSeconds,
-                    sessionTtlMinutes: this.config.session?.ttlMinutes,
-                },
-                timestamp: this.clock.now(),
-            };
-        };
-    }
-    /**
-     * Get audit logger
-     */
-    getAuditLogger() {
-        return {
-            log: (event, data) => this.logAudit(event, data),
-        };
-    }
-    /**
-     * Rotate keys
-     */
-    async rotateKeys() {
-        const oldDid = this.cachedIdentity?.did;
-        const newIdentity = await this.identity.rotateKeys();
-        this.cachedIdentity = newIdentity;
-        if (this.config.audit?.enabled) {
-            this.logAudit("keys_rotated", {
-                oldDid: oldDid,
-                newDid: newIdentity.did,
-                timestamp: this.clock.now(),
-            });
-        }
-        return newIdentity;
-    }
-    // Helper methods
-    async signData(data) {
-        const identity = await this.getIdentity();
-        const dataBytes = new TextEncoder().encode(JSON.stringify(data));
-        const signature = await this.crypto.sign(dataBytes, identity.privateKey);
-        return this.bytesToBase64(signature);
-    }
-    async generateNonce() {
-        const bytes = await this.crypto.randomBytes(32);
-        return this.bytesToBase64(bytes);
-    }
-    /**
-     * Generate a unique session ID
-     * Uses mcpi_{uuid} format for MCP protocol compliance and traceability
-     */
-    async generateSessionId() {
-        const bytes = await this.crypto.randomBytes(16);
-        // Set version (4) and variant (RFC4122)
-        bytes[6] = (bytes[6] & 0x0f) | 0x40;
-        bytes[8] = (bytes[8] & 0x3f) | 0x80;
-        const hex = this.bytesToHex(bytes);
-        const uuid = `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
-        return `mcpi_${uuid}`;
-    }
-    /**
-     * Log structured events in JSON format (NOT frozen audit format).
-     *
-     * **Important:** This method logs events in JSON format for general runtime events
-     * (e.g., "runtime_initialized", "tool_executed", "keys_rotated").
-     *
-     * **For frozen format audit logs** (MCP-I spec compliance), use `AuditLogger.logAuditRecord()`
-     * from `@kya-os/mcp-i/runtime` instead. The frozen format is:
-     * ```
-     * audit.v1 ts=<unix> session=<id> audience=<host> did=<did> kid=<kid> reqHash=<sha256:..> resHash=<sha256:..> verified=yes|no scope=<scopeId|->
-     * ```
-     *
-     * **Format:** JSON object with `event`, `data`, `timestamp`, and `timestampFormatted` fields.
-     *
-     * **Privacy:** If `includePayloads` is false (default), the `data` field is omitted.
-     *
-     * **Use Cases:**
-     * - Developer debugging and local logging
-     * - Runtime initialization events
-     * - Tool execution tracking (non-spec-compliant)
-     * - Key rotation events
-     *
-     * **NOT for:**
-     * - MCP-I spec-compliant audit logs (use `AuditLogger`)
-     * - Production audit trails (use `AuditLogger`)
-     * - Compliance requirements (use `AuditLogger`)
-     *
-     * @param event - Event name (e.g., "runtime_initialized", "tool_executed")
-     * @param data - Event data (only included if `includePayloads` is true)
-     *
-     * @example
-     * ```typescript
-     * // Logs: {"event":"runtime_initialized","timestamp":1234567890,"timestampFormatted":"2024-01-01T00:00:00Z"}
-     * this.logAudit("runtime_initialized", { did: "did:key:..." });
-     * ```
-     *
-     * @internal This is a private method for internal runtime events.
-     * Use AuditLogger for spec-compliant frozen format audit logs.
-     */
-    logAudit(event, data) {
-        if (!this.config.audit?.enabled)
-            return;
-        const record = {
-            event,
-            data: this.config.audit.includePayloads ? data : undefined,
-            timestamp: this.clock.now(),
-            timestampFormatted: this.clock.format(this.clock.now()),
-        };
-        const logLine = JSON.stringify(record);
-        if (this.config.audit.logFunction) {
-            this.config.audit.logFunction(logLine);
-        }
-        else {
-            console.error("[AUDIT]", logLine);
-        }
-    }
-    createDIDDocument(identity) {
-        return {
-            "@context": ["https://www.w3.org/ns/did/v1"],
-            id: identity.did,
-            verificationMethod: [
-                {
-                    id: `${identity.did}#key-1`,
-                    type: "Ed25519VerificationKey2020",
-                    controller: identity.did,
-                    // Using base64 for cross-platform compatibility (Cloudflare Workers)
-                    // W3C DID spec supports both base64 and multibase formats
-                    publicKeyBase64: identity.publicKey,
-                },
-            ],
-            authentication: [`${identity.did}#key-1`],
-            assertionMethod: [`${identity.did}#key-1`],
-        };
-    }
-    extractPublicKey(didDoc) {
-        const verificationMethods = isRecord(didDoc)
-            ? didDoc.verificationMethod
-            : undefined;
-        const method = Array.isArray(verificationMethods)
-            ? verificationMethods[0]
-            : undefined;
-        if (method?.publicKeyBase64) {
-            return String(method.publicKeyBase64);
-        }
-        if (method?.publicKeyMultibase) {
-            // Convert multibase to base64
-            return String(method.publicKeyMultibase); // Simplified
-        }
-        throw new Error("Public key not found in DID document");
-    }
-    /**
-     * Extract public key JWK from DID document
-     */
-    extractPublicKeyJwk(didDoc, kid) {
-        const verificationMethods = isRecord(didDoc)
-            ? didDoc.verificationMethod
-            : undefined;
-        const verificationMethodList = Array.isArray(verificationMethods)
-            ? verificationMethods
-            : [];
-        // Try to find Ed25519 public key matching kid if provided
-        const verificationMethod = verificationMethodList.find((vm) => {
-            const vmType = typeof vm.type === "string" ? vm.type : undefined;
-            const vmId = typeof vm.id === "string" ? vm.id : undefined;
-            const matchesType = vmType === "Ed25519VerificationKey2020" ||
-                vmType === "JsonWebKey2020";
-            const matchesKid = !kid || vmId === kid || vmId?.endsWith(`#${kid}`);
-            return matchesType && matchesKid;
-        }) || verificationMethodList[0]; // Fallback to first method
-        if (verificationMethod && isRecord(verificationMethod.publicKeyJwk)) {
-            const jwk = verificationMethod.publicKeyJwk;
-            // Ensure it's Ed25519 format
-            if (jwk.kty === "OKP" && jwk.crv === "Ed25519") {
-                return jwk;
-            }
-        }
-        // Fallback: try to convert multibase to JWK (simplified)
-        if (verificationMethod?.publicKeyMultibase) {
-            // This is a simplified conversion - in production, use proper multibase decoding
-            console.warn("[MCPIRuntimeBase] Multibase to JWK conversion not fully implemented");
-            return null;
-        }
-        return null;
-    }
-    bytesToBase64(bytes) {
-        return Buffer.from(bytes).toString("base64");
-    }
-    base64ToBytes(base64) {
-        return new Uint8Array(Buffer.from(base64, "base64"));
-    }
-    bytesToHex(bytes) {
-        return Buffer.from(bytes).toString("hex");
-    }
-}
-exports.MCPIRuntimeBase = MCPIRuntimeBase;
-//# sourceMappingURL=base.js.map