tmcp 1.3.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tmcp",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "The main tmcp library",
   "main": "src/index.js",
   "type": "module",
@@ -34,6 +34,7 @@
   "devDependencies": {
     "@standard-schema/spec": "^1.0.0",
     "@types/json-schema": "^7.0.15",
+    "@types/node": "^24.0.13",
     "publint": "^0.3.12"
   },
   "scripts": {

package/src/index.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @typedef {ClientCapabilitiesType} ClientCapabilities
+ */
 /**
  * @template {StandardSchemaV1} StandardSchema
  */
@@ -7,6 +10,28 @@ export class McpServer<StandardSchema extends StandardSchemaV1> {
      * @param {ServerOptions<StandardSchema>} options
      */
     constructor(server_info: ServerInfo, options: ServerOptions<StandardSchema>);
+    /**
+     * @type {Array<{uri: string, name?: string}>}
+     */
+    roots: Array<{
+        uri: string;
+        name?: string;
+    }>;
+    currentClientCapabilities(): {
+        roots?: {
+            listChanged?: boolean;
+        } & {
+            [key: string]: unknown;
+        };
+        sampling?: {} & {
+            [key: string]: unknown;
+        };
+        elicitation?: {} & {
+            [key: string]: unknown;
+        };
+    } & {
+        [key: string]: unknown;
+    };
     /**
      * @template {keyof McpEvents} TEvent
      * @param {TEvent} event
@@ -57,18 +82,36 @@ export class McpServer<StandardSchema extends StandardSchemaV1> {
         complete?: NoInfer<TVariables extends never ? never : Partial<Record<TVariables, Completion>>>;
     }, execute: (uri: string, params: Record<TVariables, string | string[]>) => Promise<ReadResourceResult> | ReadResourceResult): void;
     /**
-     * @param {JSONRPCRequest} request
-     * @returns {ReturnType<JSONRPCServer['receive']>}
+     * @param {JSONRPCResponse | JSONRPCRequest} message
+     * @param {string} [session_id]
+     * @returns {ReturnType<JSONRPCServer['receive']> | ReturnType<JSONRPCClient['receive'] | undefined>}
      */
-    receive(request: JSONRPCRequest): ReturnType<JSONRPCServer["receive"]>;
+    receive(message: JSONRPCResponse | JSONRPCRequest, session_id?: string): ReturnType<JSONRPCServer["receive"]> | ReturnType<JSONRPCClient["receive"] | undefined>;
     /**
      * Send a notification for subscriptions
      * @param {SubscriptionsKeys} what
      * @param {string} id
      */
     changed(what: SubscriptionsKeys, id: string): void;
+    /**
+     * Refresh roots list from client
+     */
+    refreshRoots(): Promise<void>;
+    /**
+     * @template {StandardSchema} TSchema
+     * @param {TSchema} schema
+     * @returns {Promise<StandardSchemaV1.InferOutput<TSchema>>}
+     */
+    elicitation<TSchema extends StandardSchema>(schema: TSchema): Promise<StandardSchemaV1.InferOutput<TSchema>>;
+    /**
+     * Request language model sampling from the client
+     * @param {CreateMessageRequest} request
+     * @returns {Promise<CreateMessageResult>}
+     */
+    message(request: CreateMessageRequest): Promise<CreateMessageResult>;
     #private;
 }
+export type ClientCapabilities = ClientCapabilitiesType;
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { McpEvents } from "./internal/internal.js";
 import type { CallToolResult } from "./validation/index.js";
@@ -76,8 +119,13 @@ import type { Completion } from "./internal/internal.js";
 import type { GetPromptResult } from "./validation/index.js";
 import type { ReadResourceResult } from "./validation/index.js";
 import type { ExtractURITemplateVariables } from "./internal/uri-template.js";
+import type { JSONRPCResponse } from "./validation/index.js";
 import type { JSONRPCRequest } from "json-rpc-2.0";
 import { JSONRPCServer } from 'json-rpc-2.0';
+import { JSONRPCClient } from 'json-rpc-2.0';
 import type { SubscriptionsKeys } from "./internal/internal.js";
+import type { CreateMessageRequest } from "./validation/index.js";
+import type { CreateMessageResult } from "./validation/index.js";
 import type { ServerInfo } from "./internal/internal.js";
 import type { ServerOptions } from "./internal/internal.js";
+import type { ClientCapabilities as ClientCapabilitiesType } from "./validation/index.js";

package/src/index.js

@@ -2,7 +2,7 @@
  * @import { StandardSchemaV1 } from "@standard-schema/spec";
  * @import { JSONRPCRequest, JSONRPCParams } from "json-rpc-2.0";
  * @import { ExtractURITemplateVariables } from "./internal/uri-template.js";
- * @import { CallToolResult, ReadResourceResult, GetPromptResult, CompleteResult } from "./validation/index.js";
+ * @import { CallToolResult, ReadResourceResult, GetPromptResult, ClientCapabilities as ClientCapabilitiesType, JSONRPCRequest as JSONRPCRequestType, JSONRPCResponse, CreateMessageRequest, CreateMessageResult } from "./validation/index.js";
  * @import { Tool, Completion, Prompt, Resource, ServerOptions, ServerInfo, SubscriptionsKeys, McpEvents } from "./internal/internal.js";
  */
 import { JSONRPCServer, JSONRPCClient } from 'json-rpc-2.0';
@@ -12,16 +12,26 @@ import {
 	ReadResourceResultSchema,
 	GetPromptResultSchema,
 	CompleteResultSchema,
+	InitializeRequestSchema,
+	JSONRPCRequestSchema,
+	JSONRPCResponseSchema,
+	CreateMessageRequestSchema,
+	CreateMessageResultSchema,
 } from './validation/index.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import * as v from 'valibot';
 
+/**
+ * @typedef {ClientCapabilitiesType} ClientCapabilities
+ */
+
 /**
  * @template {StandardSchemaV1} StandardSchema
  */
 export class McpServer {
 	#server = new JSONRPCServer();
 	/**
-	 * @type {JSONRPCClient | undefined}
+	 * @type {JSONRPCClient<Record<string, any> | undefined> | undefined}
 	 */
 	#client;
 	#options;
@@ -38,6 +48,10 @@ export class McpServer {
 	 */
 	#resources = new Map();
 	#templates = new UriTemplateMatcher();
+	/**
+	 * @type {Array<{uri: string, name?: string}>}
+	 */
+	roots = [];
 	/**
 	 * @type {{ [ref: string]: Map<string, Partial<Record<string, Completion>>> }}
 	 */
@@ -49,24 +63,51 @@ export class McpServer {
 	#event_target = new EventTarget();
 
 	/**
-	 * @type {Record<SubscriptionsKeys, Set<string>>}
+	 * @type {Record<SubscriptionsKeys, Map<string, Set<string | undefined>>>}
 	 */
 	#subscriptions = {
 		/**
-		 * @type {Set<string>}
+		 * @type {Map<string, Set<string>>}
 		 */
-		resource: new Set(),
+		resource: new Map(),
 	};
 
+	/**
+	 * @type {AsyncLocalStorage<string | undefined>}
+	 */
+	#session_storage = new AsyncLocalStorage();
+
+	/**
+	 * @type {Map<string|undefined, ClientCapabilities>}
+	 */
+	#client_capabilities_map = new Map();
+
 	/**
 	 * @param {ServerInfo} server_info
 	 * @param {ServerOptions<StandardSchema>} options
 	 */
 	constructor(server_info, options) {
 		this.#options = options;
-		this.#server.addMethod('initialize', ({ protocolVersion }) => {
+		this.#server.addMethod('initialize', (initialize_request) => {
+			const validated_initialize = v.parse(
+				InitializeRequestSchema,
+				initialize_request,
+			);
+			this.#client_capabilities_map.set(
+				this.#session_id,
+				validated_initialize.capabilities,
+			);
+			this.#event_target.dispatchEvent(
+				new CustomEvent('initialize', {
+					detail: validated_initialize,
+				}),
+			);
+			// Trigger initial roots request if client supports it
+			if (validated_initialize.capabilities?.roots) {
+				this.#refresh_roots();
+			}
 			return {
-				protocolVersion,
+				protocolVersion: validated_initialize.protocolVersion,
 				...options,
 				serverInfo: server_info,
 			};
@@ -80,9 +121,34 @@ export class McpServer {
 		this.#init_tools();
 		this.#init_prompts();
 		this.#init_resources();
+		this.#init_roots();
 		this.#init_completion();
 	}
 
+	get #session_id() {
+		return this.#session_storage.getStore();
+	}
+
+	get #client_capabilities() {
+		return this.#client_capabilities_map.get(this.#session_id);
+	}
+
+	currentClientCapabilities() {
+		return this.#client_capabilities;
+	}
+
+	#lazyily_create_client() {
+		if (!this.#client) {
+			this.#client = new JSONRPCClient((payload, context = {}) => {
+				this.#event_target.dispatchEvent(
+					new CustomEvent('send', {
+						detail: { request: payload, context },
+					}),
+				);
+			});
+		}
+	}
+
 	/**
 	 * @template {keyof McpEvents} TEvent
 	 * @param {TEvent} event
@@ -90,12 +156,8 @@ export class McpServer {
 	 * @param {AddEventListenerOptions} [options]
 	 */
 	on(event, callback, options) {
-		if (event === 'send' && !this.#client) {
-			this.#client = new JSONRPCClient((payload) => {
-				this.#event_target.dispatchEvent(
-					new CustomEvent('send', { detail: payload }),
-				);
-			});
+		if (event === 'send') {
+			this.#lazyily_create_client();
 		}
 
 		this.#event_target.addEventListener(
@@ -110,9 +172,10 @@ export class McpServer {
 	/**
 	 * @param {string} method
 	 * @param {JSONRPCParams} [params]
+	 * @param {Record<string, any>} [extra]
 	 */
-	#notify(method, params) {
-		this.#client?.notify(method, params);
+	#notify(method, params, extra) {
+		this.#client?.notify(method, params, extra);
 	}
 
 	/**
@@ -243,7 +306,12 @@ export class McpServer {
 
 		if (this.#options.capabilities?.resources?.subscribe) {
 			this.#server.addMethod('resources/subscribe', async ({ uri }) => {
-				this.#subscriptions.resource.add(uri);
+				let subscriptions = this.#subscriptions.resource.get(uri);
+				if (!subscriptions) {
+					subscriptions = new Set();
+					this.#subscriptions.resource.set(uri, subscriptions);
+				}
+				subscriptions.add(this.#session_id);
 				return {};
 			});
 		}
@@ -309,6 +377,37 @@ export class McpServer {
 			);
 		});
 	}
+	/**
+	 *
+	 */
+	#init_roots() {
+		this.#server.addMethod('notifications/roots/list_changed', () => {
+			this.#refresh_roots();
+			return null;
+		});
+	}
+
+	/**
+	 * Request roots list from client
+	 */
+	async #refresh_roots() {
+		if (!this.#client_capabilities?.roots) return;
+
+		this.#lazyily_create_client();
+		try {
+			const response = await this.#client?.request(
+				'roots/list',
+				undefined,
+				{
+					sessions: [this.#session_id],
+				},
+			);
+			this.roots = response?.roots || [];
+		} catch {
+			// Client doesn't support roots or request failed
+			this.roots = [];
+		}
+	}
 	/**
 	 *
 	 */
@@ -407,11 +506,28 @@ export class McpServer {
 		});
 	}
 	/**
-	 * @param {JSONRPCRequest} request
-	 * @returns {ReturnType<JSONRPCServer['receive']>}
+	 * @param {JSONRPCResponse | JSONRPCRequest} message
+	 * @param {string} [session_id]
+	 * @returns {ReturnType<JSONRPCServer['receive']> | ReturnType<JSONRPCClient['receive'] | undefined>}
 	 */
-	receive(request) {
-		return this.#server.receive(request);
+	receive(message, session_id) {
+		// Validate the message first
+		const validated_message = v.safeParse(JSONRPCRequestSchema, message);
+
+		// Check if it's a request or response
+		if (validated_message.success) {
+			return this.#session_storage.run(
+				session_id,
+				async () =>
+					await this.#server.receive(validated_message.output),
+			);
+		}
+		// It's a response - handle with client
+		const validated_response = v.parse(JSONRPCResponseSchema, message);
+		this.#lazyily_create_client();
+		return this.#session_storage.run(session_id, async () =>
+			this.#client?.receive(validated_response),
+		);
 	}
 
 	/**
@@ -423,10 +539,82 @@ export class McpServer {
 		if (this.#subscriptions[what].has(id)) {
 			const resource = this.#resources.get(id);
 			if (!resource) return;
-			this.#notify(`notifications/resources/updated`, {
-				uri: id,
-				title: resource.name,
-			});
+			const sessions = this.#subscriptions[what].get(id);
+			this.#notify(
+				`notifications/resources/updated`,
+				{
+					uri: id,
+					title: resource.name,
+				},
+				{
+					sessions: sessions ? [...sessions] : undefined,
+				},
+			);
+		}
+	}
+
+	/**
+	 * Refresh roots list from client
+	 */
+	async refreshRoots() {
+		await this.#refresh_roots();
+	}
+
+	/**
+	 * @template {StandardSchema} TSchema
+	 * @param {TSchema} schema
+	 * @returns {Promise<StandardSchemaV1.InferOutput<TSchema>>}
+	 */
+	async elicitation(schema) {
+		if (!this.#client_capabilities?.elicitation)
+			throw new Error("Client doesn't support elicitation");
+
+		this.#lazyily_create_client();
+		let validated_result = schema['~standard'].validate(
+			await this.#client?.request(
+				'elicitation/create',
+				{
+					params: await this.#options.adapter.toJsonSchema(schema),
+				},
+				{
+					sessions: [this.#session_id],
+				},
+			),
+		);
+		if (validated_result instanceof Promise)
+			validated_result = await validated_result;
+		if (validated_result.issues) {
+			throw new Error(
+				`Invalid elicitation result: ${JSON.stringify(validated_result.issues)}`,
+			);
 		}
+		return validated_result.value;
+	}
+
+	/**
+	 * Request language model sampling from the client
+	 * @param {CreateMessageRequest} request
+	 * @returns {Promise<CreateMessageResult>}
+	 */
+	async message(request) {
+		if (!this.#client_capabilities?.sampling)
+			throw new Error("Client doesn't support sampling");
+
+		this.#lazyily_create_client();
+
+		// Validate the request
+		const validated_request = v.parse(CreateMessageRequestSchema, request);
+
+		// Make the request to the client
+		const response = await this.#client?.request(
+			'sampling/createMessage',
+			validated_request,
+			{
+				sessions: [this.#session_id],
+			},
+		);
+
+		// Validate and return the response
+		return v.parse(CreateMessageResultSchema, response);
 	}
 }

package/src/internal/internal.d.ts

@@ -6,6 +6,7 @@ import {
 	CallToolResult,
 	ReadResourceResult,
 	CompleteResult,
+	InitializeRequest,
 } from '../validation/index.js';
 
 export type Tool<TSchema extends StandardSchemaV1 = StandardSchemaV1<any>> = {
@@ -67,5 +68,11 @@ export type ServerInfo = {
 export type SubscriptionsKeys = 'resource';
 
 export type McpEvents = {
-	send: (message: JSONRPCRequest) => void;
+	send: (message: {
+		request: JSONRPCRequest;
+		context: {
+			sessions?: string[] | undefined;
+		};
+	}) => void;
+	initialize: (initialize_request: InitializeRequest) => void;
 };

package/src/validation/index.d.ts

@@ -382,6 +382,431 @@ export const PromptMessageSchema: v.LooseObjectSchema<{
         readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
     }, undefined>], undefined>;
 }, undefined>;
+/**
+ * A model hint for sampling requests.
+ */
+export const ModelHintSchema: v.LooseObjectSchema<{
+    /**
+     * Optional name of the model.
+     */
+    readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+/**
+ * A sampling message used in sampling requests.
+ */
+export const SamplingMessageSchema: v.LooseObjectSchema<{
+    readonly role: v.PicklistSchema<["user", "assistant"], undefined>;
+    readonly content: v.UnionSchema<[v.LooseObjectSchema<{
+        readonly type: v.LiteralSchema<"text", undefined>;
+        /**
+         * The text content of the message.
+         */
+        readonly text: v.StringSchema<undefined>;
+        /**
+         * See [MCP specification] for notes on _meta usage.
+         */
+        readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    }, undefined>, v.LooseObjectSchema<{
+        readonly type: v.LiteralSchema<"image", undefined>;
+        /**
+         * The base64-encoded image data.
+         */
+        readonly data: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
+        /**
+         * The MIME type of the image. Different providers may support different image types.
+         */
+        readonly mimeType: v.StringSchema<undefined>;
+        /**
+         * See [MCP specification] for notes on _meta usage.
+         */
+        readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    }, undefined>, v.LooseObjectSchema<{
+        readonly type: v.LiteralSchema<"audio", undefined>;
+        /**
+         * The base64-encoded audio data.
+         */
+        readonly data: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
+        /**
+         * The MIME type of the audio. Different providers may support different audio types.
+         */
+        readonly mimeType: v.StringSchema<undefined>;
+        /**
+         * See [MCP specification] for notes on _meta usage.
+         */
+        readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    }, undefined>, v.LooseObjectSchema<{
+        /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
+        readonly name: v.StringSchema<undefined>;
+        readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        /**
+         * The URI of this resource.
+         */
+        readonly uri: v.StringSchema<undefined>;
+        /**
+         * A description of what this resource represents.
+         */
+        readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        /**
+         * The MIME type of this resource, if known.
+         */
+        readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly type: v.LiteralSchema<"resource_link", undefined>;
+        /**
+         * See [MCP specification] for notes on _meta usage.
+         */
+        readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    }, undefined>, v.LooseObjectSchema<{
+        readonly type: v.LiteralSchema<"resource", undefined>;
+        readonly resource: v.UnionSchema<[v.LooseObjectSchema<{
+            /**
+             * The URI of this resource.
+             */
+            readonly uri: v.StringSchema<undefined>;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            /**
+             * The text of the item. This must only be set if the item can actually be represented as text (not binary data).
+             */
+            readonly text: v.StringSchema<undefined>;
+            /**
+             * See [MCP specification] for notes on _meta usage.
+             */
+            readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+        }, undefined>, v.LooseObjectSchema<{
+            /**
+             * The URI of this resource.
+             */
+            readonly uri: v.StringSchema<undefined>;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            /**
+             * A base64-encoded string representing the binary data of the item.
+             */
+            readonly blob: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
+            /**
+             * See [MCP specification] for notes on _meta usage.
+             */
+            readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+        }, undefined>], undefined>;
+        /**
+         * See [MCP specification] for notes on _meta usage.
+         */
+        readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    }, undefined>], undefined>;
+}, undefined>;
+/**
+ * Model preferences for sampling requests.
+ */
+export const ModelPreferencesSchema: v.LooseObjectSchema<{
+    /**
+     * Optional hints for which model to use, in order of preference.
+     */
+    readonly hints: v.OptionalSchema<v.ArraySchema<v.LooseObjectSchema<{
+        /**
+         * Optional name of the model.
+         */
+        readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    /**
+     * Priority for cost considerations (0-1, where 1 is highest priority).
+     */
+    readonly costPriority: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    /**
+     * Priority for speed considerations (0-1, where 1 is highest priority).
+     */
+    readonly speedPriority: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    /**
+     * Priority for intelligence considerations (0-1, where 1 is highest priority).
+     */
+    readonly intelligencePriority: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>;
+/**
+ * Request for sampling/createMessage.
+ */
+export const CreateMessageRequestSchema: v.LooseObjectSchema<{
+    /**
+     * The messages to be processed.
+     */
+    readonly messages: v.ArraySchema<v.LooseObjectSchema<{
+        readonly role: v.PicklistSchema<["user", "assistant"], undefined>;
+        readonly content: v.UnionSchema<[v.LooseObjectSchema<{
+            readonly type: v.LiteralSchema<"text", undefined>;
+            /**
+             * The text content of the message.
+             */
+            readonly text: v.StringSchema<undefined>;
+            /**
+             * See [MCP specification] for notes on _meta usage.
+             */
+            readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+        }, undefined>, v.LooseObjectSchema<{
+            readonly type: v.LiteralSchema<"image", undefined>;
+            /**
+             * The base64-encoded image data.
+             */
+            readonly data: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
+            /**
+             * The MIME type of the image. Different providers may support different image types.
+             */
+            readonly mimeType: v.StringSchema<undefined>;
+            /**
+             * See [MCP specification] for notes on _meta usage.
+             */
+            readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+        }, undefined>, v.LooseObjectSchema<{
+            readonly type: v.LiteralSchema<"audio", undefined>;
+            /**
+             * The base64-encoded audio data.
+             */
+            readonly data: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
+            /**
+             * The MIME type of the audio. Different providers may support different audio types.
+             */
+            readonly mimeType: v.StringSchema<undefined>;
+            /**
+             * See [MCP specification] for notes on _meta usage.
+             */
+            readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+        }, undefined>, v.LooseObjectSchema<{
+            /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
+            readonly name: v.StringSchema<undefined>;
+            readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            /**
+             * The URI of this resource.
+             */
+            readonly uri: v.StringSchema<undefined>;
+            /**
+             * A description of what this resource represents.
+             */
+            readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly type: v.LiteralSchema<"resource_link", undefined>;
+            /**
+             * See [MCP specification] for notes on _meta usage.
+             */
+            readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+        }, undefined>, v.LooseObjectSchema<{
+            readonly type: v.LiteralSchema<"resource", undefined>;
+            readonly resource: v.UnionSchema<[v.LooseObjectSchema<{
+                /**
+                 * The URI of this resource.
+                 */
+                readonly uri: v.StringSchema<undefined>;
+                /**
+                 * The MIME type of this resource, if known.
+                 */
+                readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * The text of the item. This must only be set if the item can actually be represented as text (not binary data).
+                 */
+                readonly text: v.StringSchema<undefined>;
+                /**
+                 * See [MCP specification] for notes on _meta usage.
+                 */
+                readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+            }, undefined>, v.LooseObjectSchema<{
+                /**
+                 * The URI of this resource.
+                 */
+                readonly uri: v.StringSchema<undefined>;
+                /**
+                 * The MIME type of this resource, if known.
+                 */
+                readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                /**
+                 * A base64-encoded string representing the binary data of the item.
+                 */
+                readonly blob: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
+                /**
+                 * See [MCP specification] for notes on _meta usage.
+                 */
+                readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+            }, undefined>], undefined>;
+            /**
+             * See [MCP specification] for notes on _meta usage.
+             */
+            readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+        }, undefined>], undefined>;
+    }, undefined>, undefined>;
+    /**
+     * Optional system prompt to provide context.
+     */
+    readonly systemPrompt: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    /**
+     * Optional context inclusion preference.
+     */
+    readonly includeContext: v.OptionalSchema<v.PicklistSchema<["none", "thisServer", "allServers"], undefined>, undefined>;
+    /**
+     * Optional temperature for generation.
+     */
+    readonly temperature: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    /**
+     * Maximum number of tokens to generate.
+     */
+    readonly maxTokens: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>;
+    /**
+     * Optional stop sequences.
+     */
+    readonly stopSequences: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+    /**
+     * Optional metadata for the request.
+     */
+    readonly metadata: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    /**
+     * Optional model preferences for the request.
+     */
+    readonly modelPreferences: v.OptionalSchema<v.LooseObjectSchema<{
+        /**
+         * Optional hints for which model to use, in order of preference.
+         */
+        readonly hints: v.OptionalSchema<v.ArraySchema<v.LooseObjectSchema<{
+            /**
+             * Optional name of the model.
+             */
+            readonly name: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, undefined>;
+        /**
+         * Priority for cost considerations (0-1, where 1 is highest priority).
+         */
+        readonly costPriority: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        /**
+         * Priority for speed considerations (0-1, where 1 is highest priority).
+         */
+        readonly speedPriority: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        /**
+         * Priority for intelligence considerations (0-1, where 1 is highest priority).
+         */
+        readonly intelligencePriority: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+/**
+ * Response for sampling/createMessage.
+ */
+export const CreateMessageResultSchema: v.LooseObjectSchema<{
+    /**
+     * The model that generated the message.
+     */
+    readonly model: v.StringSchema<undefined>;
+    /**
+     * Optional stop reason.
+     */
+    readonly stopReason: v.OptionalSchema<v.UnionSchema<[v.LiteralSchema<"endTurn", undefined>, v.LiteralSchema<"stopSequence", undefined>, v.LiteralSchema<"maxTokens", undefined>, v.StringSchema<undefined>], undefined>, undefined>;
+    /**
+     * The role of the generated message.
+     */
+    readonly role: v.PicklistSchema<["user", "assistant"], undefined>;
+    /**
+     * The content of the generated message.
+     */
+    readonly content: v.UnionSchema<[v.LooseObjectSchema<{
+        readonly type: v.LiteralSchema<"text", undefined>;
+        /**
+         * The text content of the message.
+         */
+        readonly text: v.StringSchema<undefined>;
+        /**
+         * See [MCP specification] for notes on _meta usage.
+         */
+        readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    }, undefined>, v.LooseObjectSchema<{
+        readonly type: v.LiteralSchema<"image", undefined>;
+        /**
+         * The base64-encoded image data.
+         */
+        readonly data: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
+        /**
+         * The MIME type of the image. Different providers may support different image types.
+         */
+        readonly mimeType: v.StringSchema<undefined>;
+        /**
+         * See [MCP specification] for notes on _meta usage.
+         */
+        readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    }, undefined>, v.LooseObjectSchema<{
+        readonly type: v.LiteralSchema<"audio", undefined>;
+        /**
+         * The base64-encoded audio data.
+         */
+        readonly data: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
+        /**
+         * The MIME type of the audio. Different providers may support different audio types.
+         */
+        readonly mimeType: v.StringSchema<undefined>;
+        /**
+         * See [MCP specification] for notes on _meta usage.
+         */
+        readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    }, undefined>, v.LooseObjectSchema<{
+        /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
+        readonly name: v.StringSchema<undefined>;
+        readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        /**
+         * The URI of this resource.
+         */
+        readonly uri: v.StringSchema<undefined>;
+        /**
+         * A description of what this resource represents.
+         */
+        readonly description: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        /**
+         * The MIME type of this resource, if known.
+         */
+        readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly type: v.LiteralSchema<"resource_link", undefined>;
+        /**
+         * See [MCP specification] for notes on _meta usage.
+         */
+        readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    }, undefined>, v.LooseObjectSchema<{
+        readonly type: v.LiteralSchema<"resource", undefined>;
+        readonly resource: v.UnionSchema<[v.LooseObjectSchema<{
+            /**
+             * The URI of this resource.
+             */
+            readonly uri: v.StringSchema<undefined>;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            /**
+             * The text of the item. This must only be set if the item can actually be represented as text (not binary data).
+             */
+            readonly text: v.StringSchema<undefined>;
+            /**
+             * See [MCP specification] for notes on _meta usage.
+             */
+            readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+        }, undefined>, v.LooseObjectSchema<{
+            /**
+             * The URI of this resource.
+             */
+            readonly uri: v.StringSchema<undefined>;
+            /**
+             * The MIME type of this resource, if known.
+             */
+            readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            /**
+             * A base64-encoded string representing the binary data of the item.
+             */
+            readonly blob: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.Base64Action<string, undefined>]>;
+            /**
+             * See [MCP specification] for notes on _meta usage.
+             */
+            readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+        }, undefined>], undefined>;
+        /**
+         * See [MCP specification] for notes on _meta usage.
+         */
+        readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    }, undefined>], undefined>;
+}, undefined>;
 /**
  * The server's response to a tool call.
  */
@@ -675,8 +1100,112 @@ export const CompleteResultSchema: v.LooseObjectSchema<{
     }, undefined>;
     readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
 }, undefined>;
+export const ClientCapabilitiesSchema: v.LooseObjectSchema<{
+    readonly roots: v.OptionalSchema<v.LooseObjectSchema<{
+        readonly listChanged: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    readonly sampling: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    readonly elicitation: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+}, undefined>;
+export const InitializeRequestSchema: v.LooseObjectSchema<{
+    readonly protocolVersion: v.StringSchema<undefined>;
+    readonly capabilities: v.LooseObjectSchema<{
+        readonly roots: v.OptionalSchema<v.LooseObjectSchema<{
+            readonly listChanged: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly sampling: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+        readonly elicitation: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
+    }, undefined>;
+}, undefined>;
+/**
+ * @typedef {v.InferInput<typeof ClientCapabilitiesSchema>} ClientCapabilities
+ */
+/**
+ * @typedef {v.InferInput<typeof InitializeRequestSchema>} InitializeRequest
+ */
+/**
+ * @typedef {v.InferInput<typeof CallToolResultSchema>} CallToolResult
+ */
+/**
+ * @typedef {v.InferInput<typeof ReadResourceResultSchema>} ReadResourceResult
+ */
+/**
+ * @typedef {v.InferInput<typeof GetPromptResultSchema>} GetPromptResult
+ */
+/**
+ * @typedef {v.InferInput<typeof CompleteResultSchema>} CompleteResult
+ */
+/**
+ * @typedef {v.InferInput<typeof CreateMessageRequestSchema>} CreateMessageRequest
+ */
+/**
+ * @typedef {v.InferInput<typeof CreateMessageResultSchema>} CreateMessageResult
+ */
+/**
+ * @typedef {v.InferInput<typeof ModelPreferencesSchema>} ModelPreferences
+ */
+/**
+ * @typedef {v.InferInput<typeof SamplingMessageSchema>} SamplingMessage
+ */
+/**
+ * @typedef {v.InferInput<typeof ModelHintSchema>} ModelHint
+ */
+/**
+ * JSON-RPC 2.0 Request
+ */
+export const JSONRPCRequestSchema: v.LooseObjectSchema<{
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+    readonly method: v.StringSchema<undefined>;
+    readonly params: v.OptionalSchema<v.UnionSchema<[v.ArraySchema<v.UnknownSchema, undefined>, v.LooseObjectSchema<{}, undefined>], undefined>, undefined>;
+    readonly id: v.OptionalSchema<v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>, undefined>;
+}, undefined>;
+/**
+ * JSON-RPC 2.0 Response Success
+ */
+export const JSONRPCResponseSuccessSchema: v.LooseObjectSchema<{
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+    readonly result: v.UnknownSchema;
+    readonly id: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>;
+/**
+ * JSON-RPC 2.0 Response Error
+ */
+export const JSONRPCResponseErrorSchema: v.LooseObjectSchema<{
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+    readonly error: v.LooseObjectSchema<{
+        readonly code: v.NumberSchema<undefined>;
+        readonly message: v.StringSchema<undefined>;
+        readonly data: v.OptionalSchema<v.UnknownSchema, undefined>;
+    }, undefined>;
+    readonly id: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>;
+/**
+ * JSON-RPC 2.0 Response (Success or Error)
+ */
+export const JSONRPCResponseSchema: v.UnionSchema<[v.LooseObjectSchema<{
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+    readonly result: v.UnknownSchema;
+    readonly id: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>, v.LooseObjectSchema<{
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+    readonly error: v.LooseObjectSchema<{
+        readonly code: v.NumberSchema<undefined>;
+        readonly message: v.StringSchema<undefined>;
+        readonly data: v.OptionalSchema<v.UnknownSchema, undefined>;
+    }, undefined>;
+    readonly id: v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>, v.NullSchema<undefined>], undefined>;
+}, undefined>], undefined>;
+export type ClientCapabilities = v.InferInput<typeof ClientCapabilitiesSchema>;
+export type InitializeRequest = v.InferInput<typeof InitializeRequestSchema>;
 export type CallToolResult = v.InferInput<typeof CallToolResultSchema>;
 export type ReadResourceResult = v.InferInput<typeof ReadResourceResultSchema>;
 export type GetPromptResult = v.InferInput<typeof GetPromptResultSchema>;
 export type CompleteResult = v.InferInput<typeof CompleteResultSchema>;
+export type CreateMessageRequest = v.InferInput<typeof CreateMessageRequestSchema>;
+export type CreateMessageResult = v.InferInput<typeof CreateMessageResultSchema>;
+export type ModelPreferences = v.InferInput<typeof ModelPreferencesSchema>;
+export type SamplingMessage = v.InferInput<typeof SamplingMessageSchema>;
+export type ModelHint = v.InferInput<typeof ModelHintSchema>;
+export type JSONRPCRequest = v.InferInput<typeof JSONRPCRequestSchema>;
+export type JSONRPCResponse = v.InferInput<typeof JSONRPCResponseSchema>;
 import * as v from 'valibot';

package/src/validation/index.js

@@ -167,6 +167,115 @@ export const PromptMessageSchema = v.looseObject({
 	content: ContentBlockSchema,
 });
 
+/**
+ * A model hint for sampling requests.
+ */
+export const ModelHintSchema = v.looseObject({
+	/**
+	 * Optional name of the model.
+	 */
+	name: v.optional(v.string()),
+});
+
+/**
+ * A sampling message used in sampling requests.
+ */
+export const SamplingMessageSchema = v.looseObject({
+	role: v.picklist(['user', 'assistant']),
+	content: ContentBlockSchema,
+});
+
+/**
+ * Model preferences for sampling requests.
+ */
+export const ModelPreferencesSchema = v.looseObject({
+	/**
+	 * Optional hints for which model to use, in order of preference.
+	 */
+	hints: v.optional(v.array(ModelHintSchema)),
+	/**
+	 * Priority for cost considerations (0-1, where 1 is highest priority).
+	 */
+	costPriority: v.optional(v.number()),
+	/**
+	 * Priority for speed considerations (0-1, where 1 is highest priority).
+	 */
+	speedPriority: v.optional(v.number()),
+	/**
+	 * Priority for intelligence considerations (0-1, where 1 is highest priority).
+	 */
+	intelligencePriority: v.optional(v.number()),
+});
+
+/**
+ * Request for sampling/createMessage.
+ */
+export const CreateMessageRequestSchema = v.looseObject({
+	/**
+	 * The messages to be processed.
+	 */
+	messages: v.array(SamplingMessageSchema),
+	/**
+	 * Optional system prompt to provide context.
+	 */
+	systemPrompt: v.optional(v.string()),
+	/**
+	 * Optional context inclusion preference.
+	 */
+	includeContext: v.optional(
+		v.picklist(['none', 'thisServer', 'allServers']),
+	),
+	/**
+	 * Optional temperature for generation.
+	 */
+	temperature: v.optional(v.number()),
+	/**
+	 * Maximum number of tokens to generate.
+	 */
+	maxTokens: v.pipe(v.number(), v.integer(), v.minValue(1)),
+	/**
+	 * Optional stop sequences.
+	 */
+	stopSequences: v.optional(v.array(v.string())),
+	/**
+	 * Optional metadata for the request.
+	 */
+	metadata: v.optional(v.looseObject({})),
+	/**
+	 * Optional model preferences for the request.
+	 */
+	modelPreferences: v.optional(ModelPreferencesSchema),
+});
+
+/**
+ * Response for sampling/createMessage.
+ */
+export const CreateMessageResultSchema = v.looseObject({
+	/**
+	 * The model that generated the message.
+	 */
+	model: v.string(),
+	/**
+	 * Optional stop reason.
+	 */
+	stopReason: v.optional(
+		v.union([
+			v.literal('endTurn'),
+			v.literal('stopSequence'),
+			v.literal('maxTokens'),
+			v.string(),
+		]),
+	),
+	/**
+	 * The role of the generated message.
+	 */
+	role: v.picklist(['user', 'assistant']),
+	/**
+	 * The content of the generated message.
+	 */
+	content: ContentBlockSchema,
+});
+
 /**
  * The server's response to a tool call.
  */
@@ -231,6 +340,29 @@ export const CompleteResultSchema = v.looseObject({
 	_meta: v.optional(v.looseObject({})),
 });
 
+export const ClientCapabilitiesSchema = v.looseObject({
+	roots: v.optional(
+		v.looseObject({
+			listChanged: v.optional(v.boolean()),
+		}),
+	),
+	sampling: v.optional(v.looseObject({})),
+	elicitation: v.optional(v.looseObject({})),
+});
+
+export const InitializeRequestSchema = v.looseObject({
+	protocolVersion: v.string(),
+	capabilities: ClientCapabilitiesSchema,
+});
+
+/**
+ * @typedef {v.InferInput<typeof ClientCapabilitiesSchema>} ClientCapabilities
+ */
+
+/**
+ * @typedef {v.InferInput<typeof InitializeRequestSchema>} InitializeRequest
+ */
+
 /**
  * @typedef {v.InferInput<typeof CallToolResultSchema>} CallToolResult
  */
@@ -246,3 +378,71 @@ export const CompleteResultSchema = v.looseObject({
 /**
  * @typedef {v.InferInput<typeof CompleteResultSchema>} CompleteResult
  */
+
+/**
+ * @typedef {v.InferInput<typeof CreateMessageRequestSchema>} CreateMessageRequest
+ */
+
+/**
+ * @typedef {v.InferInput<typeof CreateMessageResultSchema>} CreateMessageResult
+ */
+
+/**
+ * @typedef {v.InferInput<typeof ModelPreferencesSchema>} ModelPreferences
+ */
+
+/**
+ * @typedef {v.InferInput<typeof SamplingMessageSchema>} SamplingMessage
+ */
+
+/**
+ * @typedef {v.InferInput<typeof ModelHintSchema>} ModelHint
+ */
+
+/**
+ * JSON-RPC 2.0 Request
+ */
+export const JSONRPCRequestSchema = v.looseObject({
+	jsonrpc: v.literal('2.0'),
+	method: v.string(),
+	params: v.optional(v.union([v.array(v.unknown()), v.looseObject({})])),
+	id: v.optional(v.union([v.string(), v.number(), v.null()])),
+});
+
+/**
+ * JSON-RPC 2.0 Response Success
+ */
+export const JSONRPCResponseSuccessSchema = v.looseObject({
+	jsonrpc: v.literal('2.0'),
+	result: v.unknown(),
+	id: v.union([v.string(), v.number(), v.null()]),
+});
+
+/**
+ * JSON-RPC 2.0 Response Error
+ */
+export const JSONRPCResponseErrorSchema = v.looseObject({
+	jsonrpc: v.literal('2.0'),
+	error: v.looseObject({
+		code: v.number(),
+		message: v.string(),
+		data: v.optional(v.unknown()),
+	}),
+	id: v.union([v.string(), v.number(), v.null()]),
+});
+
+/**
+ * JSON-RPC 2.0 Response (Success or Error)
+ */
+export const JSONRPCResponseSchema = v.union([
+	JSONRPCResponseSuccessSchema,
+	JSONRPCResponseErrorSchema,
+]);
+
+/**
+ * @typedef {v.InferInput<typeof JSONRPCRequestSchema>} JSONRPCRequest
+ */
+
+/**
+ * @typedef {v.InferInput<typeof JSONRPCResponseSchema>} JSONRPCResponse
+ */