tmcp 1.15.4 → 1.16.0

package/README.md

@@ -129,6 +129,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 +234,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 +275,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 +320,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 +391,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 +539,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 +952,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 +961,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 +987,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.4",
+  "version": "1.16.0",
   "description": "The main tmcp library",
   "main": "src/index.js",
   "type": "module",

package/src/index.js

@@ -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,41 +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, string>}
-	 */
-	#negotiated_protocol_versions = new Map();
-
-	/**
-	 * @type {Map<string|undefined, LoggingLevel>}
-	 */
-	#session_log_levels = new Map();
-
 	/**
 	 * @param {ServerInfo} server_info
 	 * @param {ServerOptions<StandardSchema>} options
@@ -229,8 +204,6 @@ export class McpServer {
 					initialize_request,
 				);
 
-				const session_id = this.#session_id;
-
 				// Validate protocol version format
 				if (
 					should_version_negotiation_fail(
@@ -250,24 +223,6 @@ export class McpServer {
 					validated_initialize.protocolVersion,
 				);
 
-				// Store negotiated protocol version
-				this.#negotiated_protocol_versions.set(
-					session_id,
-					negotiated_version,
-				);
-
-				// 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', {
@@ -335,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;
 	}
@@ -354,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;
@@ -373,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 },
 					}),
 				);
 			});
@@ -390,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();
 		}
 
@@ -411,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);
 	}
 
 	/**
@@ -436,6 +397,7 @@ export class McpServer {
 							title: tool.title || tool.description,
 							description: tool.description,
 							icons: tool.icons,
+							_meta: tool._meta,
 							inputSchema: tool.schema
 								? await this.#options.adapter.toJsonSchema(
 										tool.schema,
@@ -648,12 +610,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 {};
 			});
 		}
@@ -797,9 +758,7 @@ export class McpServer {
 			const response = await this.#client?.request(
 				'roots/list',
 				undefined,
-				{
-					sessions: [this.#session_id],
-				},
+				'standalone',
 			);
 			this.roots = response?.roots || [];
 		} catch {
@@ -830,26 +789,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',
+			);
 		}
 	}
 
@@ -860,7 +827,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(
@@ -873,6 +840,7 @@ export class McpServer {
 			annotations,
 			enabled,
 			icons,
+			_meta,
 		},
 		execute,
 	) {
@@ -886,6 +854,7 @@ export class McpServer {
 			execute,
 			annotations,
 			icons,
+			_meta,
 		});
 	}
 	/**
@@ -1000,18 +969,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
 			);
@@ -1046,28 +1003,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',
+			);
 		}
 	}
 
@@ -1102,9 +1047,7 @@ export class McpServer {
 				requestedSchema:
 					await this.#options.adapter.toJsonSchema(schema),
 			},
-			{
-				sessions: [this.#session_id],
-			},
+			'standalone',
 		);
 		const elicit_result = v.parse(ElicitResultSchema, result);
 		let validated_result = schema['~standard'].validate(
@@ -1142,9 +1085,7 @@ export class McpServer {
 		const response = await this.#client?.request(
 			'sampling/createMessage',
 			validated_request,
-			{
-				sessions: [this.#session_id],
-			},
+			'standalone',
 		);
 
 		// Validate and return the response
@@ -1160,18 +1101,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,
+			});
 		}
 	}
 
@@ -1190,29 +1125,21 @@ export class McpServer {
 			);
 		}
 
-		const sessions = [];
-
-		for (let [session_id, session_log_level] of this.#session_log_levels) {
-			// Check if the current log level should be sent based on severity
-			if (this.#should_log(level, session_log_level)) {
-				sessions.push(session_id);
-			}
-		}
-
-		if (sessions.length === 0) return;
+		const current_session_level =
+			this.#ctx_storage.getStore()?.sessionInfo?.logLevel ??
+			this.#options.logging?.default ??
+			'info';
 
-		// Send the log notification to the client
-		this.#notify(
-			'notifications/message',
-			{
+		if (
+			current_session_level &&
+			this.#should_log(level, current_session_level)
+		) {
+			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>,
@@ -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

@@ -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>;
@@ -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;
@@ -222,14 +231,22 @@ 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.
@@ -237,7 +254,7 @@ declare module 'tmcp' {
 	const JSONRPCResponseSchema: 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.ObjectSchema<{
+		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.

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

@@ -4,6 +4,7 @@
 	"names": [
 		"McpServer",
 		"Icons",
+		"Subscriptions",
 		"ReadResourceResult",
 		"GetPromptResult",
 		"ClientCapabilities",
@@ -17,6 +18,8 @@
 		"Completion",
 		"ServerOptions",
 		"ChangedArgs",
+		"SubscriptionsKeysObj",
+		"SubscriptionsKeys",
 		"McpEvents",
 		"JSONRPCResponseSchema",
 		"IconsSchema",
@@ -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;aASJC,YAAYA;aA/CVC,UAAUA;aAqDZC,YAAYA;MClhDtDC,UAAUA;;;;;MAyCVC,aAAaA;;;;;;;;;;;;;MAabC,WAAWA;;;;;;;MAOlBC,oBAAoBA;;;;MAIbC,iBAAiBA;;MAEjBC,SAASA;;;;;;;;;;;;;;ODGRC,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;;;ME3iDnEC,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.