tmcp 1.13.0 → 1.15.0

package/package.json

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

package/src/index.js

@@ -4,8 +4,8 @@
  * @import SqidsType from "sqids";
  * @import { JSONRPCRequest, JSONRPCParams } from "json-rpc-2.0";
  * @import { ExtractURITemplateVariables } from "./internal/uri-template.js";
- * @import { CallToolResult, ReadResourceResult, GetPromptResult, ClientCapabilities as ClientCapabilitiesType, JSONRPCRequest as JSONRPCRequestType, JSONRPCResponse, CreateMessageRequestParams, CreateMessageResult, Resource, LoggingLevel, ToolAnnotations, ClientInfo, ElicitResult } from "./validation/index.js";
- * @import { Tool, Completion, Prompt, StoredResource, ServerOptions, ServerInfo, SubscriptionsKeys, ChangedArgs, McpEvents } from "./internal/internal.js";
+ * @import { CallToolResult, ReadResourceResult, GetPromptResult, ServerInfo, ClientCapabilities as ClientCapabilitiesType, JSONRPCRequest as JSONRPCRequestType, JSONRPCResponse, CreateMessageRequestParams, CreateMessageResult, Resource, LoggingLevel, ToolAnnotations, ClientInfo, ElicitResult, Icons } 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';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -24,6 +24,7 @@ import {
 	McpError,
 	ReadResourceResultSchema,
 	ElicitResultSchema,
+	JSONRPCErrorSchema,
 } from './validation/index.js';
 import {
 	get_supported_versions,
@@ -229,11 +230,6 @@ export class McpServer {
 					}),
 				);
 
-				// Trigger initial roots request if client supports it
-				if (validated_initialize.capabilities?.roots) {
-					this.#refresh_roots();
-				}
-
 				// Return server response with negotiated version and capabilities
 				return {
 					protocolVersion: negotiated_version,
@@ -394,7 +390,7 @@ export class McpServer {
 							name,
 							title: tool.title || tool.description,
 							description: tool.description,
-
+							icons: tool.icons,
 							inputSchema: tool.schema
 								? await this.#options.adapter.toJsonSchema(
 										tool.schema,
@@ -511,6 +507,7 @@ export class McpServer {
 						return {
 							name,
 							title: prompt.title || prompt.description,
+							icons: prompt.icons,
 							description: prompt.description,
 							arguments: keys.map((key) => {
 								const property =
@@ -602,8 +599,10 @@ export class McpServer {
 			const all_resources = [];
 
 			// Add static resources
-			for (const [uri, { description, name, title, ...resource }] of this
-				.#resources) {
+			for (const [
+				uri,
+				{ description, name, title, icons, ...resource },
+			] of this.#resources) {
 				if (!resource.template) {
 					if (
 						resource.enabled != null &&
@@ -615,6 +614,7 @@ export class McpServer {
 						title: title || description,
 						description,
 						uri,
+						icons,
 					});
 				} else if (resource.list_resources) {
 					if (
@@ -655,7 +655,14 @@ export class McpServer {
 						[...this.#resources].map(
 							async ([
 								uri,
-								{ description, name, title, template, enabled },
+								{
+									description,
+									name,
+									title,
+									template,
+									icons,
+									enabled,
+								},
 							]) => {
 								if (!template) return null;
 								if (
@@ -665,6 +672,7 @@ export class McpServer {
 									return null;
 								return {
 									name,
+									icons,
 									title: title || description,
 									description,
 									uriTemplate: uri,
@@ -789,7 +797,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 }} options
+	 * @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 {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(
@@ -801,6 +809,7 @@ export class McpServer {
 			outputSchema,
 			annotations,
 			enabled,
+			icons,
 		},
 		execute,
 	) {
@@ -813,6 +822,7 @@ export class McpServer {
 			outputSchema,
 			execute,
 			annotations,
+			icons,
 		});
 	}
 	/**
@@ -822,10 +832,13 @@ export class McpServer {
 	 * A prompt can also have a schema that defines the input it expects, the user will be prompted to enter the inputs you request. It can also have a complete function
 	 * for each input that will be used to provide completions for the user.
 	 * @template {StandardSchema | undefined} [TSchema=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; complete?: NoInfer<TSchema extends undefined ? never : Partial<Record<keyof (StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>), Completion>>> }} options
+	 * @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; complete?: NoInfer<TSchema extends undefined ? never : Partial<Record<keyof (StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>), Completion>>> } & Icons} options
 	 * @param {TSchema extends undefined ? (()=>Promise<GetPromptResult> | GetPromptResult) : (input: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>) => Promise<GetPromptResult> | GetPromptResult} execute
 	 */
-	prompt({ name, description, title, schema, complete, enabled }, execute) {
+	prompt(
+		{ name, description, title, schema, complete, enabled, icons },
+		execute,
+	) {
 		if (complete) {
 			this.#completions['ref/prompt'].set(name, complete);
 		}
@@ -836,6 +849,7 @@ export class McpServer {
 			schema,
 			execute,
 			enabled,
+			icons,
 		});
 	}
 	/**
@@ -855,10 +869,10 @@ export class McpServer {
 	/**
 	 * Add a resource to the server. Resources are added manually to the context by the user to provide the LLM with additional context.
 	 * Use the description and title to help the user to understand what the resource is.
-	 * @param {{ name: string; description: string; title?: string; uri: string, enabled?: ()=>boolean | Promise<boolean>; }} options
+	 * @param {{ name: string; description: string; title?: string; uri: string, enabled?: ()=>boolean | Promise<boolean>; } & Icons} options
 	 * @param {(uri: string) => Promise<ReadResourceResult> | ReadResourceResult} execute
 	 */
-	resource({ name, description, title, uri, enabled }, execute) {
+	resource({ name, description, title, uri, enabled, icons }, execute) {
 		this.#resource({
 			name,
 			description,
@@ -866,6 +880,7 @@ export class McpServer {
 			uri,
 			execute,
 			enabled,
+			icons,
 			template: false,
 		});
 	}
@@ -877,7 +892,7 @@ export class McpServer {
 	 * Use the description and title to help the user to understand what the resource is.
 	 * @template {string} TUri
 	 * @template {ExtractURITemplateVariables<TUri>} TVariables
-	 * @param {{ name: string; description: string; title?: string; enabled?: ()=>boolean | Promise<boolean>; uri: TUri; complete?: NoInfer<TVariables extends never ? never : Partial<Record<TVariables, Completion>>>; list?: () => Promise<Array<Resource>> | Array<Resource> }} options
+	 * @param {{ name: string; description: string; title?: string; enabled?: ()=>boolean | Promise<boolean>; uri: TUri; complete?: NoInfer<TVariables extends never ? never : Partial<Record<TVariables, Completion>>>; list?: () => Promise<Array<Resource>> | Array<Resource> } & Icons} options
 	 * @param {(uri: string, params: Record<TVariables, string | string[]>) => Promise<ReadResourceResult> | ReadResourceResult} execute
 	 */
 	template(
@@ -889,6 +904,7 @@ export class McpServer {
 			complete,
 			list: list_resources,
 			enabled,
+			icons,
 		},
 		execute,
 	) {
@@ -900,6 +916,7 @@ export class McpServer {
 			uri,
 			execute,
 			complete,
+			icons,
 			list_resources,
 			template: true,
 		});
@@ -942,7 +959,10 @@ export class McpServer {
 			);
 		}
 		// It's a response - handle with client
-		const validated_response = v.parse(JSONRPCResponseSchema, message);
+		const validated_response = v.parse(
+			v.union([JSONRPCResponseSchema, JSONRPCErrorSchema]),
+			message,
+		);
 		this.#lazyily_create_client();
 		return this.#ctx_storage.run(ctx ?? {}, async () =>
 			this.#client?.receive(validated_response),

package/src/internal/internal.d.ts

@@ -10,7 +10,8 @@ import {
 	Resource,
 	ServerCapabilities,
 	LoggingLevel,
-	ToolAnnotations
+	ToolAnnotations,
+	Icons
 } from '../validation/index.js';
 
 export type Tool<TSchema extends StandardSchemaV1 = StandardSchemaV1<any>, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1<any>> = {
@@ -23,7 +24,7 @@ export type Tool<TSchema extends StandardSchemaV1 = StandardSchemaV1<any>, TOutp
 	execute: (
 		input?: StandardSchemaV1.InferInput<TSchema>,
 	) => Promise<CallToolResult> | CallToolResult;
-};
+} & Icons;
 
 export type Completion = (
 	query: string,
@@ -38,7 +39,7 @@ export type Prompt<TSchema extends StandardSchemaV1 = StandardSchemaV1<any>> = {
 	execute: (
 		input?: StandardSchemaV1.InferInput<TSchema>,
 	) => Promise<GetPromptResult> | GetPromptResult;
-};
+} & Icons;
 
 export type StoredResource =
 	| {
@@ -54,7 +55,7 @@ export type StoredResource =
 				uri: string,
 				params: Record<string, string | string[]>,
 			) => Promise<ReadResourceResult> | ReadResourceResult;
-	  }
+	  } & Icons
 	| {
 			description: string;
 			name: string;
@@ -64,7 +65,7 @@ export type StoredResource =
 			execute: (
 				uri: string,
 			) => Promise<ReadResourceResult> | ReadResourceResult;
-	  };
+	  } & Icons;
 
 export type ServerOptions<TSchema extends StandardSchemaV1 | undefined> = {
 	capabilities?: ServerCapabilities;
@@ -79,12 +80,6 @@ export type ServerOptions<TSchema extends StandardSchemaV1 | undefined> = {
 	}
 };
 
-export type ServerInfo = {
-	name: string;
-	version: string;
-	description: string;
-};
-
 export type ChangedArgs = {
 	'resource': [id: string];
 	'tools': [];

package/src/types/index.d.ts

@@ -25,7 +25,13 @@ declare module 'tmcp' {
 		 * 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.
 		 */
 		currentClientInfo(): {
+			icons?: {
+				src: string;
+				mimeType?: string | undefined;
+				sizes?: string[] | undefined;
+			}[] | undefined;
 			version: string;
+			websiteUrl?: string | undefined;
 			name: string;
 			title?: string | undefined;
 		} | undefined;
@@ -48,7 +54,7 @@ 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, }: {
+		tool<TSchema extends StandardSchema | undefined = undefined, TOutputSchema extends StandardSchema | undefined = undefined>({ name, description, title, schema, outputSchema, annotations, enabled, icons, }: {
 			name: string;
 			description: string;
 			title?: string;
@@ -56,7 +62,7 @@ declare module 'tmcp' {
 			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;
-		}, execute: 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>>)): void;
+		} & Icons, execute: 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>>)): void;
 		/**
 		 * Add a prompt to the server. Prompts are used to provide the user with pre-defined messages that adds context to the LLM.
 		 * Use the description and title to help the user to understand what the prompt does and when to use it.
@@ -64,25 +70,25 @@ declare module 'tmcp' {
 		 * A prompt can also have a schema that defines the input it expects, the user will be prompted to enter the inputs you request. It can also have a complete function
 		 * for each input that will be used to provide completions for the user.
 		 * */
-		prompt<TSchema extends StandardSchema | undefined = undefined>({ name, description, title, schema, complete, enabled }: {
+		prompt<TSchema extends StandardSchema | undefined = undefined>({ name, description, title, schema, complete, enabled, icons }: {
 			name: string;
 			description: string;
 			title?: string;
 			enabled?: () => boolean | Promise<boolean>;
 			schema?: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema> extends Record<string, unknown> ? TSchema : never;
 			complete?: NoInfer<TSchema extends undefined ? never : Partial<Record<keyof StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>, Completion>>>;
-		}, execute: TSchema extends undefined ? (() => Promise<GetPromptResult> | GetPromptResult) : (input: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>) => Promise<GetPromptResult> | GetPromptResult): void;
+		} & Icons, execute: TSchema extends undefined ? (() => Promise<GetPromptResult> | GetPromptResult) : (input: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>) => Promise<GetPromptResult> | GetPromptResult): void;
 		/**
 		 * Add a resource to the server. Resources are added manually to the context by the user to provide the LLM with additional context.
 		 * Use the description and title to help the user to understand what the resource is.
 		 * */
-		resource({ name, description, title, uri, enabled }: {
+		resource({ name, description, title, uri, enabled, icons }: {
 			name: string;
 			description: string;
 			title?: string;
 			uri: string;
 			enabled?: () => boolean | Promise<boolean>;
-		}, execute: (uri: string) => Promise<ReadResourceResult> | ReadResourceResult): void;
+		} & Icons, execute: (uri: string) => Promise<ReadResourceResult> | ReadResourceResult): void;
 		/**
 		 * Add a resource template to the server. Resources are added manually to the context by the user to provide the LLM with additional context.
 		 * Resource templates are used to create resources dynamically based on a URI template. The URI template should be a valid URI template as defined in RFC 6570.
@@ -90,7 +96,7 @@ declare module 'tmcp' {
 		 * be invoked to provide completions for the template variables to the user.
 		 * Use the description and title to help the user to understand what the resource is.
 		 * */
-		template<TUri extends string, TVariables extends ExtractURITemplateVariables<TUri>>({ name, description, title, uri, complete, list: list_resources, enabled, }: {
+		template<TUri extends string, TVariables extends ExtractURITemplateVariables<TUri>>({ name, description, title, uri, complete, list: list_resources, enabled, icons, }: {
 			name: string;
 			description: string;
 			title?: string;
@@ -98,7 +104,7 @@ declare module 'tmcp' {
 			uri: TUri;
 			complete?: NoInfer<TVariables extends never ? never : Partial<Record<TVariables, Completion>>>;
 			list?: () => Promise<Array<Resource>> | Array<Resource>;
-		}, execute: (uri: string, params: Record<TVariables, string | string[]>) => Promise<ReadResourceResult> | ReadResourceResult): void;
+		} & Icons, execute: (uri: string, params: Record<TVariables, string | string[]>) => Promise<ReadResourceResult> | ReadResourceResult): void;
 		/**
 		 * The main function that receive a JSONRpc message and either dispatch a `send` event or process the request.
 		 *
@@ -198,12 +204,6 @@ declare module 'tmcp' {
 		}
 	};
 
-	type ServerInfo = {
-		name: string;
-		version: string;
-		description: string;
-	};
-
 	type ChangedArgs = {
 		'resource': [id: string];
 		'tools': [];
@@ -234,6 +234,82 @@ declare module 'tmcp' {
 			readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
 		}, undefined>;
 	}, undefined>;
+	const IconsSchema: v.ObjectSchema<{
+		/**
+		 * Optional set of sized icons that the client can display in a user interface.
+		 *
+		 * Clients that support rendering icons MUST support at least the following MIME types:
+		 * - `image/png` - PNG images (safe, universal compatibility)
+		 * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility)
+		 *
+		 * Clients that support rendering icons SHOULD also support:
+		 * - `image/svg+xml` - SVG images (scalable but requires security precautions)
+		 * - `image/webp` - WebP images (modern, efficient format)
+		 */
+		readonly icons: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+			/**
+			 * URL or data URI for the icon.
+			 */
+			readonly src: v.StringSchema<undefined>;
+			/**
+			 * Optional MIME type for the icon.
+			 */
+			readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+			/**
+			 * Optional array of strings that specify sizes at which the icon can be used.
+			 * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
+			 *
+			 * If not provided, the client should assume that the icon can be used at any size.
+			 */
+			readonly sizes: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+		}, undefined>, undefined>, undefined>;
+	}, undefined>;
+	/**
+	 * Describes the name and version of an MCP implementation.
+	 */
+	const ImplementationSchema: v.ObjectSchema<{
+		/**
+		 * Optional set of sized icons that the client can display in a user interface.
+		 *
+		 * Clients that support rendering icons MUST support at least the following MIME types:
+		 * - `image/png` - PNG images (safe, universal compatibility)
+		 * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility)
+		 *
+		 * Clients that support rendering icons SHOULD also support:
+		 * - `image/svg+xml` - SVG images (scalable but requires security precautions)
+		 * - `image/webp` - WebP images (modern, efficient format)
+		 */
+		readonly icons: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+			/**
+			 * URL or data URI for the icon.
+			 */
+			readonly src: v.StringSchema<undefined>;
+			/**
+			 * Optional MIME type for the icon.
+			 */
+			readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+			/**
+			 * Optional array of strings that specify sizes at which the icon can be used.
+			 * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
+			 *
+			 * If not provided, the client should assume that the icon can be used at any size.
+			 */
+			readonly sizes: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+		}, undefined>, undefined>, undefined>;
+		readonly version: v.StringSchema<undefined>;
+		readonly websiteUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+		/** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
+		readonly name: v.StringSchema<undefined>;
+		/**
+		 * Intended for UI and end-user contexts — optimized to be human-readable and easily understood,
+		 * even by those unfamiliar with domain-specific terminology.
+		 *
+		 * If not provided, the name should be used for display (except for Tool,
+		 * where `annotations.title` should be given precedence over using `name`,
+		 * if present).
+		 */
+		readonly title: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+	}, undefined>;
 	/**
 	 * Capabilities a client may support. Known capabilities are defined here, in this schema, but this is not a closed set: any client can define its own, additional capabilities.
 	 */
@@ -289,7 +365,36 @@ declare module 'tmcp' {
 			}, undefined>, undefined>;
 		}, undefined>;
 		readonly clientInfo: v.ObjectSchema<{
+			/**
+			 * Optional set of sized icons that the client can display in a user interface.
+			 *
+			 * Clients that support rendering icons MUST support at least the following MIME types:
+			 * - `image/png` - PNG images (safe, universal compatibility)
+			 * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility)
+			 *
+			 * Clients that support rendering icons SHOULD also support:
+			 * - `image/svg+xml` - SVG images (scalable but requires security precautions)
+			 * - `image/webp` - WebP images (modern, efficient format)
+			 */
+			readonly icons: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+				/**
+				 * URL or data URI for the icon.
+				 */
+				readonly src: v.StringSchema<undefined>;
+				/**
+				 * Optional MIME type for the icon.
+				 */
+				readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+				/**
+				 * Optional array of strings that specify sizes at which the icon can be used.
+				 * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
+				 *
+				 * If not provided, the client should assume that the icon can be used at any size.
+				 */
+				readonly sizes: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+			}, undefined>, undefined>, undefined>;
 			readonly version: v.StringSchema<undefined>;
+			readonly websiteUrl: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
 			/** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
 			readonly name: v.StringSchema<undefined>;
 			/**
@@ -361,6 +466,34 @@ declare module 'tmcp' {
 	 * A known resource that the server is capable of reading.
 	 */
 	const ResourceSchema: v.ObjectSchema<{
+		/**
+		 * Optional set of sized icons that the client can display in a user interface.
+		 *
+		 * Clients that support rendering icons MUST support at least the following MIME types:
+		 * - `image/png` - PNG images (safe, universal compatibility)
+		 * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility)
+		 *
+		 * Clients that support rendering icons SHOULD also support:
+		 * - `image/svg+xml` - SVG images (scalable but requires security precautions)
+		 * - `image/webp` - WebP images (modern, efficient format)
+		 */
+		readonly icons: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+			/**
+			 * URL or data URI for the icon.
+			 */
+			readonly src: v.StringSchema<undefined>;
+			/**
+			 * Optional MIME type for the icon.
+			 */
+			readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+			/**
+			 * Optional array of strings that specify sizes at which the icon can be used.
+			 * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
+			 *
+			 * If not provided, the client should assume that the icon can be used at any size.
+			 */
+			readonly sizes: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+		}, undefined>, undefined>, undefined>;
 		/**
 		 * The URI of this resource.
 		 */
@@ -492,6 +625,34 @@ declare module 'tmcp' {
 				readonly _meta: v.OptionalSchema<v.ObjectSchema<{}, undefined>, undefined>;
 			}, undefined>, v.ObjectSchema<{
 				readonly type: v.LiteralSchema<"resource_link", undefined>;
+				/**
+				 * Optional set of sized icons that the client can display in a user interface.
+				 *
+				 * Clients that support rendering icons MUST support at least the following MIME types:
+				 * - `image/png` - PNG images (safe, universal compatibility)
+				 * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility)
+				 *
+				 * Clients that support rendering icons SHOULD also support:
+				 * - `image/svg+xml` - SVG images (scalable but requires security precautions)
+				 * - `image/webp` - WebP images (modern, efficient format)
+				 */
+				readonly icons: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+					/**
+					 * URL or data URI for the icon.
+					 */
+					readonly src: v.StringSchema<undefined>;
+					/**
+					 * Optional MIME type for the icon.
+					 */
+					readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+					/**
+					 * Optional array of strings that specify sizes at which the icon can be used.
+					 * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
+					 *
+					 * If not provided, the client should assume that the icon can be used at any size.
+					 */
+					readonly sizes: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+				}, undefined>, undefined>, undefined>;
 				/**
 				 * The URI of this resource.
 				 */
@@ -676,6 +837,34 @@ declare module 'tmcp' {
 			readonly _meta: v.OptionalSchema<v.ObjectSchema<{}, undefined>, undefined>;
 		}, undefined>, v.ObjectSchema<{
 			readonly type: v.LiteralSchema<"resource_link", undefined>;
+			/**
+			 * Optional set of sized icons that the client can display in a user interface.
+			 *
+			 * Clients that support rendering icons MUST support at least the following MIME types:
+			 * - `image/png` - PNG images (safe, universal compatibility)
+			 * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility)
+			 *
+			 * Clients that support rendering icons SHOULD also support:
+			 * - `image/svg+xml` - SVG images (scalable but requires security precautions)
+			 * - `image/webp` - WebP images (modern, efficient format)
+			 */
+			readonly icons: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+				/**
+				 * URL or data URI for the icon.
+				 */
+				readonly src: v.StringSchema<undefined>;
+				/**
+				 * Optional MIME type for the icon.
+				 */
+				readonly mimeType: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+				/**
+				 * Optional array of strings that specify sizes at which the icon can be used.
+				 * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
+				 *
+				 * If not provided, the client should assume that the icon can be used at any size.
+				 */
+				readonly sizes: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+			}, undefined>, undefined>, undefined>;
 			/**
 			 * The URI of this resource.
 			 */
@@ -982,8 +1171,12 @@ declare module 'tmcp' {
 		 */
 		readonly _meta: v.OptionalSchema<v.LooseObjectSchema<{}, undefined>, undefined>;
 	}, undefined>;
+	type Icons = v.InferInput<typeof IconsSchema>;
 	type ClientCapabilities_1 = v.InferInput<typeof ClientCapabilitiesSchema>;
 	type ServerCapabilities = v.InferInput<typeof ServerCapabilitiesSchema>;
+	type ServerInfo = v.InferInput<typeof ImplementationSchema> & {
+		description?: string;
+	};
 	type InitializeRequestParams = v.InferInput<typeof InitializeRequestParamsSchema>;
 	type CallToolResult<TStructuredContent extends Record<string, unknown> | undefined> = Omit<v.InferInput<typeof CallToolResultSchema>, "structuredContent" | "isError"> & (undefined extends TStructuredContent ? {
 		structuredContent?: undefined;

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

@@ -6,10 +6,11 @@
 		"ClientCapabilities",
 		"Completion",
 		"ServerOptions",
-		"ServerInfo",
 		"ChangedArgs",
 		"McpEvents",
 		"JSONRPCResponseSchema",
+		"IconsSchema",
+		"ImplementationSchema",
 		"ClientCapabilitiesSchema",
 		"InitializeRequestParamsSchema",
 		"ServerCapabilitiesSchema",
@@ -23,7 +24,9 @@
 		"CreateMessageResultSchema",
 		"ElicitResultSchema",
 		"CompleteResultSchema",
+		"Icons",
 		"ServerCapabilities",
+		"ServerInfo",
 		"InitializeRequestParams",
 		"ReadResourceResult",
 		"GetPromptResult",
@@ -57,6 +60,6 @@
 		null,
 		null
 	],
-	"mappings": ";;;;;cAsGaA,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aCi2CsCC,kBAAkBA;MC56ClEC,UAAUA;;;;;MAyCVC,aAAaA;;;;;;;;;;;;;MAabC,UAAUA;;;;;;MAMVC,WAAWA;;;;;;;MAaXC,SAASA;;;;;;;;;;;;ODARC,qBAAqBA;;;;;;;;;;;;;;OAuGrBC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;OA6BxBC,6BAA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuB7BC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmMxBC,cAAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4GdC,wBAAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8PxBC,qBAAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BrBC,qBAAqBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2GrBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoEpBC,kBAAkBA;OAuGlBC,gCAAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8ChCC,yBAAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6GzBC,kBAAkBA;;;;;;;;;;;;;;;;;;OAkFlBC,oBAAoBA;;;;;;;;;;;;;;;;;;;;;;MA8H2BC,kBAAkBA;MASbC,uBAAuBA;;;;;;;;;;;MAO5BC,kBAAkBA;MAGrBC,eAAeA;MAGhBC,cAAcA;MAGFC,0BAA0BA;MAGjCC,mBAAmBA;MAY9BC,QAAQA;MAMDC,eAAeA;MAGlBC,YAAYA;MAGTC,eAAeA;MAGlBC,YAAYA;;MEhgD7DC,IAAIA;;;;;;;MAOJC,cAAcA;;;;;;;MAOdC,cAAcA;;;;;MAKdC,qBAAqBA;;;;;;;;;;;;;;;;;MAiBrBC,4BAA4BA;;;;;;MAMrBC,2BAA2BA;;;;;;;OCjC1BC,iBAAiBA;;;;;;;;;;;;;;;;cAAjBA,iBAAiBA",
+	"mappings": ";;;;;cAuGaA,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aC84CsCC,kBAAkBA;MCz9ClEC,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;;;;;;;;;;;;;;;;;;;;;MA2HcC,KAAKA;;MAMQC,kBAAkBA;MAOKC,UAAUA;;;MAG5BC,uBAAuBA;;;;;;;;;;;MAO5BC,kBAAkBA;MAGrBC,eAAeA;MAGhBC,cAAcA;MAGFC,0BAA0BA;MAGjCC,mBAAmBA;MAY9BC,QAAQA;MAMDC,eAAeA;MAGlBC,YAAYA;MAGTC,eAAeA;MAGlBC,YAAYA;;ME/iD7DC,IAAIA;;;;;;;MAOJC,cAAcA;;;;;;;MAOdC,cAAcA;;;;;MAKdC,qBAAqBA;;;;;;;;;;;;;;;;;MAiBrBC,4BAA4BA;;;;;;MAMrBC,2BAA2BA;;;;;;;OCjC1BC,iBAAiBA;;;;;;;;;;;;;;;;cAAjBA,iBAAiBA",
 	"ignoreList": []
 }

package/src/validation/index.js

@@ -188,6 +188,43 @@ export const BaseMetadataSchema = v.object({
 	 */
 	title: v.optional(v.string()),
 });
+
+/**
+ * Icon schema for use in tools, prompts, resources, and implementations.
+ */
+export const IconSchema = v.object({
+	/**
+	 * URL or data URI for the icon.
+	 */
+	src: v.string(),
+	/**
+	 * Optional MIME type for the icon.
+	 */
+	mimeType: v.optional(v.string()),
+	/**
+	 * Optional array of strings that specify sizes at which the icon can be used.
+	 * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
+	 *
+	 * If not provided, the client should assume that the icon can be used at any size.
+	 */
+	sizes: v.optional(v.array(v.string())),
+});
+
+export const IconsSchema = v.object({
+	/**
+	 * Optional set of sized icons that the client can display in a user interface.
+	 *
+	 * Clients that support rendering icons MUST support at least the following MIME types:
+	 * - `image/png` - PNG images (safe, universal compatibility)
+	 * - `image/jpeg` (and `image/jpg`) - JPEG images (safe, universal compatibility)
+	 *
+	 * Clients that support rendering icons SHOULD also support:
+	 * - `image/svg+xml` - SVG images (scalable but requires security precautions)
+	 * - `image/webp` - WebP images (modern, efficient format)
+	 */
+	icons: v.optional(v.array(IconSchema)),
+});
+
 /* Initialization */
 
 /**
@@ -196,6 +233,8 @@ export const BaseMetadataSchema = v.object({
 export const ImplementationSchema = v.object({
 	...BaseMetadataSchema.entries,
 	version: v.string(),
+	websiteUrl: v.optional(v.string()),
+	...IconsSchema.entries,
 });
 
 /**
@@ -473,6 +512,7 @@ export const ResourceSchema = v.object({
 	 * for notes on _meta usage.
 	 */
 	_meta: v.optional(v.object({})),
+	...IconsSchema.entries,
 });
 
 /**
@@ -503,6 +543,7 @@ export const ResourceTemplateSchema = v.object({
 	 * for notes on _meta usage.
 	 */
 	_meta: v.optional(v.object({})),
+	...IconsSchema.entries,
 });
 
 /**
@@ -661,6 +702,7 @@ export const PromptSchema = v.object({
 	 * for notes on _meta usage.
 	 */
 	_meta: v.optional(v.object({})),
+	...IconsSchema.entries,
 });
 
 /**
@@ -925,6 +967,7 @@ export const ToolSchema = v.object({
 	 * for notes on _meta usage.
 	 */
 	_meta: v.optional(v.object({})),
+	...IconsSchema.entries,
 });
 
 /**
@@ -1476,6 +1519,9 @@ export const ServerResultSchema = v.union([
 	ListToolsResultSchema,
 ]);
 
+/**
+ * @typedef {v.InferInput<typeof IconsSchema>} Icons
+ */
 /**
  * @typedef {v.InferInput<typeof ClientCapabilitiesSchema>} ClientCapabilities
  */
@@ -1485,8 +1531,9 @@ export const ServerResultSchema = v.union([
 /**
  * @typedef {v.InferInput<typeof ImplementationSchema>} ClientInfo
  */
+// TODO remove description from ServerInfo on next major...it was never in the protocol
 /**
- * @typedef {v.InferInput<typeof ImplementationSchema>} ServerInfo
+ * @typedef {v.InferInput<typeof ImplementationSchema> & { description?: string }} ServerInfo
  */
 /**
  * @typedef {v.InferInput<typeof InitializeRequestParamsSchema>} InitializeRequestParams