tmcp 1.15.5 → 1.16.1

package/README.md

@@ -57,6 +57,10 @@ const server = new McpServer(
 	},
 );
 
+// While the adapter is optional (you can opt out by explicitly passing `adapter: undefined`)
+// without an adapter the server cannot accept inputs, produce structured outputs, or request
+// elicitations at all only do this for very simple servers.
+
 // Define a tool with type-safe schema
 server.tool(
 	{
@@ -107,7 +111,10 @@ new McpServer(serverInfo, options);
 ```
 
 - `serverInfo`: Server metadata (name, version, description)
-- `options`: Configuration object with adapter and capabilities
+- `options`: Configuration object with optional adapter (for schema conversion) and capabilities
+
+> [!IMPORTANT]
+> While the adapter is optional (you can opt out by explicitly passing `adapter: undefined`) without an adapter the server cannot accept inputs, produce structured outputs, or request elicitations at all only do this for very simple servers.
 
 #### Methods
 
@@ -129,6 +136,8 @@ server.tool(
 );
 ```
 
+`sessionInfo` contains the latest `clientCapabilities`, `clientInfo`, and `logLevel` reported by the connected client. Built-in transports populate it automatically, so every handler can branch on client features without additional bookkeeping.
+
 ##### `prompt(definition, handler)`
 
 Register a prompt template with optional schema validation.
@@ -232,30 +241,34 @@ server.tool(
 
 ##### `ctx`
 
-Access the current request context, including session ID, auth info, and custom context.
+Access the current request context, including session ID, auth info, client metadata, and custom context.
 
 ```javascript
 server.tool(
-    {
-        name: 'context-aware-tool',
-        description: 'Tool that uses request context',
-    },
-    async () => {
-        const { sessionId, auth, custom } = server.ctx;
-        
-        if (!custom?.userId) {
-            throw new Error('User authentication required');
-        }
-        
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Hello user ${custom.userId} in session ${sessionId}`,
-                },
-            ],
-        };
-    },
+	{
+		name: 'context-aware-tool',
+		description: 'Tool that uses request context',
+	},
+	async () => {
+		const { sessionId, auth, sessionInfo, custom } = server.ctx;
+
+		if (!custom?.userId) {
+			throw new Error('User authentication required');
+		}
+
+		if (sessionInfo?.clientInfo) {
+			console.log(`Serving ${sessionInfo.clientInfo.name}`);
+		}
+
+		return {
+			content: [
+				{
+					type: 'text',
+					text: `Hello user ${custom.userId} in session ${sessionId}`,
+				},
+			],
+		};
+	},
 );
 ```
 
@@ -269,9 +282,14 @@ const response = server.receive(jsonRpcRequest);
 
 // With custom context (typically used by transports)
 const response = server.receive(jsonRpcRequest, {
-    sessionId: 'session-123',
-    auth: authInfo,
-    custom: customContextData,
+	sessionId: 'session-123',
+	auth: authInfo,
+	sessionInfo: {
+		clientCapabilities,
+		clientInfo,
+		logLevel,
+	},
+	custom: customContextData,
 });
 ```
 
@@ -309,7 +327,7 @@ console.log(server.roots); // Access current roots
 
 ##### `changed(type, id)`
 
-Send notifications for subscriptions.
+Send notifications for subscriptions. When you call `changed('resource', uri)` the server now emits a broadcast notification, and the built-in transports look up which sessions subscribed to that URI before delivering it.
 
 ```javascript
 server.changed('resource', 'file://path/to/resource');
@@ -380,13 +398,25 @@ server.log('error', 'Failed to connect to database', 'database-logger');
 
 Listen to server events.
 
+Available events:
+
+- `initialize` – fired after the client handshake with the parsed initialize payload
+- `send` – emitted for point-to-point responses/notifications destined for the active session
+- `broadcast` – emitted for fan-out notifications (for example `notifications/resources/updated`)
+- `subscription` – raised when the client subscribes to a resource URI
+- `loglevelchange` – fired when the client requests a different log level
+
 ```javascript
-server.on('initialize', (data) => {
-	console.log('Client initialized:', data);
+server.on('initialize', ({ clientInfo }) => {
+	console.log('Client initialized:', clientInfo?.name);
 });
 
-server.on('send', ({ request, context }) => {
-	console.log('Sending request:', request);
+server.on('send', ({ request }) => {
+	console.log('Sending message:', request);
+});
+
+server.on('broadcast', ({ request }) => {
+	console.log('Broadcasting:', request.method);
 });
 ```
 
@@ -516,9 +546,15 @@ server.on('initialize', (data) => {
 	console.log('Client capabilities:', data.capabilities);
 });
 
-server.on('send', ({ request, context }) => {
+server.on('send', ({ request }) => {
 	console.log('Outgoing request:', request.method);
 });
+
+server.on('broadcast', ({ request }) => {
+	if (request.method === 'notifications/resources/updated') {
+		console.log('Resource updated:', request.params.uri);
+	}
+});
 ```
 
 ### Resource Subscriptions
@@ -923,7 +959,7 @@ server.prompt(
 );
 ```
 
-or enable a something based on client capabilities or info
+or enable something based on client capabilities or info
 
 ```javascript
 server.prompt(
@@ -932,8 +968,8 @@ server.prompt(
 		description: 'Claude Code prompt',
 		enabled: () => {
 			// Access session information
-			const clientInfo = server.currentClientInfo();
-			return clientInfo.name === 'Claude Code';
+			const clientInfo = server.ctx.sessionInfo?.clientInfo;
+			return clientInfo?.name === 'Claude Code';
 		},
 	},
 	async (input) => {
@@ -958,8 +994,9 @@ server.prompt(
 		description: 'fetch the repositories of the user',
 		enabled: () => {
 			// Access session information
-			const clientInfo = server.currentClientCapabilities();
-			return clientInfo.elicitation != null;
+			const clientCapabilities =
+				server.ctx.sessionInfo?.clientCapabilities;
+			return clientCapabilities?.elicitation != null;
 		},
 	},
 	async (input) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tmcp",
-  "version": "1.15.5",
+  "version": "1.16.1",
   "description": "The main tmcp library",
   "main": "src/index.js",
   "type": "module",

package/src/index.js

@@ -4,7 +4,7 @@
  * @import SqidsType from "sqids";
  * @import { JSONRPCRequest, JSONRPCParams } from "json-rpc-2.0";
  * @import { ExtractURITemplateVariables } from "./internal/uri-template.js";
- * @import { CallToolResult as CallToolResultType, ReadResourceResult as ReadResourceResultType, GetPromptResult as GetPromptResultType, ServerInfo as ServerInfoType, ClientCapabilities as ClientCapabilitiesType, JSONRPCRequest as JSONRPCRequestType, JSONRPCResponse, CreateMessageRequestParams as CreateMessageRequestParamsType, CreateMessageResult as CreateMessageResultType, Resource as ResourceType, LoggingLevel as LoggingLevelType, ToolAnnotations, ClientInfo as ClientInfoType, ElicitResult as ElicitResultType, Icons as IconsType } from "./validation/index.js";
+ * @import { CallToolResult as CallToolResultType, ReadResourceResult as ReadResourceResultType, GetPromptResult as GetPromptResultType, ServerInfo as ServerInfoType, ClientCapabilities as ClientCapabilitiesType, JSONRPCRequest as JSONRPCRequestType, JSONRPCResponse, CreateMessageRequestParams as CreateMessageRequestParamsType, CreateMessageResult as CreateMessageResultType, Resource as ResourceType, LoggingLevel as LoggingLevelType, ToolAnnotations, ClientInfo as ClientInfoType, ElicitResult as ElicitResultType, Icons as IconsType, JSONRPCMessage } from "./validation/index.js";
  * @import { Tool, Completion, Prompt, StoredResource, ServerOptions, SubscriptionsKeys, ChangedArgs, McpEvents } from "./internal/internal.js";
  */
 import { JSONRPCClient, JSONRPCServer } from 'json-rpc-2.0';
@@ -49,6 +49,7 @@ import { should_version_negotiation_fail } from './validation/version.js';
  * @template {Record<string, unknown> | undefined} [TCustom=undefined]
  * @typedef {Object} Context
  * @property {string} [sessionId]
+ * @property {{ clientCapabilities?: ClientCapabilitiesType, clientInfo?: ClientInfoType, logLevel?: LoggingLevel }} [sessionInfo]
  * @property {AuthInfo} [auth]
  * @property {TCustom} [custom]
  */
@@ -57,6 +58,10 @@ import { should_version_negotiation_fail } from './validation/version.js';
  * @typedef {IconsType} Icons
  */
 
+/**
+ * @typedef {Record<SubscriptionsKeys, string[]>} Subscriptions
+ */
+
 /**
  * @template {Record<string, unknown> | undefined} TStructuredContent
  * @typedef {CallToolResultType<TStructuredContent>} CallToolResult
@@ -149,7 +154,7 @@ async function safe_enabled(enabled) {
 export class McpServer {
 	#server = new JSONRPCServer();
 	/**
-	 * @type {JSONRPCClient<Record<string, any> | undefined> | undefined}
+	 * @type {JSONRPCClient<"broadcast" | "standalone"> | undefined}
 	 */
 	#client;
 	#options;
@@ -180,36 +185,11 @@ export class McpServer {
 
 	#event_target = new EventTarget();
 
-	/**
-	 * @type {Record<SubscriptionsKeys, Map<string, Set<string | undefined>>>}
-	 */
-	#subscriptions = {
-		/**
-		 * @type {Map<string, Set<string>>}
-		 */
-		resource: new Map(),
-	};
-
 	/**
 	 * @type {AsyncLocalStorage<Context<CustomContext> & { progress_token?: string }>}
 	 */
 	#ctx_storage = new AsyncLocalStorage();
 
-	/**
-	 * @type {Map<string|undefined, ClientCapabilities>}
-	 */
-	#client_capabilities_map = new Map();
-
-	/**
-	 * @type {Map<string|undefined, ClientInfo>}
-	 */
-	#client_info_map = new Map();
-
-	/**
-	 * @type {Map<string|undefined, LoggingLevel>}
-	 */
-	#session_log_levels = new Map();
-
 	/**
 	 * @param {ServerInfo} server_info
 	 * @param {ServerOptions<StandardSchema>} options
@@ -224,8 +204,6 @@ export class McpServer {
 					initialize_request,
 				);
 
-				const session_id = this.#session_id;
-
 				// Validate protocol version format
 				if (
 					should_version_negotiation_fail(
@@ -245,18 +223,6 @@ export class McpServer {
 					validated_initialize.protocolVersion,
 				);
 
-				// Store client capabilities
-				this.#client_capabilities_map.set(
-					session_id,
-					validated_initialize.capabilities,
-				);
-
-				// Store client info
-				this.#client_info_map.set(
-					session_id,
-					validated_initialize.clientInfo,
-				);
-
 				// Dispatch initialization event
 				this.#event_target.dispatchEvent(
 					new CustomEvent('initialize', {
@@ -324,10 +290,6 @@ export class McpServer {
 		);
 	}
 
-	get #session_id() {
-		return this.#ctx_storage.getStore()?.sessionId;
-	}
-
 	get #progress_token() {
 		return this.#ctx_storage.getStore()?.progress_token;
 	}
@@ -343,18 +305,20 @@ export class McpServer {
 	}
 
 	get #client_capabilities() {
-		return this.#client_capabilities_map.get(this.#session_id);
+		return this.#ctx_storage.getStore()?.sessionInfo?.clientCapabilities;
 	}
 
 	/**
 	 * Get the client information (name, version, etc.) of the client that initiated the current request...useful if you want to do something different based on the client.
+	 * @deprecated Use `server.ctx.sessionInfo.clientInfo` instead.
 	 */
 	currentClientInfo() {
-		return this.#client_info_map.get(this.#session_id);
+		return this.#ctx_storage.getStore()?.sessionInfo?.clientInfo;
 	}
 
 	/**
 	 * Get the client capabilities of the client that initiated the current request, you can use this to verify the client support something before invoking the respective method.
+	 * @deprecated Use `server.ctx.sessionInfo.clientCapabilities` instead.
 	 */
 	currentClientCapabilities() {
 		return this.#client_capabilities;
@@ -362,10 +326,18 @@ export class McpServer {
 
 	#lazyily_create_client() {
 		if (!this.#client) {
-			this.#client = new JSONRPCClient((payload, context = {}) => {
+			this.#client = new JSONRPCClient((payload, kind) => {
+				if (kind === 'broadcast') {
+					this.#event_target.dispatchEvent(
+						new CustomEvent('broadcast', {
+							detail: { request: payload },
+						}),
+					);
+					return;
+				}
 				this.#event_target.dispatchEvent(
 					new CustomEvent('send', {
-						detail: { request: payload, context },
+						detail: { request: payload },
 					}),
 				);
 			});
@@ -379,7 +351,7 @@ export class McpServer {
 	 * @param {AddEventListenerOptions} [options]
 	 */
 	on(event, callback, options) {
-		if (event === 'send') {
+		if (event === 'send' || event === 'broadcast') {
 			this.#lazyily_create_client();
 		}
 
@@ -400,10 +372,10 @@ export class McpServer {
 	/**
 	 * @param {string} method
 	 * @param {JSONRPCParams} [params]
-	 * @param {Record<string, any>} [extra]
+	 * @param {"broadcast" | "standalone"} [kind]
 	 */
-	#notify(method, params, extra) {
-		this.#client?.notify(method, params, extra);
+	#notify(method, params, kind = 'standalone') {
+		this.#client?.notify(method, params, kind);
 	}
 
 	/**
@@ -425,12 +397,14 @@ export class McpServer {
 							title: tool.title || tool.description,
 							description: tool.description,
 							icons: tool.icons,
-							inputSchema: tool.schema
-								? await this.#options.adapter.toJsonSchema(
-										tool.schema,
-									)
-								: { type: 'object', properties: {} },
-							...(tool.outputSchema
+							_meta: tool._meta,
+							inputSchema:
+								tool.schema && this.#options.adapter
+									? await this.#options.adapter.toJsonSchema(
+											tool.schema,
+										)
+									: { type: 'object', properties: {} },
+							...(tool.outputSchema && this.#options.adapter
 								? {
 										outputSchema:
 											await this.#options.adapter.toJsonSchema(
@@ -542,16 +516,17 @@ export class McpServer {
 							(await safe_enabled(prompt.enabled)) === false
 						)
 							return null;
-						const arguments_schema = prompt.schema
-							? await this.#options.adapter.toJsonSchema(
-									prompt.schema,
-								)
-							: {
-									type: 'object',
-									properties:
-										/** @type {Record<string, {description: string}>} */ ({}),
-									required: [],
-								};
+						const arguments_schema =
+							prompt.schema && this.#options.adapter
+								? await this.#options.adapter.toJsonSchema(
+										prompt.schema,
+									)
+								: {
+										type: 'object',
+										properties:
+											/** @type {Record<string, {description: string}>} */ ({}),
+										required: [],
+									};
 						const keys = Object.keys(
 							arguments_schema.properties ?? {},
 						);
@@ -637,12 +612,11 @@ export class McpServer {
 
 		if (this.#options.capabilities?.resources?.subscribe) {
 			this.#server.addMethod('resources/subscribe', async ({ uri }) => {
-				let subscriptions = this.#subscriptions.resource.get(uri);
-				if (!subscriptions) {
-					subscriptions = new Set();
-					this.#subscriptions.resource.set(uri, subscriptions);
-				}
-				subscriptions.add(this.#session_id);
+				this.#event_target.dispatchEvent(
+					new CustomEvent('subscription', {
+						detail: { uri },
+					}),
+				);
 				return {};
 			});
 		}
@@ -786,9 +760,7 @@ export class McpServer {
 			const response = await this.#client?.request(
 				'roots/list',
 				undefined,
-				{
-					sessions: [this.#session_id],
-				},
+				'standalone',
 			);
 			this.roots = response?.roots || [];
 		} catch {
@@ -819,26 +791,34 @@ export class McpServer {
 		if (!this.#options.capabilities?.logging) return;
 
 		this.#server.addMethod('logging/setLevel', ({ level }) => {
-			this.#session_log_levels.set(this.#session_id, level);
+			this.#event_target.dispatchEvent(
+				new CustomEvent('loglevelchange', {
+					detail: { level },
+				}),
+			);
 			return {};
 		});
 	}
 
 	#notify_tools_list_changed() {
 		if (this.#options.capabilities?.tools?.listChanged) {
-			this.#notify('notifications/tools/list_changed', {});
+			this.#notify('notifications/tools/list_changed', {}, 'broadcast');
 		}
 	}
 
 	#notify_prompts_list_changed() {
 		if (this.#options.capabilities?.prompts?.listChanged) {
-			this.#notify('notifications/prompts/list_changed', {});
+			this.#notify('notifications/prompts/list_changed', {}, 'broadcast');
 		}
 	}
 
 	#notify_resources_list_changed() {
 		if (this.#options.capabilities?.resources?.listChanged) {
-			this.#notify('notifications/resources/list_changed', {});
+			this.#notify(
+				'notifications/resources/list_changed',
+				{},
+				'broadcast',
+			);
 		}
 	}
 
@@ -849,7 +829,7 @@ export class McpServer {
 	 * Tools will be invoked by the LLM when it thinks it needs to use them, you can use the annotations to provide additional information about the tool, like what it does, how to use it, etc.
 	 * @template {StandardSchema | undefined} [TSchema=undefined]
 	 * @template {StandardSchema | undefined} [TOutputSchema=undefined]
-	 * @param {{ name: string; description: string; title?: string; enabled?: ()=>boolean | Promise<boolean>; schema?: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema> extends Record<string, unknown> ? TSchema : never; outputSchema?: StandardSchemaV1.InferOutput<TOutputSchema extends undefined ? never : TOutputSchema> extends Record<string, unknown> ? TOutputSchema : never; annotations?: ToolAnnotations } & Icons} options
+	 * @param {{ name: string; _meta?: Record<string, any>; description: string; title?: string; enabled?: ()=>boolean | Promise<boolean>; schema?: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema> extends Record<string, unknown> ? TSchema : never; outputSchema?: StandardSchemaV1.InferOutput<TOutputSchema extends undefined ? never : TOutputSchema> extends Record<string, unknown> ? TOutputSchema : never; annotations?: ToolAnnotations } & Icons} options
 	 * @param {TSchema extends undefined ? (()=>Promise<CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>> | CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>) : ((input: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>) => Promise<CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>> | CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>)} execute
 	 */
 	tool(
@@ -862,6 +842,7 @@ export class McpServer {
 			annotations,
 			enabled,
 			icons,
+			_meta,
 		},
 		execute,
 	) {
@@ -875,6 +856,7 @@ export class McpServer {
 			execute,
 			annotations,
 			icons,
+			_meta,
 		});
 	}
 	/**
@@ -976,7 +958,7 @@ export class McpServer {
 	/**
 	 * The main function that receive a JSONRpc message and either dispatch a `send` event or process the request.
 	 *
-	 * @param {JSONRPCResponse | JSONRPCRequest} message
+	 * @param {JSONRPCMessage} message
 	 * @param {Context<CustomContext>} [ctx]
 	 * @returns {ReturnType<JSONRPCServer['receive']> | ReturnType<JSONRPCClient['receive'] | undefined>}
 	 */
@@ -989,18 +971,6 @@ export class McpServer {
 
 		// Check if it's a request or response
 		if (validated_message.success) {
-			// we want to set a default log level for each session
-			// so that if the user calls `log` it can send a notification
-			// to each client that didn't explicitly set a log level too
-			if (
-				!!this.#options.capabilities?.logging &&
-				!this.#session_log_levels.has(ctx?.sessionId)
-			) {
-				this.#session_log_levels.set(
-					ctx?.sessionId,
-					this.#options.logging?.default ?? 'info',
-				);
-			}
 			const progress_token = /** @type {string | undefined} */ (
 				validated_message.output.params?._meta?.progressToken
 			);
@@ -1035,28 +1005,16 @@ export class McpServer {
 		} else if (what === 'resources') {
 			this.#notify_resources_list_changed();
 		} else {
-			if (
-				this.#subscriptions[
-					/** @type {SubscriptionsKeys} */ (what)
-				].has(id)
-			) {
-				const resource = this.#resources.get(id);
-				if (!resource) return;
-				const sessions =
-					this.#subscriptions[
-						/** @type {SubscriptionsKeys} */ (what)
-					].get(id);
-				this.#notify(
-					`notifications/resources/updated`,
-					{
-						uri: id,
-						title: resource.name,
-					},
-					{
-						sessions: sessions ? [...sessions] : undefined,
-					},
-				);
-			}
+			const resource = this.#resources.get(id);
+			if (!resource) return;
+			this.#notify(
+				`notifications/resources/updated`,
+				{
+					uri: id,
+					title: resource.name,
+				},
+				'broadcast',
+			);
 		}
 	}
 
@@ -1089,11 +1047,9 @@ export class McpServer {
 			{
 				message,
 				requestedSchema:
-					await this.#options.adapter.toJsonSchema(schema),
-			},
-			{
-				sessions: [this.#session_id],
+					await this.#options.adapter?.toJsonSchema(schema),
 			},
+			'standalone',
 		);
 		const elicit_result = v.parse(ElicitResultSchema, result);
 		let validated_result = schema['~standard'].validate(
@@ -1131,9 +1087,7 @@ export class McpServer {
 		const response = await this.#client?.request(
 			'sampling/createMessage',
 			validated_request,
-			{
-				sessions: [this.#session_id],
-			},
+			'standalone',
 		);
 
 		// Validate and return the response
@@ -1149,18 +1103,12 @@ export class McpServer {
 	 */
 	progress(progress, total = 1, message = undefined) {
 		if (this.#progress_token != null) {
-			this.#notify(
-				'notifications/progress',
-				{
-					progress,
-					total,
-					message,
-					progressToken: this.#progress_token,
-				},
-				{
-					sessions: this.#session_id ? [this.#session_id] : undefined,
-				},
-			);
+			this.#notify('notifications/progress', {
+				progress,
+				total,
+				message,
+				progressToken: this.#progress_token,
+			});
 		}
 	}
 
@@ -1179,33 +1127,21 @@ export class McpServer {
 			);
 		}
 
-		const sessions = [];
-
-		const current_session_level = this.#session_log_levels.get(
-			this.#session_id,
-		);
+		const current_session_level =
+			this.#ctx_storage.getStore()?.sessionInfo?.logLevel ??
+			this.#options.logging?.default ??
+			'info';
 
 		if (
 			current_session_level &&
 			this.#should_log(level, current_session_level)
 		) {
-			sessions.push(this.#session_id);
-		}
-
-		if (sessions.length === 0) return;
-
-		// Send the log notification to the client
-		this.#notify(
-			'notifications/message',
-			{
+			this.#notify('notifications/message', {
 				level,
 				data,
 				logger,
-			},
-			{
-				sessions,
-			},
-		);
+			});
+		}
 	}
 
 	/**

package/src/internal/internal.d.ts

@@ -20,6 +20,7 @@ export type Tool<TSchema extends StandardSchemaV1 = StandardSchemaV1<any>, TOutp
 	outputSchema?: TOutputSchema;
 	title?: string;
 	annotations?: ToolAnnotations;
+	_meta?: Record<string, unknown>;
 	enabled?: () => boolean | Promise<boolean>;
 	execute: (
 		input?: StandardSchemaV1.InferInput<TSchema>,
@@ -70,7 +71,7 @@ export type StoredResource =
 export type ServerOptions<TSchema extends StandardSchemaV1 | undefined> = {
 	capabilities?: ServerCapabilities;
 	instructions?: string;
-	adapter: JsonSchemaAdapter<TSchema>;
+	adapter: JsonSchemaAdapter<TSchema> | undefined;
 	pagination?: {
 		resources?: { size?: number };
 		prompts?: { size?: number };
@@ -96,9 +97,11 @@ export type SubscriptionsKeys = SubscriptionsKeysObj["with_args"];
 export type McpEvents = {
 	send: (message: {
 		request: JSONRPCRequest;
-		context: {
-			sessions?: string[] | undefined;
-		};
+	}) => void;
+	broadcast: (message: {
+		request: JSONRPCRequest;
 	}) => void;
 	initialize: (initialize_request: InitializeRequestParams) => void;
+	subscription: (subscriptions_request: { uri: string }) => void;
+	loglevelchange: (change: { level: LoggingLevel }) => void;
 };

package/src/types/index.d.ts

@@ -1,6 +1,6 @@
 declare module 'tmcp' {
 	import type { StandardSchemaV1 } from '@standard-schema/spec';
-	import type { JSONRPCRequest, JSONRPCServer, JSONRPCClient } from 'json-rpc-2.0';
+	import type { JSONRPCServer, JSONRPCClient, JSONRPCRequest } from 'json-rpc-2.0';
 	import type { JSONSchema7 } from 'json-schema';
 	import * as v from 'valibot';
 	export class McpServer<StandardSchema extends StandardSchemaV1 | undefined = undefined, CustomContext extends Record<string, unknown> | undefined = undefined> {
@@ -23,6 +23,7 @@ declare module 'tmcp' {
 		get ctx(): Context<CustomContext>;
 		/**
 		 * Get the client information (name, version, etc.) of the client that initiated the current request...useful if you want to do something different based on the client.
+		 * @deprecated Use `server.ctx.sessionInfo.clientInfo` instead.
 		 */
 		currentClientInfo(): {
 			icons?: {
@@ -37,6 +38,7 @@ declare module 'tmcp' {
 		} | undefined;
 		/**
 		 * Get the client capabilities of the client that initiated the current request, you can use this to verify the client support something before invoking the respective method.
+		 * @deprecated Use `server.ctx.sessionInfo.clientCapabilities` instead.
 		 */
 		currentClientCapabilities(): {
 			experimental?: {} | undefined;
@@ -54,8 +56,9 @@ declare module 'tmcp' {
 		 *
 		 * Tools will be invoked by the LLM when it thinks it needs to use them, you can use the annotations to provide additional information about the tool, like what it does, how to use it, etc.
 		 * */
-		tool<TSchema extends StandardSchema | undefined = undefined, TOutputSchema extends StandardSchema | undefined = undefined>({ name, description, title, schema, outputSchema, annotations, enabled, icons, }: {
+		tool<TSchema extends StandardSchema | undefined = undefined, TOutputSchema extends StandardSchema | undefined = undefined>({ name, description, title, schema, outputSchema, annotations, enabled, icons, _meta, }: {
 			name: string;
+			_meta?: Record<string, any>;
 			description: string;
 			title?: string;
 			enabled?: () => boolean | Promise<boolean>;
@@ -109,7 +112,7 @@ declare module 'tmcp' {
 		 * The main function that receive a JSONRpc message and either dispatch a `send` event or process the request.
 		 *
 		 * */
-		receive(message: JSONRPCResponse | JSONRPCRequest, ctx?: Context<CustomContext>): ReturnType<JSONRPCServer["receive"]> | ReturnType<JSONRPCClient["receive"] | undefined>;
+		receive(message: JSONRPCMessage, ctx?: Context<CustomContext>): ReturnType<JSONRPCServer["receive"]> | ReturnType<JSONRPCClient["receive"] | undefined>;
 		/**
 		 * Send a notification for subscriptions
 		 * */
@@ -182,10 +185,16 @@ declare module 'tmcp' {
 	};
 	export type Context<TCustom extends Record<string, unknown> | undefined = undefined> = {
 		sessionId?: string | undefined;
+		sessionInfo?: {
+			clientCapabilities?: ClientCapabilities_1;
+			clientInfo?: ClientInfo_1;
+			logLevel?: LoggingLevel;
+		} | undefined;
 		auth?: AuthInfo | undefined;
 		custom?: TCustom | undefined;
 	};
 	export type Icons = Icons_1;
+	export type Subscriptions = Record<SubscriptionsKeys, string[]>;
 	export type CallToolResult<TStructuredContent extends Record<string, unknown> | undefined> = CallToolResult_1<TStructuredContent>;
 	export type ReadResourceResult = ReadResourceResult_1;
 	export type GetPromptResult = GetPromptResult_1;
@@ -205,7 +214,7 @@ declare module 'tmcp' {
 	type ServerOptions<TSchema extends StandardSchemaV1 | undefined> = {
 		capabilities?: ServerCapabilities;
 		instructions?: string;
-		adapter: JsonSchemaAdapter<TSchema>;
+		adapter: JsonSchemaAdapter<TSchema> | undefined;
 		pagination?: {
 			resources?: { size?: number };
 			prompts?: { size?: number };
@@ -222,29 +231,73 @@ declare module 'tmcp' {
 		'resources': [];
 	}
 
+	type SubscriptionsKeysObj = {
+		[K in keyof ChangedArgs as ChangedArgs[K]["length"] extends 0 ? "without_args" : "with_args"]: K
+	};
+
+	type SubscriptionsKeys = SubscriptionsKeysObj["with_args"];
+
 	type McpEvents = {
 		send: (message: {
 			request: JSONRPCRequest;
-			context: {
-				sessions?: string[] | undefined;
-			};
+		}) => void;
+		broadcast: (message: {
+			request: JSONRPCRequest;
 		}) => void;
 		initialize: (initialize_request: InitializeRequestParams) => void;
+		subscription: (subscriptions_request: { uri: string }) => void;
+		loglevelchange: (change: { level: LoggingLevel_1 }) => void;
 	};
-	/**
-	 * A successful (non-error) response to a request.
-	 */
-	const JSONRPCResponseSchema: v.StrictObjectSchema<{
+	const JSONRPCMessageSchema: v.UnionSchema<[v.ObjectSchema<{
+		readonly method: v.StringSchema<undefined>;
+		readonly params: v.OptionalSchema<v.LooseObjectSchema<{
+			readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{
+				/**
+				 * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
+				 */
+				readonly progressToken: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>], undefined>, undefined>;
+			}, undefined>, undefined>;
+		}, undefined>, undefined>;
 		readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
 		readonly id: v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>], undefined>;
-		readonly result: v.ObjectSchema<{
+	}, undefined>, v.ObjectSchema<{
+		readonly method: v.StringSchema<undefined>;
+		readonly params: v.OptionalSchema<v.LooseObjectSchema<{
+			/**
+			 * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+			 * for notes on _meta usage.
+			 */
+			readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+		}, undefined>, undefined>;
+		readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+	}, undefined>, v.StrictObjectSchema<{
+		readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+		readonly id: v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>], undefined>;
+		readonly result: v.LooseObjectSchema<{
 			/**
 			 * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
 			 * for notes on _meta usage.
 			 */
 			readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
 		}, undefined>;
-	}, undefined>;
+	}, undefined>, v.StrictObjectSchema<{
+		readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+		readonly id: v.UnionSchema<[v.StringSchema<undefined>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>], undefined>;
+		readonly error: v.ObjectSchema<{
+			/**
+			 * The error type that occurred.
+			 */
+			readonly code: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>]>;
+			/**
+			 * A short description of the error. The message SHOULD be limited to a concise single sentence.
+			 */
+			readonly message: v.StringSchema<undefined>;
+			/**
+			 * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.).
+			 */
+			readonly data: v.OptionalSchema<v.UnknownSchema, undefined>;
+		}, undefined>;
+	}, undefined>], undefined>;
 	const IconsSchema: v.ObjectSchema<{
 		/**
 		 * Optional set of sized icons that the client can display in a user interface.
@@ -1206,7 +1259,7 @@ declare module 'tmcp' {
 	type CreateMessageRequestParams_1 = v.InferInput<typeof CreateMessageRequestParamsSchema>;
 	type CreateMessageResult_1 = v.InferInput<typeof CreateMessageResultSchema>;
 	type Resource_1 = v.InferInput<typeof ResourceSchema>;
-	type JSONRPCResponse = v.InferInput<typeof JSONRPCResponseSchema>;
+	type JSONRPCMessage = v.InferInput<typeof JSONRPCMessageSchema>;
 	type LoggingLevel_1 = v.InferInput<typeof LoggingLevelSchema>;
 	type ToolAnnotations = v.InferInput<typeof ToolAnnotationsSchema>;
 	type ElicitResult_1 = v.InferInput<typeof ElicitResultSchema>;

package/src/types/index.d.ts.map

@@ -4,6 +4,7 @@
 	"names": [
 		"McpServer",
 		"Icons",
+		"Subscriptions",
 		"ReadResourceResult",
 		"GetPromptResult",
 		"ClientCapabilities",
@@ -17,8 +18,10 @@
 		"Completion",
 		"ServerOptions",
 		"ChangedArgs",
+		"SubscriptionsKeysObj",
+		"SubscriptionsKeys",
 		"McpEvents",
-		"JSONRPCResponseSchema",
+		"JSONRPCMessageSchema",
 		"IconsSchema",
 		"ImplementationSchema",
 		"ClientCapabilitiesSchema",
@@ -37,7 +40,7 @@
 		"ServerCapabilities",
 		"InitializeRequestParams",
 		"CompleteResult",
-		"JSONRPCResponse",
+		"JSONRPCMessage",
 		"ToolAnnotations",
 		"Trim",
 		"ExtractVarName",
@@ -61,6 +64,6 @@
 		null,
 		null
 	],
-	"mappings": ";;;;;cAoJaA,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aC81CyBC,KAAKA;;aAuBQC,kBAAkBA;aAGrBC,eAAeA;aAvBZC,kBAAkBA;aAUKC,UAAUA;aAmBzBC,0BAA0BA;aAGjCC,mBAAmBA;aAY9BC,QAAQA;aASJC,YAAYA;aA/CVC,UAAUA;aAqDZC,YAAYA;MCphDtDC,UAAUA;;;;;MAyCVC,aAAaA;;;;;;;;;;;;;MAabC,WAAWA;;;;;;;MAaXC,SAASA;;;;;;;;;;;;ODKRC,qBAAqBA;;;;;;;;;;;OAgHrBC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoBXC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAUpBC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;OA6BxBC,6BAA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuB7BC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmMxBC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8GdC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+PxBC,qBAAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BrBC,qBAAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4GrBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoEpBC,kBAAkBA;OAuGlBC,gCAAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8ChCC,yBAAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6GzBC,kBAAkBA;;;;;;;;;;;;;;;;;;OAkFlBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;MAiI2BC,kBAAkBA;;;;;MAUbC,uBAAuBA;;;;;;;;;;;;;MAahCC,cAAcA;;;;MAwBbC,eAAeA;;MAMfC,eAAeA;;;ME5iDnEC,IAAIA;;;;;;;MAOJC,cAAcA;;;;;;;MAOdC,cAAcA;;;;;MAKdC,qBAAqBA;;;;;;;;;;;;;;;;;MAiBrBC,4BAA4BA;;;;;;MAMrBC,2BAA2BA;;;;;;;OCjC1BC,iBAAiBA;;;;;;;;;;;;;;;;cAAjBA,iBAAiBA",
+	"mappings": ";;;;;cAyJaA,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aCw1CyBC,KAAKA;aDp7CFC,aAAaA;;aC28CHC,kBAAkBA;aAGrBC,eAAeA;aAvBZC,kBAAkBA;aAUKC,UAAUA;aAmBzBC,0BAA0BA;aAGjCC,mBAAmBA;aAY9BC,QAAQA;aAYJC,YAAYA;aAlDVC,UAAUA;aAwDZC,YAAYA;MCrhDtDC,UAAUA;;;;;MAyCVC,aAAaA;;;;;;;;;;;;;MAabC,WAAWA;;;;;;;MAOlBC,oBAAoBA;;;;MAIbC,iBAAiBA;;MAEjBC,SAASA;;;;;;;;;;;ODgCRC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmFpBC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoBXC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAUpBC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;OA6BxBC,6BAA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuB7BC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmMxBC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8GdC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+PxBC,qBAAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BrBC,qBAAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4GrBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoEpBC,kBAAkBA;OAuGlBC,gCAAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8ChCC,yBAAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6GzBC,kBAAkBA;;;;;;;;;;;;;;;;;;OAkFlBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;MAiI2BC,kBAAkBA;;;;;MAUbC,uBAAuBA;;;;;;;;;;;;;MAahCC,cAAcA;;;;MAwBdC,cAAcA;;MASbC,eAAeA;;;ME9iDnEC,IAAIA;;;;;;;MAOJC,cAAcA;;;;;;;MAOdC,cAAcA;;;;;MAKdC,qBAAqBA;;;;;;;;;;;;;;;;;MAiBrBC,4BAA4BA;;;;;;MAMrBC,2BAA2BA;;;;;;;OCjC1BC,iBAAiBA;;;;;;;;;;;;;;;;cAAjBA,iBAAiBA",
 	"ignoreList": []
 }

package/src/validation/index.js

@@ -1,4 +1,3 @@
-/* eslint-disable jsdoc/no-undefined-types */
 import * as v from 'valibot';
 export const LATEST_PROTOCOL_VERSION = '2025-06-18';
 export const DEFAULT_NEGOTIATED_PROTOCOL_VERSION = '2025-03-26';
@@ -62,7 +61,7 @@ export const NotificationSchema = v.object({
 	method: v.string(),
 	params: v.optional(BaseNotificationParamsSchema),
 });
-export const ResultSchema = v.object({
+export const ResultSchema = v.looseObject({
 	/**
 	 * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
 	 * for notes on _meta usage.
@@ -1572,6 +1571,9 @@ export const ServerResultSchema = v.union([
 /**
  * @typedef {v.InferInput<typeof JSONRPCRequestSchema>} JSONRPCRequest
  */
+/**
+ * @typedef {v.InferInput<typeof JSONRPCMessageSchema>} JSONRPCMessage
+ */
 /**
  * @typedef {v.InferInput<typeof JSONRPCResponseSchema>} JSONRPCResponse
  */