New tests: Backwards compat for elicitation client capabilities obj

Author: nbarbettini

src/client/index.test.ts

@@ -596,6 +596,81 @@ test('should allow setRequestHandler for declared elicitation capability', () =>
     }).toThrow('Client does not support sampling capability');
 });
 
+test('should accept form-mode elicitation request when client advertises empty elicitation object (back-compat)', async () => {
+    const server = new Server(
+        {
+            name: 'test server',
+            version: '1.0'
+        },
+        {
+            capabilities: {
+                prompts: {},
+                resources: {},
+                tools: {},
+                logging: {}
+            }
+        }
+    );
+
+    const client = new Client(
+        {
+            name: 'test client',
+            version: '1.0'
+        },
+        {
+            capabilities: {
+                elicitation: {}
+            }
+        }
+    );
+
+    // Set up client handler for form-mode elicitation
+    client.setRequestHandler(ElicitRequestSchema, request => {
+        expect(request.params.mode).toBe('form');
+        return {
+            action: 'accept',
+            content: {
+                username: 'test-user',
+                confirmed: true
+            }
+        };
+    });
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
+
+    // Server should be able to send form-mode elicitation request
+    // This works because getSupportedElicitationModes defaults to form mode
+    // when neither form nor url are explicitly declared
+    const result = await server.elicitFormInput({
+        message: 'Please provide your username',
+        requestedSchema: {
+            type: 'object',
+            properties: {
+                username: {
+                    type: 'string',
+                    title: 'Username',
+                    description: 'Your username'
+                },
+                confirmed: {
+                    type: 'boolean',
+                    title: 'Confirm',
+                    description: 'Please confirm',
+                    default: false
+                }
+            },
+            required: ['username']
+        }
+    });
+
+    expect(result.action).toBe('accept');
+    expect(result.content).toEqual({
+        username: 'test-user',
+        confirmed: true
+    });
+});
+
 /***
  * Test: Type Checking
  * Test that custom request/notification/result schemas can be used with the Client class.

src/server/index.test.ts

@@ -304,7 +304,8 @@ test('should respect client elicitation capabilities', async () => {
 
     await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
 
-    expect(server.getClientCapabilities()).toEqual({ elicitation: {} });
+    // After schema parsing, empty elicitation object should have form capability injected
+    expect(server.getClientCapabilities()).toEqual({ elicitation: { form: {} } });
 
     // This should work because elicitation is supported by the client
     await expect(
@@ -345,6 +346,91 @@ test('should respect client elicitation capabilities', async () => {
     ).rejects.toThrow(/^Client does not support/);
 });
 
+test('should apply back-compat form capability injection when client sends empty elicitation object', async () => {
+    const server = new Server(
+        {
+            name: 'test server',
+            version: '1.0'
+        },
+        {
+            capabilities: {
+                prompts: {},
+                resources: {},
+                tools: {},
+                logging: {}
+            }
+        }
+    );
+
+    const client = new Client(
+        {
+            name: 'test client',
+            version: '1.0'
+        },
+        {
+            capabilities: {
+                elicitation: {}
+            }
+        }
+    );
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
+
+    // Verify that the schema preprocessing injected form capability
+    const clientCapabilities = server.getClientCapabilities();
+    expect(clientCapabilities).toBeDefined();
+    expect(clientCapabilities?.elicitation).toBeDefined();
+    expect(clientCapabilities?.elicitation?.form).toBeDefined();
+    expect(clientCapabilities?.elicitation?.form).toEqual({});
+    expect(clientCapabilities?.elicitation?.url).toBeUndefined();
+});
+
+test('should apply back-compat form capability injection when client sends elicitation with only applyDefaults', async () => {
+    const server = new Server(
+        {
+            name: 'test server',
+            version: '1.0'
+        },
+        {
+            capabilities: {
+                prompts: {},
+                resources: {},
+                tools: {},
+                logging: {}
+            }
+        }
+    );
+
+    const client = new Client(
+        {
+            name: 'test client',
+            version: '1.0'
+        },
+        {
+            capabilities: {
+                elicitation: {
+                    applyDefaults: true
+                }
+            }
+        }
+    );
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+    await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
+
+    // Verify that the schema preprocessing injected form capability while preserving applyDefaults
+    const clientCapabilities = server.getClientCapabilities();
+    expect(clientCapabilities).toBeDefined();
+    expect(clientCapabilities?.elicitation).toBeDefined();
+    expect(clientCapabilities?.elicitation?.form).toBeDefined();
+    expect(clientCapabilities?.elicitation?.form).toEqual({});
+    expect(clientCapabilities?.elicitation?.applyDefaults).toBe(true);
+    expect(clientCapabilities?.elicitation?.url).toBeUndefined();
+});
+
 test('should validate elicitation response against requested schema', async () => {
     const server = new Server(
         {

src/types.capabilities.test.ts

@@ -0,0 +1,102 @@
+import { ClientCapabilitiesSchema, InitializeRequestParamsSchema } from './types.js';
+
+describe('ClientCapabilitiesSchema backwards compatibility', () => {
+    describe('ElicitationCapabilitySchema preprocessing', () => {
+        it('should inject form capability when elicitation is an empty object', () => {
+            const capabilities = {
+                elicitation: {}
+            };
+
+            const result = ClientCapabilitiesSchema.parse(capabilities);
+            expect(result.elicitation).toBeDefined();
+            expect(result.elicitation?.form).toBeDefined();
+            expect(result.elicitation?.form).toEqual({});
+            expect(result.elicitation?.url).toBeUndefined();
+        });
+
+        it('should inject form capability when elicitation has only applyDefaults', () => {
+            const capabilities = {
+                elicitation: {
+                    applyDefaults: true
+                }
+            };
+
+            const result = ClientCapabilitiesSchema.parse(capabilities);
+            expect(result.elicitation).toBeDefined();
+            expect(result.elicitation?.form).toBeDefined();
+            expect(result.elicitation?.form).toEqual({});
+            expect(result.elicitation?.applyDefaults).toBe(true);
+            expect(result.elicitation?.url).toBeUndefined();
+        });
+
+        it('should not inject form capability when form is explicitly declared', () => {
+            const capabilities = {
+                elicitation: {
+                    form: {}
+                }
+            };
+
+            const result = ClientCapabilitiesSchema.parse(capabilities);
+            expect(result.elicitation).toBeDefined();
+            expect(result.elicitation?.form).toBeDefined();
+            expect(result.elicitation?.form).toEqual({});
+            expect(result.elicitation?.url).toBeUndefined();
+        });
+
+        it('should not inject form capability when url is explicitly declared', () => {
+            const capabilities = {
+                elicitation: {
+                    url: {}
+                }
+            };
+
+            const result = ClientCapabilitiesSchema.parse(capabilities);
+            expect(result.elicitation).toBeDefined();
+            expect(result.elicitation?.url).toBeDefined();
+            expect(result.elicitation?.url).toEqual({});
+            expect(result.elicitation?.form).toBeUndefined();
+        });
+
+        it('should not inject form capability when both form and url are explicitly declared', () => {
+            const capabilities = {
+                elicitation: {
+                    form: {},
+                    url: {}
+                }
+            };
+
+            const result = ClientCapabilitiesSchema.parse(capabilities);
+            expect(result.elicitation).toBeDefined();
+            expect(result.elicitation?.form).toBeDefined();
+            expect(result.elicitation?.url).toBeDefined();
+            expect(result.elicitation?.form).toEqual({});
+            expect(result.elicitation?.url).toEqual({});
+        });
+
+        it('should not inject form capability when elicitation is undefined', () => {
+            const capabilities = {};
+
+            const result = ClientCapabilitiesSchema.parse(capabilities);
+            // When elicitation is not provided, it should remain undefined
+            expect(result.elicitation).toBeUndefined();
+        });
+
+        it('should work within InitializeRequestParamsSchema context', () => {
+            const initializeParams = {
+                protocolVersion: '2025-11-25',
+                capabilities: {
+                    elicitation: {}
+                },
+                clientInfo: {
+                    name: 'test client',
+                    version: '1.0'
+                }
+            };
+
+            const result = InitializeRequestParamsSchema.parse(initializeParams);
+            expect(result.capabilities.elicitation).toBeDefined();
+            expect(result.capabilities.elicitation?.form).toBeDefined();
+            expect(result.capabilities.elicitation?.form).toEqual({});
+        });
+    });
+});