Merge branch 'main' into groups/prompt-meta

Author: chughtapan

.github/workflows/main.yml

@@ -58,11 +58,47 @@ jobs:
 
             - run: pnpm test:all
 
+    test-runtimes:
+        runs-on: ubuntu-latest
+        strategy:
+            fail-fast: false
+            matrix:
+                include:
+                    - runtime: bun
+                      version: "1.x"
+                    - runtime: deno
+                      version: v2.x
+        steps:
+            - uses: actions/checkout@v6
+            - name: Install pnpm
+              uses: pnpm/action-setup@v4
+              with:
+                  run_install: false
+            - uses: actions/setup-node@v6
+              with:
+                  node-version: 24
+                  cache: pnpm
+                  cache-dependency-path: pnpm-lock.yaml
+            - name: Set up Bun
+              if: matrix.runtime == 'bun'
+              uses: oven-sh/setup-bun@v2
+              with:
+                  bun-version: ${{ matrix.version }}
+            - name: Set up Deno
+              if: matrix.runtime == 'deno'
+              uses: denoland/setup-deno@v2
+              with:
+                  deno-version: ${{ matrix.version }}
+            - run: pnpm install
+            - run: pnpm build:all
+            - name: Run ${{ matrix.runtime }} integration tests
+              run: pnpm --filter @modelcontextprotocol/test-integration test:integration:${{ matrix.runtime }}
+
     publish:
         runs-on: ubuntu-latest
         if: github.event_name == 'release'
         environment: release
-        needs: [build, test]
+        needs: [build, test, test-runtimes]
 
         permissions:
             contents: read

README.md

@@ -25,7 +25,7 @@
 
 The Model Context Protocol (MCP) allows applications to provide context for LLMs in a standardized way, separating the concerns of providing context from the actual LLM interaction.
 
-This repository contains the TypeScript SDK implementation of the MCP specification and ships:
+This repository contains the TypeScript SDK implementation of the MCP specification. It runs on **Node.js**, **Bun**, and **Deno**, and ships:
 
 - MCP **server** libraries (tools/resources/prompts, Streamable HTTP, stdio, auth helpers)
 - MCP **client** libraries (transports, high-level helpers, OAuth helpers)
@@ -57,12 +57,20 @@ They are intentionally thin adapters: they should not introduce new MCP function
 
 ```bash
 npm install @modelcontextprotocol/server zod
+# or
+bun add @modelcontextprotocol/server zod
+# or
+deno add npm:@modelcontextprotocol/server npm:zod
 ```
 
 ### Client
 
 ```bash
 npm install @modelcontextprotocol/client zod
+# or
+bun add @modelcontextprotocol/client zod
+# or
+deno add npm:@modelcontextprotocol/client npm:zod
 ```
 
 ### Optional middleware packages

docs/client-quickstart.md

@@ -19,10 +19,13 @@ This quickstart assumes you have familiarity with:
 
 Before starting, ensure your system meets these requirements:
 
-- Node.js 20 or higher installed
+- Node.js 20 or higher installed (or **Bun** / **Deno** — the SDK supports all three runtimes)
 - Latest version of `npm` installed
 - An Anthropic API key from the [Anthropic Console](https://console.anthropic.com/settings/keys)
 
+> [!TIP]
+> This tutorial uses Node.js and npm, but you can substitute `bun` or `deno` commands where appropriate. For example, use `bun add` instead of `npm install`, or run the client with `bun run` / `deno run`.
+
 ## Set up your environment
 
 First, let's create and set up our project:
@@ -109,7 +112,7 @@ First, let's set up our imports and create the basic client class in `src/index.
 
 ```ts source="../examples/client-quickstart/src/index.ts#prelude"
 import Anthropic from '@anthropic-ai/sdk';
-import { Client, StdioClientTransport, type CallToolResult } from '@modelcontextprotocol/client';
+import { Client, StdioClientTransport } from '@modelcontextprotocol/client';
 import readline from 'readline/promises';
 
 const ANTHROPIC_MODEL = 'claude-sonnet-4-5';
@@ -201,7 +204,7 @@ Now let's add the core functionality for processing queries and handling tool ca
         const result = await this.mcp.callTool({
           name: toolName,
           arguments: toolArgs,
-        }) as CallToolResult;
+        });
 
         finalText.push(`[Calling tool ${toolName} with args ${JSON.stringify(toolArgs)}]`);
 

docs/server-quickstart.md

@@ -36,6 +36,9 @@ node --version
 npm --version
 ```
 
+> [!TIP]
+> The MCP SDK also works with **Bun** and **Deno**. This tutorial uses Node.js, but you can substitute `bun` or `deno` commands where appropriate. For HTTP-based servers on Bun or Deno, use `WebStandardStreamableHTTPServerTransport` instead of the Node.js-specific transport — see the [server guide](./server.md) for details.
+
 ## Set up your environment
 
 First, let's install Node.js and npm if you haven't already. You can download them from [nodejs.org](https://nodejs.org/).

examples/client-quickstart/src/index.ts

@@ -1,6 +1,6 @@
 //#region prelude
 import Anthropic from '@anthropic-ai/sdk';
-import { Client, StdioClientTransport, type CallToolResult } from '@modelcontextprotocol/client';
+import { Client, StdioClientTransport } from '@modelcontextprotocol/client';
 import readline from 'readline/promises';
 
 const ANTHROPIC_MODEL = 'claude-sonnet-4-5';
@@ -84,7 +84,7 @@ class MCPClient {
         const result = await this.mcp.callTool({
           name: toolName,
           arguments: toolArgs,
-        }) as CallToolResult;
+        });
 
         finalText.push(`[Calling tool ${toolName} with args ${JSON.stringify(toolArgs)}]`);
 

examples/client/src/elicitationUrlExample.ts

@@ -9,8 +9,6 @@ import { createServer } from 'node:http';
 import { createInterface } from 'node:readline';
 
 import type {
-    CallToolRequest,
-    CallToolResult,
     ElicitRequest,
     ElicitRequestURLParams,
     ElicitResult,
@@ -687,16 +685,8 @@ async function callTool(name: string, args: Record<string, unknown>): Promise<vo
     }
 
     try {
-        const request: CallToolRequest = {
-            method: 'tools/call',
-            params: {
-                name,
-                arguments: args
-            }
-        };
-
         console.log(`Calling tool '${name}' with args:`, args);
-        const result = (await client.request(request)) as CallToolResult;
+        const result = await client.callTool({ name, arguments: args });
 
         console.log('Tool result:');
         const resourceLinks: ResourceLink[] = [];

examples/client/src/multipleClientsParallel.ts

@@ -1,4 +1,4 @@
-import type { CallToolRequest, CallToolResult } from '@modelcontextprotocol/client';
+import type { CallToolResult } from '@modelcontextprotocol/client';
 import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
 
 /**
@@ -48,19 +48,14 @@ async function createAndRunClient(config: ClientConfig): Promise<{ id: string; r
 
         // Call the specified tool
         console.log(`[${config.id}] Calling tool: ${config.toolName}`);
-        const toolRequest: CallToolRequest = {
-            method: 'tools/call',
-            params: {
-                name: config.toolName,
-                arguments: {
-                    ...config.toolArguments,
-                    // Add client ID to arguments for identification in notifications
-                    caller: config.id
-                }
+        const result = await client.callTool({
+            name: config.toolName,
+            arguments: {
+                ...config.toolArguments,
+                // Add client ID to arguments for identification in notifications
+                caller: config.id
             }
-        };
-
-        const result = (await client.request(toolRequest)) as CallToolResult;
+        });
         console.log(`[${config.id}] Tool call completed`);
 
         // Keep the connection open for a bit to receive notifications

examples/client/src/parallelToolCallsClient.ts

@@ -1,4 +1,4 @@
-import type { CallToolRequest, CallToolResult, ListToolsRequest } from '@modelcontextprotocol/client';
+import type { CallToolResult, ListToolsRequest } from '@modelcontextprotocol/client';
 import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
 
 /**
@@ -108,58 +108,40 @@ async function listTools(client: Client): Promise<void> {
 async function startParallelNotificationTools(client: Client): Promise<Record<string, CallToolResult>> {
     try {
         // Define multiple tool calls with different configurations
-        const toolCalls: Array<{ caller: string; request: CallToolRequest }> = [
+        const toolCalls = [
             {
                 caller: 'fast-notifier',
-                request: {
-                    method: 'tools/call',
-                    params: {
-                        name: 'start-notification-stream',
-                        arguments: {
-                            interval: 2, // 0.5 second between notifications
-                            count: 10, // Send 10 notifications
-                            caller: 'fast-notifier' // Identify this tool call
-                        }
-                    }
+                args: {
+                    interval: 2, // 0.5 second between notifications
+                    count: 10, // Send 10 notifications
+                    caller: 'fast-notifier' // Identify this tool call
                 }
             },
             {
                 caller: 'slow-notifier',
-                request: {
-                    method: 'tools/call',
-                    params: {
-                        name: 'start-notification-stream',
-                        arguments: {
-                            interval: 5, // 2 seconds between notifications
-                            count: 5, // Send 5 notifications
-                            caller: 'slow-notifier' // Identify this tool call
-                        }
-                    }
+                args: {
+                    interval: 5, // 2 seconds between notifications
+                    count: 5, // Send 5 notifications
+                    caller: 'slow-notifier' // Identify this tool call
                 }
             },
             {
                 caller: 'burst-notifier',
-                request: {
-                    method: 'tools/call',
-                    params: {
-                        name: 'start-notification-stream',
-                        arguments: {
-                            interval: 1, // 0.1 second between notifications
-                            count: 3, // Send just 3 notifications
-                            caller: 'burst-notifier' // Identify this tool call
-                        }
-                    }
+                args: {
+                    interval: 1, // 0.1 second between notifications
+                    count: 3, // Send just 3 notifications
+                    caller: 'burst-notifier' // Identify this tool call
                 }
             }
         ];
 
         console.log(`Starting ${toolCalls.length} notification tools in parallel...`);
 
         // Start all tool calls in parallel
-        const toolPromises = toolCalls.map(({ caller, request }) => {
+        const toolPromises = toolCalls.map(({ caller, args }) => {
             console.log(`Starting tool call for ${caller}...`);
             return client
-                .request(request)
+                .callTool({ name: 'start-notification-stream', arguments: args })
                 .then(result => ({ caller, result }))
                 .catch(error => {
                     console.error(`Error in tool call for ${caller}:`, error);
@@ -173,7 +155,7 @@ async function startParallelNotificationTools(client: Client): Promise<Record<st
         // Organize results by caller
         const resultsByTool: Record<string, CallToolResult> = {};
         for (const { caller, result } of results) {
-            resultsByTool[caller] = result as CallToolResult;
+            resultsByTool[caller] = result;
         }
 
         return resultsByTool;

examples/client/src/simpleOAuthClient.ts

@@ -4,7 +4,7 @@ import { createServer } from 'node:http';
 import { createInterface } from 'node:readline';
 import { URL } from 'node:url';
 
-import type { CallToolRequest, CallToolResult, ListToolsRequest, OAuthClientMetadata } from '@modelcontextprotocol/client';
+import type { CallToolResult, ListToolsRequest, OAuthClientMetadata } from '@modelcontextprotocol/client';
 import { Client, StreamableHTTPClientTransport, UnauthorizedError } from '@modelcontextprotocol/client';
 import open from 'open';
 
@@ -306,15 +306,10 @@ class InteractiveOAuthClient {
         }
 
         try {
-            const request: CallToolRequest = {
-                method: 'tools/call',
-                params: {
-                    name: toolName,
-                    arguments: toolArgs
-                }
-            };
-
-            const result = (await this.client.request(request)) as CallToolResult;
+            const result = await this.client.callTool({
+                name: toolName,
+                arguments: toolArgs
+            });
 
             console.log(`\n🔧 Tool '${toolName}' result:`);
             if (result.content) {

examples/client/src/simpleStreamableHttp.ts

@@ -1,7 +1,6 @@
 import { createInterface } from 'node:readline';
 
 import type {
-    CallToolRequest,
     CallToolResult,
     GetPromptRequest,
     ListPromptsRequest,
@@ -646,16 +645,8 @@ async function callTool(name: string, args: Record<string, unknown>): Promise<vo
     }
 
     try {
-        const request: CallToolRequest = {
-            method: 'tools/call',
-            params: {
-                name,
-                arguments: args
-            }
-        };
-
         console.log(`Calling tool '${name}' with args:`, args);
-        const result = (await client.request(request)) as CallToolResult;
+        const result = await client.callTool({ name, arguments: args });
 
         console.log('Tool result:');
         const resourceLinks: ResourceLink[] = [];
@@ -746,23 +737,18 @@ async function runNotificationsToolWithResumability(interval: number, count: num
         console.log(`Starting notification stream with resumability: interval=${interval}ms, count=${count || 'unlimited'}`);
         console.log(`Using resumption token: ${notificationsToolLastEventId || 'none'}`);
 
-        const request: CallToolRequest = {
-            method: 'tools/call',
-            params: {
-                name: 'start-notification-stream',
-                arguments: { interval, count }
-            }
-        };
-
         const onLastEventIdUpdate = (event: string) => {
             notificationsToolLastEventId = event;
             console.log(`Updated resumption token: ${event}`);
         };
 
-        const result = (await client.request(request, {
-            resumptionToken: notificationsToolLastEventId,
-            onresumptiontoken: onLastEventIdUpdate
-        })) as CallToolResult;
+        const result = await client.callTool(
+            { name: 'start-notification-stream', arguments: { interval, count } },
+            {
+                resumptionToken: notificationsToolLastEventId,
+                onresumptiontoken: onLastEventIdUpdate
+            }
+        );
 
         console.log('Tool result:');
         for (const item of result.content) {