Cherry-pick: test: add end-to-end tests for elicitation capability round-trip and session state persistence (#297)

Cherry-picked from #296 (merged to release/1.0.x)
Original commit: 4f88506

Co-authored-by: agentfront[bot] <agentfront[bot]@users.noreply.github.com>
Co-authored-by: frontegg-david <69419539+frontegg-david@users.noreply.github.com>

Author: 3 people

apps/e2e/demo-e2e-elicitation/e2e/elicitation.e2e.spec.ts

@@ -531,4 +531,87 @@ test.describe('Elicitation E2E', () => {
       }
     });
   });
+
+  /**
+   * Tests for elicitation capability round-trip.
+   *
+   * These tests verify the full capability negotiation flow that was missing
+   * from previous tests, causing two production bugs to go undetected:
+   * - Bug #1: Server not advertising elicitation in capabilities response
+   * - Bug #2: supportsElicitation flag lost across requests in SSE mode
+   */
+  test.describe('elicitation capability round-trip', () => {
+    test('server should advertise elicitation in capabilities', async ({ mcp }) => {
+      const caps = mcp.capabilities as Record<string, unknown>;
+      expect(caps.elicitation).toBeDefined();
+    });
+
+    test('elicitation should work after prior requests in same session', async ({ mcp }) => {
+      // Do normal requests first — exercises session state persistence
+      const tools = await mcp.tools.list();
+      expect(tools.length).toBeGreaterThan(0);
+
+      // Second request in same session
+      const tools2 = await mcp.tools.list();
+      expect(tools2.length).toEqual(tools.length);
+
+      // Now trigger elicitation — must still work after prior requests
+      mcp.onElicitation(async () => ({
+        action: 'accept',
+        content: { confirmed: true },
+      }));
+
+      const result = await mcp.tools.call('confirm-action', { action: 'test after requests' });
+      expect(result).toBeSuccessful();
+      expect(result.text()).toContain('confirmed and executed');
+      // Must NOT contain fallback instructions — native elicitation should work
+      expect(result.text()).not.toContain('sendElicitationResult');
+    });
+
+    test('tools/list should NOT include sendElicitationResult for elicitation-capable clients', async ({ mcp }) => {
+      const tools = await mcp.tools.list();
+      const toolNames = tools.map((t) => t.name);
+      expect(toolNames).not.toContain('sendElicitationResult');
+    });
+
+    test('should handle multiple sequential elicitations in same session', async ({ mcp }) => {
+      // Do a normal request first
+      await mcp.tools.list();
+
+      // First elicitation
+      mcp.onElicitation(async () => ({
+        action: 'accept',
+        content: { confirmed: true },
+      }));
+      const result1 = await mcp.tools.call('confirm-action', { action: 'first action' });
+      expect(result1).toBeSuccessful();
+      expect(result1.text()).toContain('confirmed and executed');
+
+      // Second elicitation in same session — session state must persist
+      mcp.onElicitation(async () => ({
+        action: 'accept',
+        content: { userInput: 'hello' },
+      }));
+      const result2 = await mcp.tools.call('get-user-input', { prompt: 'say hi' });
+      expect(result2).toBeSuccessful();
+      expect(result2.text()).toContain('hello');
+    });
+
+    test('non-supporting client should get fallback even after prior requests', async ({ server }) => {
+      const noElicitClient = await server.createClientBuilder().withCapabilities({}).withPublicMode().buildAndConnect();
+
+      try {
+        // Do some normal requests first
+        const tools = await noElicitClient.tools.list();
+        expect(tools.map((t) => t.name)).toContain('sendElicitationResult');
+
+        // Now trigger elicitation — should get fallback
+        const result = await noElicitClient.tools.call('confirm-action', { action: 'test' });
+        expect(result).toBeSuccessful();
+        expect(result.text()).toContain('sendElicitationResult');
+      } finally {
+        await noElicitClient.disconnect();
+      }
+    });
+  });
 });

libs/sdk/package.json

@@ -74,7 +74,6 @@
     "cors": "^2.8.5",
     "raw-body": "^3.0.0",
     "content-type": "^1.0.5",
-    "vectoriadb": "^2.1.3",
     "@vercel/kv": "^3.0.0",
     "@frontmcp/storage-sqlite": "0.12.1",
     "@enclave-vm/core": "^2.11.1",
@@ -107,6 +106,7 @@
     "@frontmcp/auth": "0.12.1",
     "@frontmcp/protocol": "0.12.1",
     "ioredis": "^5.8.0",
+    "vectoriadb": "^2.1.3",
     "js-yaml": "^4.1.1",
     "jose": "^6.1.3",
     "reflect-metadata": "^0.2.2",

libs/sdk/src/auth/session/__tests__/session-id.utils.spec.ts

@@ -237,7 +237,7 @@ describe('session-id.utils', () => {
         clientVersion: '1.0.0',
       });
 
-      expect(updated).toBe(true);
+      expect(updated).not.toBeNull();
     });
 
     it('should merge partial updates correctly', () => {
@@ -285,7 +285,7 @@ describe('session-id.utils', () => {
         clientName: 'Test',
       });
 
-      expect(result).toBe(false);
+      expect(result).toBeNull();
     });
 
     it('should decrypt and update if not in cache', () => {

libs/sdk/src/auth/session/utils/session-id.utils.ts

@@ -162,34 +162,43 @@ export function extractSessionFromCookie(cookie?: string): string | undefined {
 }
 
 /**
- * Update a cached session payload with new data.
- * This is used to persist changes like platformType detection that happen
- * after the initial session creation.
+ * Update a cached session payload with new data and re-encrypt to produce
+ * a new session ID that carries the updated payload.
  *
- * @param sessionId - The session ID to update
+ * This ensures that any node in a distributed system (including Vercel Edge
+ * and Cloudflare Workers) can decrypt the session ID and get the full
+ * payload with initialization data (e.g., supportsElicitation, platformType).
+ *
+ * @param sessionId - The current session ID to update
  * @param updates - Partial payload updates to merge
- * @returns true if the session was found and updated, false otherwise
+ * @returns The new session ID with the updated payload baked in, or null if session was invalid
  */
-export function updateSessionPayload(sessionId: string, updates: Partial<SessionIdPayload>): boolean {
+export function updateSessionPayload(sessionId: string, updates: Partial<SessionIdPayload>): string | null {
+  let payload: SessionIdPayload | undefined;
+
   const existing = cache.get(sessionId);
   if (existing) {
-    // Merge updates into existing payload
-    Object.assign(existing, updates);
-    // Re-set to refresh TTL
-    cache.set(sessionId, existing);
-    return true;
+    payload = existing;
+  } else {
+    const decrypted = safeDecrypt(sessionId);
+    if (hasValidSessionStructure(decrypted) || isValidPublicSessionPayload(decrypted)) {
+      payload = decrypted as SessionIdPayload;
+    }
   }
 
-  // Try to decrypt and update if not in cache
-  const decrypted = safeDecrypt(sessionId);
-  if (hasValidSessionStructure(decrypted) || isValidPublicSessionPayload(decrypted)) {
-    const payload = decrypted as SessionIdPayload;
-    Object.assign(payload, updates);
-    cache.set(sessionId, payload);
-    return true;
-  }
+  if (!payload) return null;
+
+  // Merge updates into payload
+  Object.assign(payload, updates);
+
+  // Re-encrypt to produce a new session ID carrying the updated payload
+  const newSessionId = encryptJson(payload);
+
+  // Cache under BOTH old and new session IDs so lookups by either key work
+  cache.set(sessionId, payload);
+  cache.set(newSessionId, payload);
 
-  return false;
+  return newSessionId;
 }
 
 /**

libs/sdk/src/transport/adapters/transport.local.adapter.ts

@@ -34,6 +34,28 @@ export abstract class LocalTransportAdapter<T extends SupportedTransport> {
    */
   protected pendingElicit?: PendingElicit;
 
+  /**
+   * Session payload fields set during MCP initialize.
+   * Stored on the adapter instance so they survive across requests in SSE mode
+   * (where each POST creates a fresh anonymous HTTP session) and are available
+   * in distributed environments without relying on local in-memory caches.
+   */
+  private initSessionPayload?: Partial<{
+    supportsElicitation: boolean;
+    platformType: string;
+    clientName: string;
+    clientVersion: string;
+  }>;
+
+  /**
+   * Called by the initialize request handler to persist initialization data
+   * on the transport adapter instance. This data is merged into the session
+   * payload on every subsequent request via ensureAuthInfo().
+   */
+  setInitSessionPayload(payload: NonNullable<LocalTransportAdapter<T>['initSessionPayload']>): void {
+    this.initSessionPayload = payload;
+  }
+
   #requestId = 1;
   ready: Promise<void>;
   server: McpServer;
@@ -99,6 +121,8 @@ export abstract class LocalTransportAdapter<T extends SupportedTransport> {
     // load asynchronously after connection and may emit change notifications
     const remoteCapabilities = hasRemoteApps ? this.buildRemoteCapabilities() : {};
 
+    const elicitationCapability = this.scope.metadata.elicitation?.enabled ? { elicitation: {} } : {};
+
     const serverOptions = {
       instructions: '',
       capabilities: {
@@ -110,6 +134,7 @@ export abstract class LocalTransportAdapter<T extends SupportedTransport> {
         ...completionsCapability,
         // MCP logging protocol support - allows clients to set log level via logging/setLevel
         logging: {},
+        ...elicitationCapability,
       },
       serverInfo: info,
     };
@@ -202,6 +227,28 @@ export abstract class LocalTransportAdapter<T extends SupportedTransport> {
     const sessionId = session?.id ?? `fallback:${Date.now()}`;
     const sessionPayload = session?.payload ?? { protocol: 'streamable-http' as const };
 
+    // Enrich session payload with initialization data stored on the adapter.
+    // In SSE mode, each HTTP request creates a fresh anonymous session, so
+    // fields set during MCP initialize (supportsElicitation, platformType, etc.)
+    // are lost. The adapter instance persists for the transport's lifetime, so
+    // we merge the initialization payload here. This works in distributed mode
+    // too: the adapter is always on the node that owns the transport session.
+    if (this.initSessionPayload) {
+      const init = this.initSessionPayload;
+      if (init.supportsElicitation !== undefined && sessionPayload.supportsElicitation === undefined) {
+        sessionPayload.supportsElicitation = init.supportsElicitation;
+      }
+      if (init.platformType !== undefined && sessionPayload.platformType === undefined) {
+        (sessionPayload as Record<string, unknown>)['platformType'] = init.platformType;
+      }
+      if (init.clientName !== undefined && sessionPayload.clientName === undefined) {
+        sessionPayload.clientName = init.clientName;
+      }
+      if (init.clientVersion !== undefined && sessionPayload.clientVersion === undefined) {
+        sessionPayload.clientVersion = init.clientVersion;
+      }
+    }
+
     const authInfo: SdkAuthInfo = {
       token,
       user,

libs/sdk/src/transport/mcp-handlers/initialize-request.handler.ts

@@ -5,6 +5,7 @@ import { UnsupportedClientVersionError } from '../../errors';
 import type { ClientCapabilities } from '../../notification';
 import { detectPlatformFromCapabilities, detectAIPlatform, supportsElicitation } from '../../notification';
 import { updateSessionPayload } from '../../auth/session/utils/session-id.utils';
+import type { SdkAuthInfo } from '../../server/server.types';
 
 /**
  * Validates that the client's protocol version is a valid date string format.
@@ -102,14 +103,23 @@ export default function initializeRequestHandler({
               ctx.authInfo.sessionIdPayload.platformType = finalPlatform;
             }
 
-            // Persist to session cache so subsequent requests can access client info
-            // This is critical for HTTP transports where sessions are parsed from encrypted headers
-            updateSessionPayload(sessionId, {
+            const initPayload = {
               clientName,
               clientVersion,
               supportsElicitation: clientSupportsElicitation,
               ...(finalPlatform && { platformType: finalPlatform }),
-            });
+            };
+
+            // Persist to session cache so subsequent requests can access client info
+            // This is critical for HTTP transports where sessions are parsed from encrypted headers
+            updateSessionPayload(sessionId, initPayload);
+
+            // Persist initialization data on the transport adapter instance.
+            // This ensures the data survives across SSE requests (fresh HTTP sessions)
+            // and works in distributed environments (Vercel Edge, Cloudflare Workers)
+            // where the encrypted session payload carries the correct initialization state.
+            const transport = (ctx.authInfo as SdkAuthInfo)?.transport;
+            transport?.setInitSessionPayload(initPayload);
           }
         } else if (ctx.authInfo?.sessionIdPayload) {
           // Update platform and elicitation support even without client info
@@ -118,11 +128,17 @@ export default function initializeRequestHandler({
             ctx.authInfo.sessionIdPayload.platformType = detectedPlatform;
           }
 
-          // Persist to session cache
-          updateSessionPayload(sessionId, {
+          const initPayload = {
             supportsElicitation: clientSupportsElicitation,
             ...(detectedPlatform && { platformType: detectedPlatform }),
-          });
+          };
+
+          // Persist to session cache
+          updateSessionPayload(sessionId, initPayload);
+
+          // Persist on transport adapter instance
+          const transport = (ctx.authInfo as SdkAuthInfo)?.transport;
+          transport?.setInitSessionPayload(initPayload);
         }
       }