tmcp 1.18.1 → 1.19.1

package/src/index.js

@@ -5,7 +5,8 @@
  * @import { JSONRPCRequest, JSONRPCParams } from "json-rpc-2.0";
  * @import { ExtractURITemplateVariables } from "./internal/uri-template.js";
  * @import { CallToolResult as CallToolResultType, ReadResourceResult as ReadResourceResultType, GetPromptResult as GetPromptResultType, ServerInfo as ServerInfoType, ClientCapabilities as ClientCapabilitiesType, JSONRPCRequest as JSONRPCRequestType, JSONRPCResponse, CreateMessageRequestParams as CreateMessageRequestParamsType, CreateMessageResult as CreateMessageResultType, Resource as ResourceType, LoggingLevel as LoggingLevelType, ToolAnnotations, ClientInfo as ClientInfoType, ElicitResult as ElicitResultType, Icons as IconsType, JSONRPCMessage, InitializeResult as InitializeResultType, ListToolsResult as ListToolsResultType, ListPromptsResult as ListPromptsResultType, ListResourceTemplatesResult as ListResourceTemplatesResultType, ListResourcesResult as ListResourcesResultType, CompleteResult as CompleteResultType } from "./validation/index.js";
- * @import { Tool, Completion, Prompt, StoredResource, ServerOptions, SubscriptionsKeys, ChangedArgs, McpEvents } from "./internal/internal.js";
+ * @import { Tool, Completion, Prompt, StoredResource, ServerOptions, SubscriptionsKeys, ChangedArgs, McpEvents, AllSame, TemplateOptions } from "./internal/internal.js";
+ * @import { CreatedTool, ToolOptions, CreatedPrompt, PromptOptions, CreatedResource, CreatedTemplate, ResourceOptions } from "./internal/internal.js";
  */
 import { JSONRPCClient, JSONRPCServer } from 'json-rpc-2.0';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -667,7 +668,7 @@ export class McpServer {
 			// Add static resources
 			for (const [
 				uri,
-				{ description, name, title, icons, ...resource },
+				{ description, name, title, icons, mimeType, ...resource },
 			] of this.#resources) {
 				if (!resource.template) {
 					if (
@@ -680,6 +681,7 @@ export class McpServer {
 						title: title || description,
 						description,
 						uri,
+						mimeType,
 						icons,
 					});
 				} else if (resource.list_resources) {
@@ -726,6 +728,7 @@ export class McpServer {
 									name,
 									title,
 									template,
+									mimeType,
 									icons,
 									enabled,
 								},
@@ -741,6 +744,7 @@ export class McpServer {
 									icons,
 									title: title || description,
 									description,
+									mimeType,
 									uriTemplate: uri,
 								};
 							},
@@ -860,6 +864,119 @@ export class McpServer {
 		}
 	}
 
+	/**
+	 * Use the `defineTool` utility to create a reusable tool and pass it to this method to add it to the server.
+	 * @template {Array<CreatedTool<any, any>>} T
+	 * @template {T extends Array<CreatedTool<infer TSchema, infer TOutputSchema>> ? AllSame<TSchema, StandardSchema | undefined> extends true ? AllSame<TOutputSchema, StandardSchema | undefined> extends true ? T : never : never : never} U
+	 * @param {T & NoInfer<U>} tools
+	 */
+	tools(tools) {
+		for (const tool of tools) {
+			this.tool(
+				{
+					name: tool.name,
+					description: tool.description,
+					title: tool.title,
+					schema: tool.schema,
+					outputSchema: tool.outputSchema,
+					annotations: tool.annotations,
+					enabled: tool.enabled,
+					icons: tool.icons,
+					_meta: tool._meta,
+				},
+				// @ts-expect-error typescript doesn't know about execute because of an egregious hack to prevent it
+				// from showing in intellisense when declaring a tool inline
+				tool.execute,
+			);
+		}
+	}
+
+	/**
+	 * Use the `definePrompt` utility to create a reusable tool and pass it to this method to add it to the server.
+	 * @template {Array<CreatedPrompt<any>>} T
+	 * @template {T extends Array<CreatedPrompt<infer TSchema>> ? AllSame<TSchema, StandardSchema | undefined> extends true ?  T : never : never} U
+	 * @param {T & NoInfer<U>} prompts
+	 */
+	prompts(prompts) {
+		for (const prompt of prompts) {
+			this.prompt(
+				{
+					name: prompt.name,
+					description: prompt.description,
+					title: prompt.title,
+					schema: prompt.schema,
+					complete: prompt.complete,
+					enabled: prompt.enabled,
+					icons: prompt.icons,
+				},
+				// @ts-expect-error typescript doesn't know about execute because of an egregious hack to prevent it
+				// from showing in intellisense when declaring a tool inline
+				prompt.execute,
+			);
+		}
+	}
+
+	/**
+	 * Use the `defineResource` utility to create a reusable resource and pass it to this method to add it to the server.
+	 *
+	 * @param {CreatedResource[]} resources
+	 */
+	resources(resources) {
+		for (const resource of resources) {
+			this.resource(
+				{
+					name: resource.name,
+					description: resource.description,
+					title: resource.title,
+					uri: resource.uri,
+					mimeType: resource.mimeType,
+					enabled: resource.enabled,
+					icons: resource.icons,
+				},
+				// @ts-expect-error typescript doesn't know about execute because of an egregious hack to prevent it
+				// from showing in intellisense when declaring a tool inline
+				resource.execute,
+			);
+		}
+	}
+
+	/**
+	 * Use the `defineTemplate` utility to create a reusable template and pass it to this method to add it to the server.
+	 *
+	 * @param {CreatedTemplate<any>[]} templates
+	 */
+	templates(templates) {
+		for (const template of templates) {
+			this.template(
+				{
+					name: template.name,
+					description: template.description,
+					title: template.title,
+					uri: template.uri,
+					mimeType: template.mimeType,
+					complete: template.complete,
+					list: template.list,
+					enabled: template.enabled,
+					icons: template.icons,
+				},
+				// @ts-expect-error typescript doesn't know about execute because of an egregious hack to prevent it
+				// from showing in intellisense when declaring a tool inline
+				template.execute,
+			);
+		}
+	}
+
+	/**
+	 * Add a tool to the server. If you want to receive any input you need to provide a schema. The schema needs to be a valid Standard Schema V1 schema and needs to be an Object with the properties you need,
+	 * Use the description and title to help the LLM to understand what the tool does and when to use it. If you provide an outputSchema, you need to return a structuredContent that matches the schema.
+	 *
+	 * 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]
+	 * @overload
+	 * @param {CreatedTool<TSchema, TOutputSchema>} tool_or_options
+	 * @returns {void}
+	 */
 	/**
 	 * Add a tool to the server. If you want to receive any input you need to provide a schema. The schema needs to be a valid Standard Schema V1 schema and needs to be an Object with the properties you need,
 	 * Use the description and title to help the LLM to understand what the tool does and when to use it. If you provide an outputSchema, you need to return a structuredContent that matches the schema.
@@ -867,8 +984,20 @@ 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; _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
+	 * @overload
+	 * @param {ToolOptions<TSchema, TOutputSchema>} tool_or_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
+	 * @returns {void}
+	 * */
+	/**
+	 * Add a tool to the server. If you want to receive any input you need to provide a schema. The schema needs to be a valid Standard Schema V1 schema and needs to be an Object with the properties you need,
+	 * Use the description and title to help the LLM to understand what the tool does and when to use it. If you provide an outputSchema, you need to return a structuredContent that matches the schema.
+	 *
+	 * 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 {CreatedTool<TSchema, TOutputSchema> | ToolOptions<TSchema, TOutputSchema>} tool_or_options
+	 * @param {undefined | 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(
 		{
@@ -881,9 +1010,15 @@ export class McpServer {
 			enabled,
 			icons,
 			_meta,
+			...tool_or_options
 		},
 		execute,
 	) {
+		if ('execute' in tool_or_options) {
+			// @ts-expect-error typescript doesn't know about execute because of an egregious hack to prevent it
+			// from showing in intellisense when declaring a tool inline
+			execute = tool_or_options.execute;
+		}
 		this.#notify_tools_list_changed();
 		this.#tools.set(name, {
 			description,
@@ -891,12 +1026,24 @@ export class McpServer {
 			enabled,
 			schema,
 			outputSchema,
-			execute,
+			execute: /** @type {NonNullable<typeof execute>} */ (execute),
 			annotations,
 			icons,
 			_meta,
 		});
 	}
+
+	/**
+	 * 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.
+	 *
+	 * 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]
+	 * @overload
+	 * @param {CreatedPrompt<TSchema>} prompt_or_options
+	 * @returns {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.
@@ -904,13 +1051,39 @@ 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>>> } & Icons} options
+	 * @overload
+	 * @param {PromptOptions<TSchema>} prompt_or_options
 	 * @param {TSchema extends undefined ? (()=>Promise<GetPromptResult> | GetPromptResult) : (input: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>) => Promise<GetPromptResult> | GetPromptResult} execute
+	 * @returns {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.
+	 *
+	 * 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 {CreatedPrompt<TSchema> | PromptOptions<TSchema>} 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, icons },
+		{
+			name,
+			description,
+			title,
+			schema,
+			complete,
+			enabled,
+			icons,
+			...prompt_or_options
+		},
 		execute,
 	) {
+		if ('execute' in prompt_or_options) {
+			// @ts-expect-error typescript doesn't know about execute because of an egregious hack to prevent it
+			// from showing in intellisense when declaring a tool inline
+			execute = prompt_or_options.execute;
+		}
 		if (complete) {
 			this.#completions['ref/prompt'].set(name, complete);
 		}
@@ -919,7 +1092,7 @@ export class McpServer {
 			description,
 			title,
 			schema,
-			execute,
+			execute: /** @type {NonNullable<typeof execute>} */ (execute),
 			enabled,
 			icons,
 		});
@@ -941,16 +1114,49 @@ 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>; } & Icons} options
+	 * @overload
+	 * @param {CreatedResource} resource_or_options
+	 * @returns {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.
+	 * @overload
+	 * @param {ResourceOptions} resource_or_options
 	 * @param {(uri: string) => Promise<ReadResourceResult> | ReadResourceResult} execute
+	 * @returns {void}
 	 */
-	resource({ name, description, title, uri, enabled, icons }, execute) {
+	/**
+	 * 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 {CreatedResource | ResourceOptions} resource_or_options
+	 * @param {(uri: string) => Promise<ReadResourceResult> | ReadResourceResult} [execute]
+	 */
+	resource(
+		{
+			name,
+			description,
+			title,
+			uri,
+			mimeType,
+			enabled,
+			icons,
+			...resource_or_options
+		},
+		execute,
+	) {
+		if ('execute' in resource_or_options) {
+			// @ts-expect-error typescript doesn't know about execute because of an egregious hack to prevent it
+			// from showing in intellisense when declaring a tool inline
+			execute = resource_or_options.execute;
+		}
 		this.#resource({
 			name,
 			description,
 			title,
 			uri,
-			execute,
+			mimeType,
+			execute: /** @type {NonNullable<typeof execute>} */ (execute),
 			enabled,
 			icons,
 			template: false,
@@ -964,8 +1170,33 @@ 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> } & Icons} options
+	 * @overload
+	 * @param {CreatedTemplate<TUri>} template_or_options
+	 * @returns {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.
+	 * Resource templates can have a list method that returns a list of resources that match the template and a complete method that returns a list of resources given one of the template variables, this method will
+	 * 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 {string} TUri
+	 * @template {ExtractURITemplateVariables<TUri>} TVariables
+	 * @overload
+	 * @param {TemplateOptions<TUri>} template_or_options
 	 * @param {(uri: string, params: Record<TVariables, string | string[]>) => Promise<ReadResourceResult> | ReadResourceResult} execute
+	 * @returns {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.
+	 * Resource templates can have a list method that returns a list of resources that match the template and a complete method that returns a list of resources given one of the template variables, this method will
+	 * 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 {string} TUri
+	 * @template {ExtractURITemplateVariables<TUri>} TVariables
+	 * @param {CreatedTemplate<TUri> | TemplateOptions<TUri>} template_or_options
+	 * @param {(uri: string, params: Record<TVariables, string | string[]>) => Promise<ReadResourceResult> | ReadResourceResult} [execute]
 	 */
 	template(
 		{
@@ -973,20 +1204,28 @@ export class McpServer {
 			description,
 			title,
 			uri,
+			mimeType,
 			complete,
 			list: list_resources,
 			enabled,
 			icons,
+			...template_or_options
 		},
 		execute,
 	) {
+		if ('execute' in template_or_options) {
+			// @ts-expect-error typescript doesn't know about execute because of an egregious hack to prevent it
+			// from showing in intellisense when declaring a tool inline
+			execute = template_or_options.execute;
+		}
 		this.#resource({
 			name,
 			enabled,
 			description,
 			title,
 			uri,
-			execute,
+			mimeType,
+			execute: /** @type {NonNullable<typeof execute>} */ (execute),
 			complete,
 			icons,
 			list_resources,

package/src/internal/internal.d.ts

@@ -13,6 +13,59 @@ import {
 	ToolAnnotations,
 	Icons
 } from '../validation/index.js';
+import { ExtractURITemplateVariables } from './uri-template.js';
+
+declare const created_tool: unique symbol;
+declare const created_prompt: unique symbol;
+declare const created_resource: unique symbol;
+declare const created_template: unique symbol;
+
+export type AllSame<T, U> = [T] extends [U] ? true : false;
+
+export type PromptOptions<TSchema extends StandardSchemaV1 | undefined = undefined> = { 
+	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
+
+export type ToolOptions<TSchema extends StandardSchemaV1 | undefined = undefined, TOutputSchema extends StandardSchemaV1 | undefined = undefined> = {
+	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;
+
+export type ResourceOptions = { 
+	name: string;
+	description: string; 
+	title?: string; 
+	uri: string;
+	mimeType?: string;
+	enabled?: ()=>boolean | Promise<boolean>; 
+} & Icons
+
+export type TemplateOptions<TUri extends string = string, TVariables extends ExtractURITemplateVariables<TUri> = ExtractURITemplateVariables<TUri>> = { 
+	name: string;
+	description: string;
+	title?: string;
+	mimeType?: string;
+	enabled?: ()=>boolean | Promise<boolean>;
+	uri: TUri;
+	complete?: NoInfer<TVariables extends never ? never : Partial<Record<TVariables, Completion>>>;
+	list?: () => Promise<Array<Resource>> | Array<Resource> 
+} & Icons
+
+export type CreatedTool<TSchema extends StandardSchemaV1 | undefined = undefined, TOutputSchema extends StandardSchemaV1 | undefined = undefined> = ToolOptions<TSchema, TOutputSchema> & { [created_tool]: created_tool };
+export type CreatedPrompt<TSchema extends StandardSchemaV1 | undefined = undefined> = PromptOptions<TSchema> & { [created_prompt]: created_prompt };
+export type CreatedResource = ResourceOptions & { [created_resource]: created_resource };
+export type CreatedTemplate<TUri extends string = string> = TemplateOptions<TUri> & { [created_template]: created_template };
 
 export type Tool<TSchema extends StandardSchemaV1 = StandardSchemaV1<any>, TOutputSchema extends StandardSchemaV1 = StandardSchemaV1<any>> = {
 	description: string;
@@ -48,6 +101,7 @@ export type StoredResource =
 			name: string;
 			template: true;
 			title?: string;
+			mimeType?: string;
 			enabled?: () => boolean | Promise<boolean>;
 			list_resources?: () =>
 				| Promise<Array<Resource>>
@@ -62,6 +116,7 @@ export type StoredResource =
 			name: string;
 			template: false;
 			title?: string;
+			mimeType?: string;
 			enabled?: () => boolean | Promise<boolean>;
 			execute: (
 				uri: string,

package/src/prompt.js

@@ -0,0 +1,23 @@
+/**
+ * @import { StandardSchemaV1 } from "@standard-schema/spec";
+ * @import { PromptOptions, CreatedPrompt } from "./internal/internal.js";
+ * @import { GetPromptResult } from "./validation/index.js"
+ */
+
+/**
+ * Add a tool to the server. If you want to receive any input you need to provide a schema. The schema needs to be a valid Standard Schema V1 schema and needs to be an Object with the properties you need,
+ * Use the description and title to help the LLM to understand what the tool does and when to use it. If you provide an outputSchema, you need to return a structuredContent that matches the schema.
+ *
+ * @template {StandardSchemaV1 | undefined} [TSchema=undefined]
+ * @param {PromptOptions<TSchema>} options
+ * @param {TSchema extends undefined ? (()=>Promise<GetPromptResult> | GetPromptResult) : (input: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>) => Promise<GetPromptResult> | GetPromptResult} execute
+ */
+export function definePrompt(options, execute) {
+	// eslint-disable-next-line jsdoc/no-undefined-types
+	return /** @type {CreatedPrompt<TSchema>} */ (
+		/** @type {unknown} */ ({
+			...options,
+			execute,
+		})
+	);
+}

package/src/resource.js

@@ -0,0 +1,20 @@
+/**
+ * @import { ResourceOptions, CreatedResource } from "./internal/internal.js";
+ * @import { ReadResourceResult } from "./validation/index.js";
+ */
+
+/**
+ * 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. The mimeType can be used to indicate the type of content.
+ *
+ * @param {ResourceOptions} options
+ * @param {(uri: string) => Promise<ReadResourceResult> | ReadResourceResult} execute
+ */
+export function defineResource(options, execute) {
+	return /** @type {CreatedResource} */ (
+		/** @type {unknown} */ ({
+			...options,
+			execute,
+		})
+	);
+}

package/src/template.js

@@ -0,0 +1,27 @@
+/* eslint-disable jsdoc/no-undefined-types */
+/**
+ * @import { ExtractURITemplateVariables } from "./internal/uri-template.js";
+ * @import { TemplateOptions, CreatedTemplate } from "./internal/internal.js";
+ * @import { ReadResourceResult } from "./validation/index.js";
+ */
+
+/**
+ * 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.
+ * Resource templates can have a list method that returns a list of resources that match the template and a complete method that returns a list of resources given one of the template variables, this method will
+ * 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. The mimeType can be used to indicate the type of content.
+ *
+ * @template {string} TUri
+ * @template {ExtractURITemplateVariables<TUri>} TVariables
+ * @param {TemplateOptions<TUri>} options
+ * @param {(uri: string, params: Record<TVariables, string | string[]>) => Promise<ReadResourceResult> | ReadResourceResult} execute
+ */
+export function defineTemplate(options, execute) {
+	return /** @type {CreatedTemplate<TUri>} */ (
+		/** @type {unknown} */ ({
+			...options,
+			execute,
+		})
+	);
+}

package/src/tool.js

@@ -0,0 +1,23 @@
+/**
+ * @import { StandardSchemaV1 } from "@standard-schema/spec";
+ * @import { ToolOptions, CreatedTool } from "./internal/internal.js";
+ */
+
+/**
+ * Add a tool to the server. If you want to receive any input you need to provide a schema. The schema needs to be a valid Standard Schema V1 schema and needs to be an Object with the properties you need,
+ * Use the description and title to help the LLM to understand what the tool does and when to use it. If you provide an outputSchema, you need to return a structuredContent that matches the schema.
+ *
+ * @template {StandardSchemaV1 | undefined} [TSchema=undefined]
+ * @template {StandardSchemaV1 | undefined} [TOutputSchema=undefined]
+ * @param {ToolOptions<TSchema, TOutputSchema>} options
+ * @param {TSchema extends undefined ? (()=>Promise<import("./index.js").CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>> | import("./index.js").CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>) : ((input: StandardSchemaV1.InferInput<TSchema extends undefined ? never : TSchema>) => Promise<import("./index.js").CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>> | import("./index.js").CallToolResult<TOutputSchema extends undefined ? undefined : StandardSchemaV1.InferInput<TOutputSchema extends undefined ? never : TOutputSchema>>)} execute
+ */
+export function defineTool(options, execute) {
+	// eslint-disable-next-line jsdoc/no-undefined-types
+	return /** @type {CreatedTool<TSchema, TOutputSchema>} */ (
+		/** @type {unknown} */ ({
+			...options,
+			execute,
+		})
+	);
+}