@kya-os/mcp-i 1.5.2 → 1.5.3-canary.1

package/dist/runtime/utils/tools.js

@@ -4,6 +4,15 @@ exports.addToolsToServer = addToolsToServer;
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const proof_1 = require("../proof");
 const identity_1 = require("../identity");
+const tool_protection_registry_1 = require("../tool-protection-registry");
+const auth_handshake_1 = require("../auth-handshake");
+const session_1 = require("../session");
+const request_context_1 = require("../request-context");
+const proof_batch_queue_1 = require("../proof-batch-queue");
+// Parse runtime config path from injected variable
+// @ts-expect-error: injected by compiler
+const rawRuntimeConfigPath = typeof RUNTIME_CONFIG_PATH !== "undefined" ? RUNTIME_CONFIG_PATH : undefined;
+const runtimeConfigPath = rawRuntimeConfigPath ? JSON.parse(rawRuntimeConfigPath) : null;
 /** Validates if a value is a valid Zod schema object */
 function isZodRawShape(value) {
     if (typeof value !== "object" || value === null) {
@@ -24,6 +33,83 @@ function pathToName(path) {
     const fileName = path.split("/").pop() || path;
     return fileName.replace(/\.[^/.]+$/, "");
 }
+// Global ProofBatchQueue instance (singleton)
+let globalProofQueue = null;
+/** Load runtime config and initialize ProofBatchQueue if configured */
+async function initializeProofBatchQueue(debug) {
+    // Return existing instance if already initialized
+    if (globalProofQueue) {
+        return globalProofQueue;
+    }
+    // Check if runtime config path is available
+    if (!runtimeConfigPath) {
+        if (debug) {
+            console.error("[MCPI] No runtime config found - proof submission disabled");
+        }
+        return null;
+    }
+    try {
+        if (debug) {
+            console.error("[MCPI] Loading runtime config from:", runtimeConfigPath);
+        }
+        // Dynamically import the runtime config
+        const configModule = await import(runtimeConfigPath);
+        const runtimeConfig = typeof configModule.getRuntimeConfig === "function"
+            ? configModule.getRuntimeConfig()
+            : configModule.default;
+        // Check if proofing is enabled
+        if (!runtimeConfig?.proofing?.enabled) {
+            if (debug) {
+                console.error("[MCPI] Proofing is disabled in runtime config");
+            }
+            return null;
+        }
+        const proofingConfig = runtimeConfig.proofing;
+        if (!proofingConfig.batchQueue?.destinations || proofingConfig.batchQueue.destinations.length === 0) {
+            if (debug) {
+                console.error("[MCPI] No proof destinations configured");
+            }
+            return null;
+        }
+        // Create proof destinations
+        const destinations = [];
+        for (const destConfig of proofingConfig.batchQueue.destinations) {
+            if (destConfig.type === "agentshield") {
+                destinations.push(new proof_batch_queue_1.AgentShieldProofDestination(destConfig.apiUrl, destConfig.apiKey));
+                if (debug) {
+                    console.error(`[MCPI] Added AgentShield destination: ${destConfig.apiUrl}`);
+                }
+            }
+            // Add other destination types here (KTA, etc.)
+        }
+        if (destinations.length === 0) {
+            if (debug) {
+                console.error("[MCPI] No valid proof destinations configured");
+            }
+            return null;
+        }
+        // Initialize ProofBatchQueue
+        globalProofQueue = new proof_batch_queue_1.ProofBatchQueue({
+            destinations,
+            maxBatchSize: proofingConfig.batchQueue.maxBatchSize || 10,
+            flushIntervalMs: proofingConfig.batchQueue.flushIntervalMs || 5000,
+            maxRetries: proofingConfig.batchQueue.maxRetries || 3,
+            debug: proofingConfig.batchQueue.debug || debug,
+        });
+        if (debug) {
+            console.error(`[MCPI] ProofBatchQueue initialized (batch: ${proofingConfig.batchQueue.maxBatchSize}, ` +
+                `flush: ${proofingConfig.batchQueue.flushIntervalMs}ms, ` +
+                `destinations: ${destinations.length})`);
+        }
+        return globalProofQueue;
+    }
+    catch (error) {
+        if (debug) {
+            console.error("[MCPI] Failed to initialize ProofBatchQueue:", error);
+        }
+        return null;
+    }
+}
 if (typeof global !== 'undefined') {
     global.__MCPI_HANDLERS_REGISTERED__ = global.__MCPI_HANDLERS_REGISTERED__ || false;
 }
@@ -44,6 +130,8 @@ async function addToolsToServer(server, toolModules, identityConfig) {
     if (identityConfig?.debug) {
         console.error("[MCPI] Registering handlers for the first time");
     }
+    // Initialize session manager for handshake support
+    const sessionManager = new session_1.SessionManager();
     // Initialize identity manager if identity is enabled
     let identityManager = null;
     if (identityConfig?.enabled) {
@@ -68,6 +156,8 @@ async function addToolsToServer(server, toolModules, identityConfig) {
             // Continue without identity if initialization fails
         }
     }
+    // Initialize ProofBatchQueue for proof submission (if runtime config exists)
+    await initializeProofBatchQueue(identityConfig?.debug);
     // Collect all tools and their handlers
     const tools = [];
     const toolHandlers = new Map();
@@ -113,8 +203,12 @@ async function addToolsToServer(server, toolModules, identityConfig) {
     });
     // Debug: log server state before registering handler
     if (identityConfig?.debug) {
-        console.error("[MCPI] About to register tools/list handler");
+        console.error("[MCPI] About to register handlers (tools/list, tools/call)");
     }
+    // NOTE: Custom handshake handler removed - it was causing registration errors
+    // Handshake/session management should be handled via HTTP headers or custom tools
+    // The setRequestHandler expects a Zod schema, not a request object
+    // TODO: Implement handshake as a custom tool if needed
     // Register tools/list handler
     server.setRequestHandler(types_js_1.ListToolsRequestSchema, async (request) => {
         return {
@@ -123,92 +217,215 @@ async function addToolsToServer(server, toolModules, identityConfig) {
     });
     // Register tools/call handler
     server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        const handler = toolHandlers.get(name);
-        if (!handler) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Tool "${name}" not found`,
-                    },
-                ],
-                isError: true,
-            };
+        // Extract sessionId from request metadata (XMCP-I extension)
+        const sessionId = request._meta?.sessionId;
+        let session = null;
+        if (sessionId) {
+            session = await sessionManager.getSession(sessionId);
+            if (!session && identityConfig?.debug) {
+                console.error(`[MCPI] Session not found or expired: ${sessionId}`);
+            }
         }
-        try {
-            // Execute the tool handler
-            const result = await handler(args || {});
-            // Build base response
-            const baseResponse = {
-                content: [
-                    {
-                        type: "text",
-                        text: typeof result === "string" ? result : JSON.stringify(result),
-                    },
-                ],
-            };
-            // If identity is enabled, generate cryptographic proof
-            if (identityManager) {
-                try {
-                    // Ensure identity exists
-                    const identity = await identityManager.ensureIdentity();
-                    // Create a session context for this request
-                    const toolRequest = {
-                        method: name,
-                        params: args || {},
-                    };
-                    const toolResponse = {
-                        data: result,
-                    };
-                    // Create a session context for standalone tool calls
-                    // In a full implementation, this would use proper handshake
-                    // TODO: Use proper handshake
-                    const timestamp = Math.floor(Date.now() / 1000);
-                    const session = {
-                        sessionId: `tool-${Date.now()}`,
-                        nonce: `${Date.now()}`,
-                        audience: "client",
-                        createdAt: timestamp,
-                        timestamp,
-                        lastActivity: timestamp,
-                        ttlMinutes: 30,
+        // Wrap tool execution with request context for AsyncLocalStorage
+        return (0, request_context_1.runWithContext)({
+            session: session || undefined,
+            requestId: request._meta?.requestId,
+            startTime: Date.now(),
+        }, async () => {
+            const { name, arguments: args } = request.params;
+            const handler = toolHandlers.get(name);
+            if (!handler) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Tool "${name}" not found`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // PHASE 1.5: Check if tool is protected BEFORE executing
+            const toolProtection = tool_protection_registry_1.toolProtectionRegistry.get(name);
+            if (toolProtection?.requiresDelegation) {
+                const authConfig = tool_protection_registry_1.toolProtectionRegistry.getAuthConfig();
+                const delegationVerifier = tool_protection_registry_1.toolProtectionRegistry.getDelegationVerifier();
+                if (!delegationVerifier || !authConfig) {
+                    if (identityConfig?.debug) {
+                        console.error(`[MCPI] Tool "${name}" requires delegation but verifier not configured`);
+                    }
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `❌ Tool "${name}" requires delegation verification, but the delegation system is not configured.\n\n` +
+                                    `To fix this:\n` +
+                                    `1. Configure a delegation verifier:\n` +
+                                    `   - MemoryDelegationVerifier (development/testing)\n` +
+                                    `   - KVDelegationVerifier (production with KV store)\n` +
+                                    `   - AgentShieldVerifier (production with AgentShield service)\n\n` +
+                                    `2. Enable delegation in your runtime config:\n` +
+                                    `   const runtime = new MCPIRuntime({\n` +
+                                    `     delegation: { enabled: true },\n` +
+                                    `     // ... other config\n` +
+                                    `   });\n\n` +
+                                    `3. Ensure the verifier is initialized before tool execution.\n\n` +
+                                    `📚 Documentation: https://docs.mcp-i.dev/delegation/setup`,
+                            },
+                        ],
+                        isError: true,
                     };
-                    // Generate proof using the proof generator
-                    const proofGen = new proof_1.ProofGenerator(identity);
-                    const proof = await proofGen.generateProof(toolRequest, toolResponse, session);
+                }
+                // Extract agent DID from current request context (AsyncLocalStorage)
+                const agentDid = (0, request_context_1.getCurrentAgentDid)();
+                if (!agentDid) {
                     if (identityConfig?.debug) {
-                        console.error(`[MCPI] Generated proof for tool "${name}" - DID: ${proof.meta.did}`);
+                        console.error(`[MCPI] Tool "${name}" requires delegation but no agent DID in session`);
                     }
-                    // Return response with proof metadata
                     return {
-                        ...baseResponse,
-                        _meta: {
-                            proof,
-                        },
+                        content: [
+                            {
+                                type: "text",
+                                text: `❌ Tool "${name}" requires delegation, but no agent identity was found in the current session.\n\n` +
+                                    `This usually means one of the following:\n\n` +
+                                    `1. **No handshake was performed**: The MCP client must send a handshake request before calling protected tools.\n` +
+                                    `   Example handshake:\n` +
+                                    `   {\n` +
+                                    `     "agentDid": "did:key:z6Mk...",\n` +
+                                    `     "nonce": "unique-value",\n` +
+                                    `     "audience": "server-did",\n` +
+                                    `     "timestamp": ${Date.now()}\n` +
+                                    `   }\n\n` +
+                                    `2. **Handshake missing agentDid**: Ensure the handshake request includes the 'agentDid' field.\n\n` +
+                                    `3. **Session expired**: The session may have expired. Try performing a new handshake.\n\n` +
+                                    `4. **Request missing sessionId**: Ensure tool call requests include _meta.sessionId from the handshake response.\n\n` +
+                                    `📚 Learn more: https://docs.mcp-i.dev/delegation/handshake`,
+                            },
+                        ],
+                        isError: true,
                     };
                 }
-                catch (proofError) {
+                if (identityConfig?.debug) {
+                    console.error(`[MCPI] Tool "${name}" requires delegation - verifying scopes: ${toolProtection.requiredScopes?.join(', ')}`);
+                }
+                // Verify delegation
+                const verifyResult = await (0, auth_handshake_1.verifyOrHints)(agentDid, toolProtection.requiredScopes || [], authConfig);
+                // If not authorized, return needs_authorization error
+                if (!verifyResult.authorized) {
                     if (identityConfig?.debug) {
-                        console.error(`[MCPI] Failed to generate proof for tool "${name}":`, proofError);
+                        console.error(`[MCPI] Tool "${name}" blocked - authorization required`);
                     }
-                    // Return base response without proof if generation fails
-                    return baseResponse;
+                    // Return MCP error format with authorization hints
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "needs_authorization",
+                                    message: `Tool "${name}" requires user authorization`,
+                                    authorizationUrl: verifyResult.authError?.authorizationUrl,
+                                    resumeToken: verifyResult.authError?.resumeToken,
+                                    scopes: verifyResult.authError?.scopes,
+                                    display: verifyResult.authError?.display,
+                                }),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                if (identityConfig?.debug) {
+                    console.error(`[MCPI] Tool "${name}" authorized - executing handler`);
                 }
             }
-            return baseResponse;
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error executing tool "${name}": ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
+            try {
+                // Execute the tool handler
+                const result = await handler(args || {});
+                // Build base response
+                const baseResponse = {
+                    content: [
+                        {
+                            type: "text",
+                            text: typeof result === "string" ? result : JSON.stringify(result),
+                        },
+                    ],
+                };
+                // If identity is enabled, generate cryptographic proof
+                if (identityManager) {
+                    try {
+                        // Ensure identity exists
+                        const identity = await identityManager.ensureIdentity();
+                        // Create a session context for this request
+                        const toolRequest = {
+                            method: name,
+                            params: args || {},
+                        };
+                        const toolResponse = {
+                            data: result,
+                        };
+                        // Create a session context for standalone tool calls
+                        // In a full implementation, this would use proper handshake
+                        // TODO: Use proper handshake
+                        const timestamp = Math.floor(Date.now() / 1000);
+                        const session = {
+                            sessionId: `tool-${Date.now()}`,
+                            nonce: `${Date.now()}`,
+                            audience: "client",
+                            createdAt: timestamp,
+                            timestamp,
+                            lastActivity: timestamp,
+                            ttlMinutes: 30,
+                        };
+                        // Generate proof using the proof generator
+                        const proofGen = new proof_1.ProofGenerator(identity);
+                        const proof = await proofGen.generateProof(toolRequest, toolResponse, session);
+                        if (identityConfig?.debug) {
+                            console.error(`[MCPI] Generated proof for tool "${name}" - DID: ${proof.meta.did}`);
+                        }
+                        // Submit proof to ProofBatchQueue (if initialized)
+                        if (globalProofQueue) {
+                            try {
+                                globalProofQueue.enqueue(proof);
+                                if (identityConfig?.debug) {
+                                    console.error(`[MCPI] Proof enqueued for submission to AgentShield`);
+                                }
+                            }
+                            catch (queueError) {
+                                if (identityConfig?.debug) {
+                                    console.error(`[MCPI] Failed to enqueue proof:`, queueError);
+                                }
+                                // Continue even if queueing fails - proof is still in response
+                            }
+                        }
+                        // Return response with proof metadata
+                        return {
+                            ...baseResponse,
+                            _meta: {
+                                proof,
+                            },
+                        };
+                    }
+                    catch (proofError) {
+                        if (identityConfig?.debug) {
+                            console.error(`[MCPI] Failed to generate proof for tool "${name}":`, proofError);
+                        }
+                        // Return base response without proof if generation fails
+                        return baseResponse;
+                    }
+                }
+                return baseResponse;
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error executing tool "${name}": ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        });
     });
     if (identityConfig?.debug) {
         console.error("[MCPI] Handlers registered successfully");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kya-os/mcp-i",
-  "version": "1.5.2",
+  "version": "1.5.3-canary.1",
   "description": "The TypeScript MCP framework with identity features built-in",
   "type": "commonjs",
   "main": "dist/index.js",