@kya-os/mcp-i-cloudflare 1.5.8-canary.34 → 1.5.8-canary.35

package/dist/adapter.js

@@ -122,13 +122,62 @@ class CloudflareMCPServer {
                         isProvided: !!providedSessionId,
                         isEphemeral: !providedSessionId,
                     });
+                    // Extract OAuth identity from request or session cache for persistent userDid lookup
+                    let oauthIdentity = undefined;
+                    if (meta?.request) {
+                        oauthIdentity = this.extractOAuthIdentityFromRequest(meta.request);
+                        if (oauthIdentity) {
+                            console.log("[CloudflareMCPServer] Extracted OAuth identity from request:", {
+                                provider: oauthIdentity.provider,
+                                subject: oauthIdentity.subject.substring(0, 20) + "...",
+                            });
+                        }
+                    }
+                    // If OAuth identity not in request, try to get from session cache
+                    if (!oauthIdentity && sessionId && this.delegationStorage) {
+                        try {
+                            const sessionKey = STORAGE_KEYS.session(sessionId);
+                            const sessionData = (await this.delegationStorage.get(sessionKey, "json"));
+                            if (sessionData?.oauthIdentity?.provider) {
+                                // Note: We only have subjectHash in session cache (PII protection)
+                                // We can't fully reconstruct OAuth identity, but we can use it to lookup userDid
+                                console.log("[CloudflareMCPServer] Found OAuth identity in session cache:", {
+                                    provider: sessionData.oauthIdentity.provider,
+                                    hasSubjectHash: !!sessionData.oauthIdentity.subjectHash,
+                                });
+                                // OAuth identity from session cache is incomplete (subjectHash only), so we'll use it for userDid lookup via storage
+                            }
+                        }
+                        catch (error) {
+                            console.warn("[CloudflareMCPServer] Failed to get OAuth identity from session:", error);
+                            // Non-fatal - continue without OAuth identity
+                        }
+                    }
                     // Check KV storage for stored delegation token if not provided in params
                     let delegationToken = params.delegationToken;
                     if (!delegationToken && this.delegationStorage) {
                         try {
                             // Get userDID from params first
                             let userDid = params.clientDid || params.userDid;
-                            // ✅ FIX: If userDid not in params, try to retrieve from session cache
+                            // ✅ PRIORITY 1: If OAuth identity available, use it to lookup persistent userDid
+                            if (!userDid && oauthIdentity && this.delegationStorage) {
+                                try {
+                                    const oauthKey = STORAGE_KEYS.oauthIdentity(oauthIdentity.provider, oauthIdentity.subject);
+                                    const mappedUserDid = await this.delegationStorage.get(oauthKey, "text");
+                                    if (mappedUserDid) {
+                                        userDid = mappedUserDid;
+                                        console.log("[CloudflareMCPServer] ✅ Retrieved persistent userDid from OAuth mapping:", {
+                                            provider: oauthIdentity.provider,
+                                            userDid: userDid.slice(0, 20) + "...",
+                                        });
+                                    }
+                                }
+                                catch (error) {
+                                    console.warn("[CloudflareMCPServer] Failed to lookup userDid from OAuth mapping:", error);
+                                    // Non-fatal - continue with session cache lookup
+                                }
+                            }
+                            // ✅ PRIORITY 2: If userDid not in params or OAuth mapping, try to retrieve from session cache
                             if (!userDid && sessionId) {
                                 try {
                                     const sessionKey = STORAGE_KEYS.session(sessionId);
@@ -152,56 +201,17 @@ class CloudflareMCPServer {
                                 sessionId: sessionId?.slice(0, 20) + "..." || "none",
                                 hasDelegationStorage: !!this.delegationStorage,
                             });
-                            // PRIORITY 1: Try agent-scoped token FIRST (stable across sessions)
-                            // This is the most reliable lookup since sessions are ephemeral in Cloudflare Workers
-                            // The consent service stores tokens with this key format
-                            const agentKey = STORAGE_KEYS.legacyDelegation(agentDid);
-                            console.log("[CloudflareMCPServer] 🔍 PRIORITY 1: Checking agent-scoped key:", {
-                                key: agentKey,
-                                agentDid: agentDid.slice(0, 20) + "...",
-                            });
-                            const agentToken = await this.delegationStorage.get(agentKey, "text");
-                            console.log("[CloudflareMCPServer] 🔍 PRIORITY 1: Agent-scoped lookup result:", {
-                                key: agentKey,
-                                found: !!agentToken,
-                                tokenLength: agentToken?.length || 0,
-                                tokenPreview: agentToken ? agentToken.substring(0, 20) + "..." : null,
-                            });
-                            if (agentToken) {
-                                delegationToken = agentToken;
-                                console.log("[CloudflareMCPServer] ✅ Delegation token retrieved from agent-scoped key:", {
-                                    agentDid: agentDid.slice(0, 20) + "...",
-                                    key: agentKey,
-                                    tokenLength: agentToken.length,
-                                });
-                                // Cache it for this session for faster future lookups
-                                // Store full session data object to match consent service format
-                                if (sessionId) {
-                                    const sessionKey = STORAGE_KEYS.session(sessionId);
-                                    // Read existing session data to preserve userDid and other fields
-                                    const existingSession = (await this.delegationStorage.get(sessionKey, "json"));
-                                    await this.delegationStorage.put(sessionKey, JSON.stringify({
-                                        ...existingSession,
-                                        userDid,
-                                        agentDid,
-                                        delegationToken: agentToken,
-                                        cachedAt: Date.now(),
-                                    }), {
-                                        expirationTtl: 1800, // 30 minutes
-                                    });
-                                }
-                            }
-                            // PRIORITY 2: Try user+agent scoped token (if userDID is available)
-                            // This is the preferred approach for multi-user scenarios
-                            if (!delegationToken && userDid) {
+                            // PRIORITY 1: Try user+agent scoped token (user-specific, most secure)
+                            // This is the preferred approach for multi-user scenarios with proper user isolation
+                            if (userDid) {
                                 const userAgentKey = STORAGE_KEYS.delegation(userDid, agentDid);
-                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 2: Checking user+agent scoped key:", {
+                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 1: Checking user+agent scoped key:", {
                                     key: userAgentKey,
                                     userDid: userDid.slice(0, 20) + "...",
                                     agentDid: agentDid.slice(0, 20) + "...",
                                 });
                                 const userAgentToken = await this.delegationStorage.get(userAgentKey, "text");
-                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 2: User+agent scoped lookup result:", {
+                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 1: User+agent scoped lookup result:", {
                                     key: userAgentKey,
                                     found: !!userAgentToken,
                                     tokenLength: userAgentToken?.length || 0,
@@ -233,17 +243,17 @@ class CloudflareMCPServer {
                                     }
                                 }
                             }
-                            // PRIORITY 3: Try session-scoped token (if session ID was persisted)
+                            // PRIORITY 2: Try session-scoped token (if session ID was persisted)
                             // Note: Sessions are ephemeral in Cloudflare Workers, so this is mainly
                             // useful for caching tokens within a single request chain
                             if (!delegationToken && sessionId) {
                                 const sessionKey = STORAGE_KEYS.session(sessionId);
-                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 3: Checking session-scoped key:", {
+                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 2: Checking session-scoped key:", {
                                     key: sessionKey,
                                     sessionId: sessionId.slice(0, 20) + "...",
                                 });
                                 const sessionData = (await this.delegationStorage.get(sessionKey, "json"));
-                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 3: Session-scoped lookup result:", {
+                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 2: Session-scoped lookup result:", {
                                     key: sessionKey,
                                     found: !!sessionData,
                                     hasDelegationToken: !!sessionData?.delegationToken,
@@ -258,18 +268,71 @@ class CloudflareMCPServer {
                                     });
                                 }
                             }
+                            // PRIORITY 3: Try agent-scoped token (legacy fallback - DEPRECATED)
+                            // Only use when userDid is unavailable (backward compatibility)
+                            // WARNING: This allows cross-user delegation sharing - migrate to user+agent scoped tokens
+                            if (!delegationToken && !userDid) {
+                                const agentKey = STORAGE_KEYS.legacyDelegation(agentDid);
+                                console.warn("[CloudflareMCPServer] ⚠️ DEPRECATION: Using agent-scoped token (legacy format). Migrate to user+agent scoped tokens for proper user isolation.", {
+                                    key: agentKey,
+                                    agentDid: agentDid.slice(0, 20) + "...",
+                                    reason: "userDid unavailable",
+                                });
+                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 3: Checking agent-scoped key (legacy):", {
+                                    key: agentKey,
+                                    agentDid: agentDid.slice(0, 20) + "...",
+                                });
+                                const agentToken = await this.delegationStorage.get(agentKey, "text");
+                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 3: Agent-scoped lookup result:", {
+                                    key: agentKey,
+                                    found: !!agentToken,
+                                    tokenLength: agentToken?.length || 0,
+                                    tokenPreview: agentToken ? agentToken.substring(0, 20) + "..." : null,
+                                });
+                                if (agentToken) {
+                                    delegationToken = agentToken;
+                                    console.log("[CloudflareMCPServer] ✅ Delegation token retrieved from agent-scoped key (legacy):", {
+                                        agentDid: agentDid.slice(0, 20) + "...",
+                                        key: agentKey,
+                                        tokenLength: agentToken.length,
+                                    });
+                                    // Cache it for this session for faster future lookups
+                                    // Store full session data object to match consent service format
+                                    if (sessionId) {
+                                        const sessionKey = STORAGE_KEYS.session(sessionId);
+                                        // Read existing session data to preserve userDid and other fields
+                                        const existingSession = (await this.delegationStorage.get(sessionKey, "json"));
+                                        await this.delegationStorage.put(sessionKey, JSON.stringify({
+                                            ...existingSession,
+                                            userDid,
+                                            agentDid,
+                                            delegationToken: agentToken,
+                                            cachedAt: Date.now(),
+                                        }), {
+                                            expirationTtl: 1800, // 30 minutes
+                                        });
+                                    }
+                                }
+                            }
                             if (!delegationToken) {
+                                const checkedKeys = [];
+                                // Only include agent-scoped key if it was checked (when userDid unavailable)
+                                if (!userDid) {
+                                    checkedKeys.push(STORAGE_KEYS.legacyDelegation(agentDid));
+                                }
+                                // Always include user+agent scoped key if userDid is available
+                                if (userDid) {
+                                    checkedKeys.push(STORAGE_KEYS.delegation(userDid, agentDid));
+                                }
+                                // Always include session-scoped key if sessionId is available
+                                if (sessionId) {
+                                    checkedKeys.push(STORAGE_KEYS.session(sessionId));
+                                }
                                 console.log("[CloudflareMCPServer] ⚠️ No delegation token found in KV storage:", {
                                     agentDid: agentDid.slice(0, 20) + "...",
                                     userDid: userDid?.slice(0, 20) + "..." || "none",
                                     sessionId: sessionId?.slice(0, 20) + "..." || "none",
-                                    checkedKeys: [
-                                        agentKey,
-                                        userDid
-                                            ? STORAGE_KEYS.delegation(userDid, agentDid)
-                                            : null,
-                                        sessionId ? STORAGE_KEYS.session(sessionId) : null,
-                                    ].filter(Boolean),
+                                    checkedKeys: checkedKeys.filter(Boolean),
                                 });
                             }
                         }
@@ -322,28 +385,18 @@ class CloudflareMCPServer {
                                 userDid: userDid?.slice(0, 20) + "...",
                                 agentDid: agentDid?.slice(0, 20) + "...",
                             });
-                            // PRIORITY 1: Try agent-scoped token FIRST (stable across sessions)
-                            const agentKey = STORAGE_KEYS.legacyDelegation(agentDid);
-                            console.log("[CloudflareMCPServer] 🔍 PRIORITY 1: Checking agent-scoped key:", {
-                                key: agentKey,
-                                agentDid: agentDid.slice(0, 20) + "...",
-                            });
-                            let delegationToken = await this.delegationStorage.get(agentKey, "text");
-                            console.log("[CloudflareMCPServer] 🔍 PRIORITY 1: Agent-scoped lookup result:", {
-                                key: agentKey,
-                                found: !!delegationToken,
-                                tokenLength: delegationToken?.length || 0,
-                            });
-                            // PRIORITY 2: Try user+agent scoped token (if userDID is available)
-                            if (!delegationToken && userDid) {
+                            // PRIORITY 1: Try user+agent scoped token (user-specific, most secure)
+                            // This is the preferred approach for multi-user scenarios with proper user isolation
+                            let delegationToken = undefined;
+                            if (userDid) {
                                 const userAgentKey = STORAGE_KEYS.delegation(userDid, agentDid);
-                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 2: Checking user+agent scoped key:", {
+                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 1: Checking user+agent scoped key (existing session):", {
                                     key: userAgentKey,
                                     userDid: userDid.slice(0, 20) + "...",
                                     agentDid: agentDid.slice(0, 20) + "...",
                                 });
                                 const userAgentToken = await this.delegationStorage.get(userAgentKey, "text");
-                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 2: User+agent scoped lookup result:", {
+                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 1: User+agent scoped lookup result:", {
                                     key: userAgentKey,
                                     found: !!userAgentToken,
                                     tokenLength: userAgentToken?.length || 0,
@@ -352,27 +405,55 @@ class CloudflareMCPServer {
                                     delegationToken = userAgentToken;
                                 }
                             }
-                            // PRIORITY 3: Try session-scoped token (if session ID was persisted)
+                            // PRIORITY 2: Try session-scoped token (if session ID was persisted)
                             if (!delegationToken && sessionId) {
                                 const sessionKey = STORAGE_KEYS.session(sessionId);
-                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 3: Looking up session key:", {
-                                    sessionKey,
+                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 2: Checking session-scoped key (existing session):", {
+                                    key: sessionKey,
                                     sessionId: sessionId.slice(0, 20) + "...",
                                 });
+                                const sessionData = (await this.delegationStorage.get(sessionKey, "json"));
+                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 2: Session-scoped lookup result:", {
+                                    key: sessionKey,
+                                    found: !!sessionData,
+                                    hasDelegationToken: !!sessionData?.delegationToken,
+                                    tokenLength: sessionData?.delegationToken?.length || 0,
+                                });
+                                if (sessionData?.delegationToken) {
+                                    delegationToken = sessionData.delegationToken;
+                                }
+                            }
+                            // PRIORITY 3: Try agent-scoped token (legacy fallback - DEPRECATED)
+                            // Only use when userDid is unavailable (backward compatibility)
+                            if (!delegationToken && !userDid) {
+                                const agentKey = STORAGE_KEYS.legacyDelegation(agentDid);
+                                console.warn("[CloudflareMCPServer] ⚠️ DEPRECATION: Using agent-scoped token (legacy format). Migrate to user+agent scoped tokens for proper user isolation.", {
+                                    key: agentKey,
+                                    agentDid: agentDid.slice(0, 20) + "...",
+                                    reason: "userDid unavailable",
+                                });
+                                console.log("[CloudflareMCPServer] 🔍 PRIORITY 3: Checking agent-scoped key (legacy, existing session):", {
+                                    key: agentKey,
+                                    agentDid: agentDid.slice(0, 20) + "...",
+                                });
                                 try {
-                                    const sessionData = (await this.delegationStorage.get(sessionKey, "json"));
-                                    console.log("[CloudflareMCPServer] 🔍 PRIORITY 3: Session-scoped lookup result:", {
-                                        key: sessionKey,
-                                        found: !!sessionData,
-                                        hasDelegationToken: !!sessionData?.delegationToken,
-                                        tokenLength: sessionData?.delegationToken?.length || 0,
+                                    const agentToken = await this.delegationStorage.get(agentKey, "text");
+                                    console.log("[CloudflareMCPServer] 🔍 PRIORITY 3: Agent-scoped lookup result:", {
+                                        key: agentKey,
+                                        found: !!agentToken,
+                                        tokenLength: agentToken?.length || 0,
                                     });
-                                    if (sessionData?.delegationToken) {
-                                        delegationToken = sessionData.delegationToken;
+                                    if (agentToken) {
+                                        delegationToken = agentToken;
+                                        console.log("[CloudflareMCPServer] ✅ Delegation token retrieved from agent-scoped key (legacy, existing session):", {
+                                            agentDid: agentDid.slice(0, 20) + "...",
+                                            key: agentKey,
+                                            tokenLength: agentToken.length,
+                                        });
                                     }
                                 }
                                 catch (error) {
-                                    console.error("[CloudflareMCPServer] Error retrieving session data:", error);
+                                    console.error("[CloudflareMCPServer] Error retrieving agent token:", error);
                                 }
                             }
                             // ✅ CRITICAL: Set delegation token on session if found
@@ -389,13 +470,22 @@ class CloudflareMCPServer {
                                 });
                             }
                             else {
+                                const checkedKeys = [];
+                                // Only include agent-scoped key if it was checked (when userDid unavailable)
+                                if (!userDid) {
+                                    checkedKeys.push(STORAGE_KEYS.legacyDelegation(agentDid));
+                                }
+                                // Always include user+agent scoped key if userDid is available
+                                if (userDid) {
+                                    checkedKeys.push(STORAGE_KEYS.delegation(userDid, agentDid));
+                                }
+                                // Always include session-scoped key if sessionId is available
+                                if (sessionId) {
+                                    checkedKeys.push(STORAGE_KEYS.session(sessionId));
+                                }
                                 console.log("[CloudflareMCPServer] ⚠️ No delegation token found in KV storage for existing session:", {
                                     sessionId: sessionId?.slice(0, 20) + "..." || "none",
-                                    checkedKeys: [
-                                        agentKey,
-                                        userDid ? STORAGE_KEYS.delegation(userDid, agentDid) : null,
-                                        sessionId ? STORAGE_KEYS.session(sessionId) : null,
-                                    ].filter(Boolean),
+                                    checkedKeys: checkedKeys.filter(Boolean),
                                 });
                             }
                             // PRIORITY 2: Try user+agent scoped token (if userDID is available)
@@ -434,10 +524,16 @@ class CloudflareMCPServer {
                                     hasUserDid: !!userDid,
                                 });
                             }
-                            // PRIORITY 3: Try agent-scoped token (fallback)
-                            if (!session.delegationToken) {
+                            // PRIORITY 3: Try agent-scoped token (legacy fallback - DEPRECATED)
+                            // Only use when userDid is unavailable (backward compatibility)
+                            if (!session.delegationToken && !userDid) {
                                 const agentKey = STORAGE_KEYS.legacyDelegation(agentDid);
-                                console.log("[CloudflareMCPServer] PRIORITY 3: Looking up agent key:", {
+                                console.warn("[CloudflareMCPServer] ⚠️ DEPRECATION: Using agent-scoped token (legacy format). Migrate to user+agent scoped tokens for proper user isolation.", {
+                                    key: agentKey,
+                                    agentDid: agentDid.slice(0, 20) + "...",
+                                    reason: "userDid unavailable",
+                                });
+                                console.log("[CloudflareMCPServer] PRIORITY 3: Looking up agent key (legacy):", {
                                     agentKey,
                                     agentDid: agentDid.slice(0, 20) + "...",
                                 });
@@ -448,7 +544,7 @@ class CloudflareMCPServer {
                                             ...session,
                                             delegationToken: agentToken,
                                         };
-                                        console.log("[CloudflareMCPServer] ✅ Delegation token retrieved from agent-scoped key (existing session):", {
+                                        console.log("[CloudflareMCPServer] ✅ Delegation token retrieved from agent-scoped key (legacy, existing session):", {
                                             agentDid: agentDid.slice(0, 20) + "...",
                                             key: agentKey,
                                             tokenLength: agentToken.length,
@@ -526,17 +622,38 @@ class CloudflareMCPServer {
                 session.scopeId = scopeId; // ✅ ADDED: Pass scopeId for tool auto-discovery
                 // ✅ CRITICAL: Verify delegation token is set on session before processToolCall
                 // Also do a final KV lookup if token is still missing (defensive check)
+                // Use same 3-priority lookup: user+agent scoped, then session-scoped, then agent-scoped (last resort)
                 if (!session?.delegationToken && this.delegationStorage) {
                     try {
                         const agentDid = (await this.runtime.getIdentity()).did;
-                        const agentKey = STORAGE_KEYS.legacyDelegation(agentDid);
-                        const finalToken = await this.delegationStorage.get(agentKey, "text");
+                        const userDid = session.userDid || params.clientDid || params.userDid;
+                        let finalToken = undefined;
+                        // PRIORITY 1: User+agent scoped token
+                        if (userDid) {
+                            const userAgentKey = STORAGE_KEYS.delegation(userDid, agentDid);
+                            const token = await this.delegationStorage.get(userAgentKey, "text");
+                            finalToken = token || undefined; // Convert null to undefined
+                        }
+                        // PRIORITY 2: Session-scoped token
+                        if (!finalToken && session.id) {
+                            const sessionKey = STORAGE_KEYS.session(session.id);
+                            const sessionData = (await this.delegationStorage.get(sessionKey, "json"));
+                            finalToken = sessionData?.delegationToken;
+                        }
+                        // PRIORITY 3: Agent-scoped token (legacy fallback - only if userDid unavailable)
+                        if (!finalToken && !userDid) {
+                            const agentKey = STORAGE_KEYS.legacyDelegation(agentDid);
+                            const token = await this.delegationStorage.get(agentKey, "text");
+                            finalToken = token || undefined; // Convert null to undefined
+                        }
                         if (finalToken) {
                             session.delegationToken = finalToken;
                             console.log("[CloudflareMCPServer] ✅ Final KV lookup succeeded, token set on session:", {
                                 toolName,
                                 agentDid: agentDid.slice(0, 20) + "...",
+                                userDid: userDid?.slice(0, 20) + "..." || "none",
                                 tokenLength: finalToken.length,
+                                source: userDid ? (session.id ? "session-scoped" : "user+agent-scoped") : "agent-scoped (legacy)",
                             });
                         }
                     }
@@ -602,31 +719,27 @@ class CloudflareMCPServer {
                             normalizedClientInfo.capabilities;
                     }
                 }
-                // Phase 4 PR #5: Extract OAuth identity and lookup persistent User DID BEFORE handshake
-                let userDid = undefined;
-                if (this.delegationStorage && meta?.request) {
-                    const oauthIdentity = this.extractOAuthIdentityFromRequest(meta.request);
+                // Phase 4 PR #5: Extract OAuth identity BEFORE handshake and pass to runtime
+                let oauthIdentity = undefined;
+                if (meta?.request) {
+                    oauthIdentity = this.extractOAuthIdentityFromRequest(meta.request);
                     if (oauthIdentity) {
-                        try {
-                            const oauthKey = STORAGE_KEYS.oauthIdentity(oauthIdentity.provider, oauthIdentity.subject);
-                            const mappedUserDid = await this.delegationStorage.get(oauthKey, "text");
-                            if (mappedUserDid) {
-                                userDid = mappedUserDid;
-                                console.log("[Adapter] Found persistent User DID for return user:", {
-                                    provider: oauthIdentity.provider,
-                                    userDid: userDid.substring(0, 20) + "...",
-                                });
-                            }
-                        }
-                        catch (error) {
-                            console.warn("[Adapter] Failed to lookup persistent User DID:", error);
-                            // Non-fatal - continue with handshake
-                        }
+                        console.log("[Adapter] Extracted OAuth identity for handshake:", {
+                            provider: oauthIdentity.provider,
+                            subject: oauthIdentity.subject.substring(0, 20) + "...",
+                        });
+                        // Add OAuth identity to handshake payload for persistent user DID lookup
+                        // Type assertion needed because HandshakeRequest doesn't include oauthIdentity,
+                        // but handleHandshake accepts it via intersection type
+                        handshakePayload.oauthIdentity = oauthIdentity;
                     }
                 }
                 const handshakeResult = await this.runtime.handleHandshake(handshakePayload);
-                // Phase 4 PR #5: Store User DID and clientId in session AFTER handshake
-                if (userDid && this.delegationStorage && handshakeResult.sessionId) {
+                // Get userDid from handshake result (may have been retrieved via OAuth mapping)
+                const userDid = handshakeResult.userDid;
+                // Phase 4 PR #5: Store User DID, OAuth identity (with redacted subject), and clientId in session AFTER handshake
+                // Only store if userDid is available (from OAuth mapping or handshake result)
+                if (this.delegationStorage && handshakeResult.sessionId && userDid) {
                     try {
                         const sessionKey = STORAGE_KEYS.session(handshakeResult.sessionId);
                         const existingSession = (await this.delegationStorage.get(sessionKey, "json"));
@@ -634,16 +747,29 @@ class CloudflareMCPServer {
                         const clientId = handshakePayload.clientInfo?.clientId;
                         // Get agentDid from runtime identity
                         const agentDid = (await this.runtime.getIdentity()).did;
+                        // Store OAuth identity with redacted subject for PII protection
+                        const oauthIdentityForStorage = oauthIdentity
+                            ? {
+                                provider: oauthIdentity.provider,
+                                subjectHash: oauthIdentity.subject.substring(0, 8), // Redact full subject
+                                // Don't store email, name, or full subject for PII protection
+                            }
+                            : undefined;
                         await this.delegationStorage.put(sessionKey, JSON.stringify({
                             ...(existingSession || {}),
                             userDid,
                             agentDid,
                             ...(clientId && { clientId }),
+                            ...(oauthIdentityForStorage && { oauthIdentity: oauthIdentityForStorage }),
                         }), { expirationTtl: DEFAULT_SESSION_CACHE_TTL });
-                        console.log("[Adapter] Stored User DID, agentDid, and clientId in session for return user");
+                        console.log("[Adapter] Stored User DID, agentDid, clientId, and OAuth identity (redacted) in session", {
+                            hasUserDid: !!userDid,
+                            hasOAuth: !!oauthIdentity,
+                            provider: oauthIdentity?.provider,
+                        });
                     }
                     catch (error) {
-                        console.warn("[Adapter] Failed to store User DID in session:", error);
+                        console.warn("[Adapter] Failed to store session data:", error);
                         // Non-fatal - continue
                     }
                 }
@@ -872,16 +998,104 @@ class CloudflareMCPServer {
                 return null;
             const cookieValue = oauthCookie.substring(equalsIndex + 1);
             const parsed = JSON.parse(decodeURIComponent(cookieValue));
-            // Validate required fields
-            if (parsed && parsed.provider && parsed.subject) {
-                return parsed;
+            // ✅ SECURITY: Validate OAuth identity format and content
+            const validationResult = this.validateOAuthIdentity(parsed);
+            if (!validationResult.valid) {
+                console.warn("[Adapter] ⚠️ OAuth identity validation failed:", validationResult.reason, { parsed });
+                return null;
             }
+            return parsed;
         }
         catch (error) {
             console.warn("[Adapter] Failed to extract OAuth identity from cookies:", error);
         }
         return null;
     }
+    /**
+     * Validate OAuth identity format and content
+     *
+     * Ensures:
+     * - Provider is non-empty string (1-50 chars)
+     * - Subject is non-empty string (1-255 chars)
+     * - Provider matches expected format (alphanumeric, hyphens, underscores)
+     * - Subject matches expected format (non-empty, reasonable length)
+     *
+     * @param identity - Parsed OAuth identity object
+     * @returns Validation result
+     */
+    validateOAuthIdentity(identity) {
+        // Check if identity is an object
+        if (!identity || typeof identity !== "object") {
+            return { valid: false, reason: "OAuth identity must be an object" };
+        }
+        const oauth = identity;
+        // Validate provider
+        if (!oauth.provider || typeof oauth.provider !== "string") {
+            return { valid: false, reason: "OAuth provider is required and must be a string" };
+        }
+        const provider = oauth.provider.trim();
+        if (provider.length === 0) {
+            return { valid: false, reason: "OAuth provider cannot be empty" };
+        }
+        if (provider.length > 50) {
+            return { valid: false, reason: "OAuth provider must be 50 characters or less" };
+        }
+        // Provider format: alphanumeric, hyphens, underscores, dots (e.g., "google", "microsoft", "github", "custom-provider")
+        const providerPattern = /^[a-zA-Z0-9._-]+$/;
+        if (!providerPattern.test(provider)) {
+            return {
+                valid: false,
+                reason: `OAuth provider must match pattern [a-zA-Z0-9._-]: "${provider}"`,
+            };
+        }
+        // Validate subject
+        if (!oauth.subject || typeof oauth.subject !== "string") {
+            return { valid: false, reason: "OAuth subject is required and must be a string" };
+        }
+        const subject = oauth.subject.trim();
+        if (subject.length === 0) {
+            return { valid: false, reason: "OAuth subject cannot be empty" };
+        }
+        if (subject.length > 255) {
+            return { valid: false, reason: "OAuth subject must be 255 characters or less" };
+        }
+        // Subject format: non-empty, reasonable characters (allows most Unicode, but prevents control chars)
+        // OAuth subjects can be numeric IDs, email-like strings, or other identifiers
+        const subjectPattern = /^[\S]+$/; // At least one non-whitespace character
+        if (!subjectPattern.test(subject)) {
+            return {
+                valid: false,
+                reason: `OAuth subject contains invalid characters: "${subject.substring(0, 20)}..."`,
+            };
+        }
+        // Validate optional email if present
+        if (oauth.email !== undefined) {
+            if (typeof oauth.email !== "string") {
+                return { valid: false, reason: "OAuth email must be a string if provided" };
+            }
+            const email = oauth.email.trim();
+            if (email.length > 0) {
+                // Basic email format validation
+                const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                if (!emailPattern.test(email)) {
+                    return { valid: false, reason: `OAuth email format invalid: "${email}"` };
+                }
+                if (email.length > 255) {
+                    return { valid: false, reason: "OAuth email must be 255 characters or less" };
+                }
+            }
+        }
+        // Validate optional name if present
+        if (oauth.name !== undefined) {
+            if (typeof oauth.name !== "string") {
+                return { valid: false, reason: "OAuth name must be a string if provided" };
+            }
+            if (oauth.name.length > 255) {
+                return { valid: false, reason: "OAuth name must be 255 characters or less" };
+            }
+        }
+        return { valid: true };
+    }
 }
 function buildRequestMeta(request) {
     const ip = request.headers.get("cf-connecting-ip") ??