Simplify back-compat for form elicitation requests

Author: nbarbettini

src/client/index.test.ts

@@ -14,6 +14,7 @@ import {
     CallToolRequestSchema,
     CreateMessageRequestSchema,
     ElicitRequestSchema,
+    ElicitResultSchema,
     ListRootsRequestSchema,
     ErrorCode
 } from '../types.js';
@@ -917,6 +918,64 @@ test('should reject form-mode elicitation when client only supports URL mode', a
     await client.close();
 });
 
+test('should reject missing-mode elicitation when client only supports URL mode', async () => {
+    const server = new Server(
+        {
+            name: 'test server',
+            version: '1.0'
+        },
+        {
+            capabilities: {}
+        }
+    );
+
+    const client = new Client(
+        {
+            name: 'test client',
+            version: '1.0'
+        },
+        {
+            capabilities: {
+                elicitation: {
+                    url: {}
+                }
+            }
+        }
+    );
+
+    const handler = vi.fn().mockResolvedValue({
+        action: 'cancel'
+    });
+    client.setRequestHandler(ElicitRequestSchema, handler);
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
+
+    await expect(
+        server.request(
+            {
+                method: 'elicitation/create',
+                params: {
+                    message: 'Please provide data',
+                    requestedSchema: {
+                        type: 'object',
+                        properties: {
+                            username: {
+                                type: 'string'
+                            }
+                        }
+                    }
+                }
+            },
+            ElicitResultSchema
+        )
+    ).rejects.toThrow('Client does not support form-mode elicitation requests');
+
+    expect(handler).not.toHaveBeenCalled();
+
+    await Promise.all([client.close(), server.close()]);
+});
+
 test('should reject URL-mode elicitation when client only supports form mode', async () => {
     const client = new Client(
         {

src/client/index.ts

@@ -267,13 +267,14 @@ export class Client<
                 }
 
                 const { params } = validatedRequest.data;
+                const mode = params.mode ?? 'form';
                 const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation);
 
-                if (params.mode === 'form' && !supportsFormMode) {
+                if (mode === 'form' && !supportsFormMode) {
                     throw new McpError(ErrorCode.InvalidParams, 'Client does not support form-mode elicitation requests');
                 }
 
-                if (params.mode === 'url' && !supportsUrlMode) {
+                if (mode === 'url' && !supportsUrlMode) {
                     throw new McpError(ErrorCode.InvalidParams, 'Client does not support URL-mode elicitation requests');
                 }
 
@@ -288,9 +289,9 @@ export class Client<
                 }
 
                 const validatedResult = validationResult.data;
-                const requestedSchema = params.mode === 'form' ? (params.requestedSchema as JsonSchemaType) : undefined;
+                const requestedSchema = mode === 'form' ? (params.requestedSchema as JsonSchemaType) : undefined;
 
-                if (params.mode === 'form' && validatedResult.action === 'accept' && validatedResult.content && requestedSchema) {
+                if (mode === 'form' && validatedResult.action === 'accept' && validatedResult.content && requestedSchema) {
                     if (this._capabilities.elicitation?.form?.applyDefaults) {
                         try {
                             applyElicitationDefaults(requestedSchema, validatedResult.content);

src/server/index.test.ts

@@ -700,7 +700,7 @@ test('should include form mode when sending elicitation form requests', async ()
 
     const receivedModes: string[] = [];
     client.setRequestHandler(ElicitRequestSchema, request => {
-        receivedModes.push(request.params.mode);
+        receivedModes.push(request.params.mode ?? '');
         return {
             action: 'accept',
             content: {
@@ -764,7 +764,7 @@ test('should include url mode when sending elicitation URL requests', async () =
     const receivedModes: string[] = [];
     const receivedIds: string[] = [];
     client.setRequestHandler(ElicitRequestSchema, request => {
-        receivedModes.push(request.params.mode);
+        receivedModes.push(request.params.mode ?? '');
         if (request.params.mode === 'url') {
             receivedIds.push(request.params.elicitationId);
         }

src/server/index.ts

@@ -35,8 +35,6 @@ import {
 import { AjvJsonSchemaValidator } from '../validation/ajv-provider.js';
 import type { JsonSchemaType, jsonSchemaValidator } from '../validation/types.js';
 
-type LegacyElicitRequestFormParams = Omit<ElicitRequestFormParams, 'mode'>;
-
 export type ServerOptions = ProtocolOptions & {
     /**
      * Capabilities to advertise as being supported by this server.
@@ -331,33 +329,13 @@ export class Server<
 
     /**
      * Creates an elicitation request for the given parameters.
-     * @param params The parameters for the form elicitation request (explicit mode: 'form').
+     * For backwards compatibility, `mode` may be omitted for form requests and will default to `'form'`.
+     * @param params The parameters for the elicitation request.
      * @param options Optional request options.
      * @returns The result of the elicitation request.
      */
-    async elicitInput(params: ElicitRequestFormParams, options?: RequestOptions): Promise<ElicitResult>;
-    /**
-     * Creates an elicitation request for the given parameters.
-     * @param params The parameters for the URL elicitation request (with url and elicitationId).
-     * @param options Optional request options.
-     * @returns The result of the elicitation request.
-     */
-    async elicitInput(params: ElicitRequestURLParams, options?: RequestOptions): Promise<ElicitResult>;
-    /**
-     * Creates an elicitation request for the given parameters.
-     * @deprecated Use the overloads with explicit `mode: 'form' | 'url'` instead.
-     * @param params The parameters for the form elicitation request (legacy signature without mode).
-     * @param options Optional request options.
-     * @returns The result of the elicitation request.
-     */
-    async elicitInput(params: LegacyElicitRequestFormParams, options?: RequestOptions): Promise<ElicitResult>;
-
-    // Implementation (not visible to callers)
-    async elicitInput(
-        params: LegacyElicitRequestFormParams | ElicitRequestFormParams | ElicitRequestURLParams,
-        options?: RequestOptions
-    ): Promise<ElicitResult> {
-        const mode = ('mode' in params ? params.mode : 'form') as 'form' | 'url';
+    async elicitInput(params: ElicitRequestFormParams | ElicitRequestURLParams, options?: RequestOptions): Promise<ElicitResult> {
+        const mode = (params.mode ?? 'form') as 'form' | 'url';
 
         switch (mode) {
             case 'url': {
@@ -372,10 +350,9 @@ export class Server<
                 if (!this._clientCapabilities?.elicitation?.form) {
                     throw new Error('Client does not support form elicitation.');
                 }
+
                 const formParams: ElicitRequestFormParams =
-                    'mode' in params
-                        ? (params as ElicitRequestFormParams)
-                        : ({ ...(params as LegacyElicitRequestFormParams), mode: 'form' } as ElicitRequestFormParams);
+                    params.mode === 'form' ? (params as ElicitRequestFormParams) : { ...(params as ElicitRequestFormParams), mode: 'form' };
 
                 const result = await this.request({ method: 'elicitation/create', params: formParams }, ElicitResultSchema, options);
 

src/types.ts

@@ -1479,8 +1479,10 @@ export const PrimitiveSchemaDefinitionSchema = z.union([EnumSchemaSchema, Boolea
 export const ElicitRequestFormParamsSchema = BaseRequestParamsSchema.extend({
     /**
      * The elicitation mode.
+     *
+     * Optional for backward compatibility. Clients MUST treat missing mode as "form".
      */
-    mode: z.literal('form'),
+    mode: z.literal('form').optional(),
     /**
      * The message to present to the user describing what information is being requested.
      */