@kya-os/mcp-i 1.12.2 → 1.12.3

package/dist/runtime/mcpi-runtime.js

@@ -176,69 +176,70 @@ class MCPIRuntime {
         if (!this.cachedIdentity) {
             throw new Error("Runtime not initialized - call initialize() first");
         }
-        // PHASE 1 INTERCEPTOR: Check delegation BEFORE executing tool
-        if (this.config.delegation?.enabled && options.requiresDelegation) {
-            if (!this.delegationVerifier) {
-                throw new Error("Delegation verifier not configured");
-            }
-            if (!options.agentDid) {
-                throw new Error("agentDid required when requiresDelegation=true");
-            }
-            const requiredScopes = options.requiredScopes || [];
-            // Build auth handshake config
-            const authConfig = {
-                delegationVerifier: this.delegationVerifier,
-                resumeTokenStore: this.resumeTokenStore,
-                kta: this.config.delegation.authorization?.kta,
-                bouncer: {
-                    authorizationUrl: this.config.delegation.authorization?.authorizationUrl ||
-                        "https://agentshield.example.com/consent",
-                    resumeTokenTtl: this.config.delegation.authorization?.resumeTokenTtl,
-                    minReputationScore: this.config.delegation.authorization?.minReputationScore,
-                    requireAuthForUnknown: this.config.delegation.authorization?.requireAuthForUnknown,
-                },
-                debug: this.config.identity?.environment === "development",
-            };
-            // Verify delegation or return authorization hints
-            const verifyResult = await (0, auth_handshake_1.verifyOrHints)(options.agentDid, requiredScopes, authConfig);
-            // If not authorized, return needs_authorization error
-            if (!verifyResult.authorized) {
-                if (!verifyResult.authError) {
-                    throw new Error('Authorization failed but no authError was provided');
-                }
-                return verifyResult.authError;
-            }
-            // If authorized, capture delegation metadata for outbound header propagation
-            if (verifyResult.delegation) {
-                options.delegationRef = verifyResult.delegation.id;
-                options.delegationChain = (0, mcp_i_core_1.buildChainString)(verifyResult.delegation);
-                options.delegationScopes = options.requiredScopes ?? [];
-                const identity = await this.identityManager.ensureIdentity();
-                (0, request_context_1.setDelegationContextFromIdentity)({
-                    delegationId: options.delegationRef,
-                    delegationChain: options.delegationChain,
-                    delegationScopes: options.delegationScopes,
-                    // JWS-compact DelegationCredential VC from the verified result —
-                    // emitted on KYA-OS-Delegation-Credential when the verifier
-                    // returned a presentable credential.
-                    delegationCredential: verifyResult.credential?.credential_jwt,
-                    identity,
-                });
-            }
-        }
-        const auditInvocation = this.config.auditTrail
-            ? await (0, mcp_i_runtime_1.beginRuntimeToolAudit)(this.config.auditTrail, {
-                toolName: request.method,
-                args: request.params,
-                session: {
-                    ...session,
-                    id: session.sessionId,
-                },
-            })
-            : undefined;
-        // Capture before async boundary — TS narrowing doesn't survive across async callbacks
+        // Isolate verification and delegation setup before either can change a caller's
+        // context. The tool and proof generation then share this call's own store.
         const cachedIdentity = this.cachedIdentity;
         return (0, request_context_1.runWithContext)({ session: session ?? undefined }, async () => {
+            // PHASE 1 INTERCEPTOR: Check delegation BEFORE executing tool
+            if (this.config.delegation?.enabled && options.requiresDelegation) {
+                if (!this.delegationVerifier) {
+                    throw new Error("Delegation verifier not configured");
+                }
+                if (!options.agentDid) {
+                    throw new Error("agentDid required when requiresDelegation=true");
+                }
+                const requiredScopes = options.requiredScopes || [];
+                // Build auth handshake config
+                const authConfig = {
+                    delegationVerifier: this.delegationVerifier,
+                    resumeTokenStore: this.resumeTokenStore,
+                    kta: this.config.delegation.authorization?.kta,
+                    bouncer: {
+                        authorizationUrl: this.config.delegation.authorization?.authorizationUrl ||
+                            "https://agentshield.example.com/consent",
+                        resumeTokenTtl: this.config.delegation.authorization?.resumeTokenTtl,
+                        minReputationScore: this.config.delegation.authorization?.minReputationScore,
+                        requireAuthForUnknown: this.config.delegation.authorization?.requireAuthForUnknown,
+                    },
+                    debug: this.config.identity?.environment === "development",
+                };
+                // Verify delegation or return authorization hints
+                const verifyResult = await (0, auth_handshake_1.verifyOrHints)(options.agentDid, requiredScopes, authConfig);
+                // If not authorized, return needs_authorization error
+                if (!verifyResult.authorized) {
+                    if (!verifyResult.authError) {
+                        throw new Error('Authorization failed but no authError was provided');
+                    }
+                    return verifyResult.authError;
+                }
+                // If authorized, capture delegation metadata for outbound header propagation
+                if (verifyResult.delegation) {
+                    options.delegationRef = verifyResult.delegation.id;
+                    options.delegationChain = (0, mcp_i_core_1.buildChainString)(verifyResult.delegation);
+                    options.delegationScopes = options.requiredScopes ?? [];
+                    const identity = await this.identityManager.ensureIdentity();
+                    (0, request_context_1.setDelegationContextFromIdentity)({
+                        delegationId: options.delegationRef,
+                        delegationChain: options.delegationChain,
+                        delegationScopes: options.delegationScopes,
+                        // JWS-compact DelegationCredential VC from the verified result —
+                        // emitted on KYA-OS-Delegation-Credential when the verifier
+                        // returned a presentable credential.
+                        delegationCredential: verifyResult.credential?.credential_jwt,
+                        identity,
+                    });
+                }
+            }
+            const auditInvocation = this.config.auditTrail
+                ? await (0, mcp_i_runtime_1.beginRuntimeToolAudit)(this.config.auditTrail, {
+                    toolName: request.method,
+                    args: request.params,
+                    session: {
+                        ...session,
+                        id: session.sessionId,
+                    },
+                })
+                : undefined;
             try {
                 // Execute the tool (only if delegation check passed)
                 let data = await toolHandler(request);