Merge branch 'main' into ochafik/sep-1577-sampling-tools

Author: ochafik

.github/workflows/main.yml

@@ -3,6 +3,7 @@ on:
         branches:
             - main
     pull_request:
+    workflow_dispatch:
     release:
         types: [published]
 

jest.config.js

@@ -1,6 +1,6 @@
 {
     "name": "@modelcontextprotocol/sdk",
-    "version": "1.21.1",
+    "version": "1.22.0",
     "description": "Model Context Protocol implementation for TypeScript",
     "license": "MIT",
     "author": "Anthropic, PBC (https://anthropic.com)",
@@ -71,7 +71,8 @@
         "lint": "eslint src/ && prettier --check .",
         "lint:fix": "eslint src/ --fix && prettier --write .",
         "check": "npm run typecheck && npm run lint",
-        "test": "jest",
+        "test": "vitest run",
+        "test:watch": "vitest",
         "start": "npm run server",
         "server": "tsx watch --clear-screen=false scripts/cli.ts server",
         "client": "tsx scripts/cli.ts client"
@@ -102,27 +103,24 @@
     "devDependencies": {
         "@cfworker/json-schema": "^4.1.1",
         "@eslint/js": "^9.8.0",
-        "@jest-mock/express": "^3.0.0",
         "@types/content-type": "^1.1.8",
         "@types/cors": "^2.8.17",
         "@types/cross-spawn": "^6.0.6",
         "@types/eslint__js": "^8.42.3",
         "@types/eventsource": "^1.1.15",
         "@types/express": "^5.0.0",
-        "@types/jest": "^29.5.12",
         "@types/node": "^22.0.2",
         "@types/supertest": "^6.0.2",
         "@types/ws": "^8.5.12",
         "@typescript/native-preview": "^7.0.0-dev.20251103.1",
         "eslint": "^9.8.0",
         "eslint-config-prettier": "^10.1.8",
-        "jest": "^29.7.0",
         "prettier": "3.6.2",
         "supertest": "^7.0.0",
-        "ts-jest": "^29.2.4",
         "tsx": "^4.16.5",
         "typescript": "^5.5.4",
         "typescript-eslint": "^8.0.0",
+        "vitest": "^4.0.8",
         "ws": "^8.18.0"
     },
     "resolutions": {

package-lock.json

@@ -348,6 +348,7 @@ async function authInternal(
 ): Promise<AuthResult> {
     let resourceMetadata: OAuthProtectedResourceMetadata | undefined;
     let authorizationServerUrl: string | URL | undefined;
+
     try {
         resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl }, fetchFn);
         if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
@@ -359,10 +360,10 @@ async function authInternal(
 
     /**
      * If we don't get a valid authorization server metadata from protected resource metadata,
-     * fallback to the legacy MCP spec's implementation (version 2025-03-26): MCP server acts as the Authorization server.
+     * fallback to the legacy MCP spec's implementation (version 2025-03-26): MCP server base URL acts as the Authorization server.
      */
     if (!authorizationServerUrl) {
-        authorizationServerUrl = serverUrl;
+        authorizationServerUrl = new URL('/', serverUrl);
     }
 
     const resource: URL | undefined = await selectResourceURL(serverUrl, provider, resourceMetadata);

package.json

@@ -2,33 +2,34 @@ import { StdioClientTransport, getDefaultEnvironment } from './stdio.js';
 import spawn from 'cross-spawn';
 import { JSONRPCMessage } from '../types.js';
 import { ChildProcess } from 'node:child_process';
+import { Mock, MockedFunction } from 'vitest';
 
 // mock cross-spawn
-jest.mock('cross-spawn');
-const mockSpawn = spawn as jest.MockedFunction<typeof spawn>;
+vi.mock('cross-spawn');
+const mockSpawn = spawn as unknown as MockedFunction<typeof spawn>;
 
 describe('StdioClientTransport using cross-spawn', () => {
     beforeEach(() => {
         // mock cross-spawn's return value
         mockSpawn.mockImplementation(() => {
             const mockProcess: {
-                on: jest.Mock;
-                stdin?: { on: jest.Mock; write: jest.Mock };
-                stdout?: { on: jest.Mock };
+                on: Mock;
+                stdin?: { on: Mock; write: Mock };
+                stdout?: { on: Mock };
                 stderr?: null;
             } = {
-                on: jest.fn((event: string, callback: () => void) => {
+                on: vi.fn((event: string, callback: () => void) => {
                     if (event === 'spawn') {
                         callback();
                     }
                     return mockProcess;
                 }),
                 stdin: {
-                    on: jest.fn(),
-                    write: jest.fn().mockReturnValue(true)
+                    on: vi.fn(),
+                    write: vi.fn().mockReturnValue(true)
                 },
                 stdout: {
-                    on: jest.fn()
+                    on: vi.fn()
                 },
                 stderr: null
             };
@@ -37,7 +38,7 @@ describe('StdioClientTransport using cross-spawn', () => {
     });
 
     afterEach(() => {
-        jest.clearAllMocks();
+        vi.clearAllMocks();
     });
 
     test('should call cross-spawn correctly', async () => {
@@ -105,30 +106,30 @@ describe('StdioClientTransport using cross-spawn', () => {
 
         // get the mock process object
         const mockProcess: {
-            on: jest.Mock;
+            on: Mock;
             stdin: {
-                on: jest.Mock;
-                write: jest.Mock;
-                once: jest.Mock;
+                on: Mock;
+                write: Mock;
+                once: Mock;
             };
             stdout: {
-                on: jest.Mock;
+                on: Mock;
             };
             stderr: null;
         } = {
-            on: jest.fn((event: string, callback: () => void) => {
+            on: vi.fn((event: string, callback: () => void) => {
                 if (event === 'spawn') {
                     callback();
                 }
                 return mockProcess;
             }),
             stdin: {
-                on: jest.fn(),
-                write: jest.fn().mockReturnValue(true),
-                once: jest.fn()
+                on: vi.fn(),
+                write: vi.fn().mockReturnValue(true),
+                once: vi.fn()
             },
             stdout: {
-                on: jest.fn()
+                on: vi.fn()
             },
             stderr: null
         };

src/client/auth.test.ts

@@ -27,9 +27,9 @@ import { InMemoryTransport } from '../inMemory.js';
  */
 test('should initialize with matching protocol version', async () => {
     const clientTransport: Transport = {
-        start: jest.fn().mockResolvedValue(undefined),
-        close: jest.fn().mockResolvedValue(undefined),
-        send: jest.fn().mockImplementation(message => {
+        start: vi.fn().mockResolvedValue(undefined),
+        close: vi.fn().mockResolvedValue(undefined),
+        send: vi.fn().mockImplementation(message => {
             if (message.method === 'initialize') {
                 clientTransport.onmessage?.({
                     jsonrpc: '2.0',
@@ -86,9 +86,9 @@ test('should initialize with matching protocol version', async () => {
 test('should initialize with supported older protocol version', async () => {
     const OLD_VERSION = SUPPORTED_PROTOCOL_VERSIONS[1];
     const clientTransport: Transport = {
-        start: jest.fn().mockResolvedValue(undefined),
-        close: jest.fn().mockResolvedValue(undefined),
-        send: jest.fn().mockImplementation(message => {
+        start: vi.fn().mockResolvedValue(undefined),
+        close: vi.fn().mockResolvedValue(undefined),
+        send: vi.fn().mockImplementation(message => {
             if (message.method === 'initialize') {
                 clientTransport.onmessage?.({
                     jsonrpc: '2.0',
@@ -136,9 +136,9 @@ test('should initialize with supported older protocol version', async () => {
  */
 test('should reject unsupported protocol version', async () => {
     const clientTransport: Transport = {
-        start: jest.fn().mockResolvedValue(undefined),
-        close: jest.fn().mockResolvedValue(undefined),
-        send: jest.fn().mockImplementation(message => {
+        start: vi.fn().mockResolvedValue(undefined),
+        close: vi.fn().mockResolvedValue(undefined),
+        send: vi.fn().mockImplementation(message => {
             if (message.method === 'initialize') {
                 clientTransport.onmessage?.({
                     jsonrpc: '2.0',

src/client/auth.ts

@@ -36,10 +36,54 @@ import {
     SUPPORTED_PROTOCOL_VERSIONS,
     type SubscribeRequest,
     type Tool,
-    type UnsubscribeRequest
+    type UnsubscribeRequest,
+    ElicitResultSchema,
+    ElicitRequestSchema
 } from '../types.js';
 import { AjvJsonSchemaValidator } from '../validation/ajv-provider.js';
 import type { JsonSchemaType, JsonSchemaValidator, jsonSchemaValidator } from '../validation/types.js';
+import { ZodLiteral, ZodObject, z } from 'zod';
+import type { RequestHandlerExtra } from '../shared/protocol.js';
+
+/**
+ * Elicitation default application helper. Applies defaults to the data based on the schema.
+ *
+ * @param schema - The schema to apply defaults to.
+ * @param data - The data to apply defaults to.
+ */
+function applyElicitationDefaults(schema: JsonSchemaType | undefined, data: unknown): void {
+    if (!schema || data === null || typeof data !== 'object') return;
+
+    // Handle object properties
+    if (schema.type === 'object' && schema.properties && typeof schema.properties === 'object') {
+        const obj = data as Record<string, unknown>;
+        const props = schema.properties as Record<string, JsonSchemaType & { default?: unknown }>;
+        for (const key of Object.keys(props)) {
+            const propSchema = props[key];
+            // If missing or explicitly undefined, apply default if present
+            if (obj[key] === undefined && Object.prototype.hasOwnProperty.call(propSchema, 'default')) {
+                obj[key] = propSchema.default;
+            }
+            // Recurse into existing nested objects/arrays
+            if (obj[key] !== undefined) {
+                applyElicitationDefaults(propSchema, obj[key]);
+            }
+        }
+    }
+
+    if (Array.isArray(schema.anyOf)) {
+        for (const sub of schema.anyOf) {
+            applyElicitationDefaults(sub, data);
+        }
+    }
+
+    // Combine schemas
+    if (Array.isArray(schema.oneOf)) {
+        for (const sub of schema.oneOf) {
+            applyElicitationDefaults(sub, data);
+        }
+    }
+}
 
 export type ClientOptions = ProtocolOptions & {
     /**
@@ -141,6 +185,64 @@ export class Client<
         this._capabilities = mergeCapabilities(this._capabilities, capabilities);
     }
 
+    /**
+     * Override request handler registration to enforce client-side validation for elicitation.
+     */
+    public override setRequestHandler<
+        T extends ZodObject<{
+            method: ZodLiteral<string>;
+        }>
+    >(
+        requestSchema: T,
+        handler: (
+            request: z.infer<T>,
+            extra: RequestHandlerExtra<ClientRequest | RequestT, ClientNotification | NotificationT>
+        ) => ClientResult | ResultT | Promise<ClientResult | ResultT>
+    ): void {
+        const method = requestSchema.shape.method.value;
+        if (method === 'elicitation/create') {
+            const wrappedHandler = async (
+                request: z.infer<T>,
+                extra: RequestHandlerExtra<ClientRequest | RequestT, ClientNotification | NotificationT>
+            ): Promise<ClientResult | ResultT> => {
+                const validatedRequest = ElicitRequestSchema.safeParse(request);
+                if (!validatedRequest.success) {
+                    throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation request: ${validatedRequest.error.message}`);
+                }
+
+                const result = await Promise.resolve(handler(request, extra));
+
+                const validationResult = ElicitResultSchema.safeParse(result);
+                if (!validationResult.success) {
+                    throw new McpError(ErrorCode.InvalidParams, `Invalid elicitation result: ${validationResult.error.message}`);
+                }
+
+                const validatedResult = validationResult.data;
+
+                if (
+                    this._capabilities.elicitation?.applyDefaults &&
+                    validatedResult.action === 'accept' &&
+                    validatedResult.content &&
+                    validatedRequest.data.params.requestedSchema
+                ) {
+                    try {
+                        applyElicitationDefaults(validatedRequest.data.params.requestedSchema, validatedResult.content);
+                    } catch {
+                        // gracefully ignore errors in default application
+                    }
+                }
+
+                return validatedResult;
+            };
+
+            // Install the wrapped handler
+            return super.setRequestHandler(requestSchema, wrappedHandler as unknown as typeof handler);
+        }
+
+        // Non-elicitation handlers use default behavior
+        return super.setRequestHandler(requestSchema, handler);
+    }
+
     protected assertCapability(capability: keyof ServerCapabilities, method: string): void {
         if (!this._serverCapabilities?.[capability]) {
             throw new Error(`Server does not support ${capability} (required for ${method})`);