@kya-os/mcp-i 1.6.9 → 1.6.11

package/dist/runtime/tool-protection.d.ts

@@ -21,6 +21,12 @@ export interface ToolProtectionConfig {
     riskLevel?: 'low' | 'medium' | 'high' | 'critical';
     /** Optional custom authorization URL for this specific tool */
     authorizationUrl?: string;
+    /** Authorization method required for this tool */
+    authorization?: {
+        type: 'oauth' | 'credential' | 'none';
+        provider?: string;
+        credentialType?: string;
+    };
 }
 /**
  * Map of tool names to their protection configurations

package/dist/runtime/utils/tools.js

@@ -508,6 +508,95 @@ async function addToolsToServer(server, toolModules, identityConfig) {
                         isError: true,
                     };
                 }
+                // Check if authorization method matches current tool requirements
+                // This prevents stale delegations from working after tool auth method changes
+                if (verifyResult.authorized && toolProtection.authorization) {
+                    const toolAuth = toolProtection.authorization;
+                    const delegationAuth = verifyResult.credential?.authorization;
+                    // If tool requires authorization but credential doesn't have auth data, reject
+                    // This prevents bypassing auth checks with incomplete credential data
+                    if (!delegationAuth) {
+                        if (identityConfig?.debug) {
+                            console.error(`[MCPI] Tool "${name}" blocked - credential missing authorization data`);
+                        }
+                        // Build authorization URL for re-authorization
+                        const authUrl = new URL(authConfig.bouncer.authorizationUrl);
+                        authUrl.searchParams.set("agent_did", agentDid);
+                        authUrl.searchParams.set("scopes", (toolProtection.requiredScopes || []).join(","));
+                        authUrl.searchParams.set("tool", name);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        error: "authorization_data_missing",
+                                        message: `Tool "${name}" requires authorization method ${toolAuth.type}` +
+                                            `${toolAuth.provider ? `:${toolAuth.provider}` : ""}` +
+                                            `${toolAuth.credentialType ? `:${toolAuth.credentialType}` : ""} ` +
+                                            `but delegation credential does not contain authorization data. Please re-authorize.`,
+                                        authorizationUrl: authUrl.toString(),
+                                        scopes: toolProtection.requiredScopes || [],
+                                        requiredAuth: toolAuth,
+                                    }),
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    // Compare authorization types
+                    let authMatches = delegationAuth.type === toolAuth.type;
+                    // For OAuth, also compare provider (undefined in toolAuth means "any provider acceptable")
+                    if (authMatches &&
+                        delegationAuth.type === "oauth" &&
+                        toolAuth.type === "oauth") {
+                        // If tool doesn't specify a provider, any provider is acceptable
+                        if (toolAuth.provider) {
+                            authMatches = delegationAuth.provider === toolAuth.provider;
+                        }
+                    }
+                    // For credential, also compare credentialType (undefined in toolAuth means "any type acceptable")
+                    if (authMatches &&
+                        delegationAuth.type === "credential" &&
+                        toolAuth.type === "credential") {
+                        // If tool doesn't specify a credential type, any type is acceptable
+                        if (toolAuth.credentialType) {
+                            authMatches =
+                                delegationAuth.credentialType === toolAuth.credentialType;
+                        }
+                    }
+                    if (!authMatches) {
+                        if (identityConfig?.debug) {
+                            console.error(`[MCPI] Tool "${name}" blocked - authorization method mismatch`);
+                        }
+                        // Build authorization URL for re-authorization
+                        const authUrl = new URL(authConfig.bouncer.authorizationUrl);
+                        authUrl.searchParams.set("agent_did", agentDid);
+                        authUrl.searchParams.set("scopes", (toolProtection.requiredScopes || []).join(","));
+                        authUrl.searchParams.set("tool", name);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        error: "authorization_method_mismatch",
+                                        message: `Tool "${name}" requires re-authorization. ` +
+                                            `Delegation was created with ${delegationAuth.type}` +
+                                            `${delegationAuth.provider ? `:${delegationAuth.provider}` : ""}` +
+                                            `${delegationAuth.credentialType ? `:${delegationAuth.credentialType}` : ""} ` +
+                                            `but tool now requires ${toolAuth.type}` +
+                                            `${toolAuth.provider ? `:${toolAuth.provider}` : ""}` +
+                                            `${toolAuth.credentialType ? `:${toolAuth.credentialType}` : ""}.`,
+                                        authorizationUrl: authUrl.toString(),
+                                        scopes: toolProtection.requiredScopes || [],
+                                        currentAuth: delegationAuth,
+                                        requiredAuth: toolAuth,
+                                    }),
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                }
                 if (identityConfig?.debug) {
                     console.error(`[MCPI] Tool "${name}" authorized - executing handler`);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kya-os/mcp-i",
-  "version": "1.6.9",
+  "version": "1.6.11",
   "description": "The TypeScript MCP framework with identity features built-in",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -63,8 +63,8 @@
     "model-context-protocol"
   ],
   "dependencies": {
-    "@kya-os/contracts": "^1.6.12",
-    "@kya-os/mcp-i-core": "^1.3.19",
+    "@kya-os/contracts": "^1.6.15",
+    "@kya-os/mcp-i-core": "^1.3.22",
     "@modelcontextprotocol/sdk": "^1.11.4",
     "@swc/core": "^1.11.24",
     "@types/express": "^5.0.1",