@modelcontextprotocol/sdk 1.24.3 → 1.25.0

package/dist/esm/types.js

@@ -33,10 +33,14 @@ export const TaskCreationParamsSchema = z.looseObject({
      */
     pollInterval: z.number().optional()
 });
+export const TaskMetadataSchema = z.object({
+    ttl: z.number().optional()
+});
 /**
- * Task association metadata, used to signal which task a message originated from.
+ * Metadata for associating messages with a task.
+ * Include this in the `_meta` field under the key `io.modelcontextprotocol/related-task`.
  */
-export const RelatedTaskMetadataSchema = z.looseObject({
+export const RelatedTaskMetadataSchema = z.object({
     taskId: z.string()
 });
 const RequestMetaSchema = z.looseObject({
@@ -52,53 +56,54 @@ const RequestMetaSchema = z.looseObject({
 /**
  * Common params for any request.
  */
-const BaseRequestParamsSchema = z.looseObject({
-    /**
-     * If specified, the caller is requesting that the receiver create a task to represent the request.
-     * Task creation parameters are now at the top level instead of in _meta.
-     */
-    task: TaskCreationParamsSchema.optional(),
+const BaseRequestParamsSchema = z.object({
     /**
      * See [General fields: `_meta`](/specification/draft/basic/index#meta) for notes on `_meta` usage.
      */
     _meta: RequestMetaSchema.optional()
 });
+/**
+ * Common params for any task-augmented request.
+ */
+export const TaskAugmentedRequestParamsSchema = BaseRequestParamsSchema.extend({
+    /**
+     * If specified, the caller is requesting task-augmented execution for this request.
+     * The request will return a CreateTaskResult immediately, and the actual result can be
+     * retrieved later via tasks/result.
+     *
+     * Task augmentation is subject to capability negotiation - receivers MUST declare support
+     * for task augmentation of specific request types in their capabilities.
+     */
+    task: TaskMetadataSchema.optional()
+});
+/**
+ * Checks if a value is a valid TaskAugmentedRequestParams.
+ * @param value - The value to check.
+ *
+ * @returns True if the value is a valid TaskAugmentedRequestParams, false otherwise.
+ */
+export const isTaskAugmentedRequestParams = (value) => TaskAugmentedRequestParamsSchema.safeParse(value).success;
 export const RequestSchema = z.object({
     method: z.string(),
-    params: BaseRequestParamsSchema.optional()
+    params: BaseRequestParamsSchema.loose().optional()
 });
-const NotificationsParamsSchema = z.looseObject({
+const NotificationsParamsSchema = z.object({
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: z
-        .object({
-        /**
-         * If specified, this notification is related to the provided task.
-         */
-        [RELATED_TASK_META_KEY]: z.optional(RelatedTaskMetadataSchema)
-    })
-        .passthrough()
-        .optional()
+    _meta: RequestMetaSchema.optional()
 });
 export const NotificationSchema = z.object({
     method: z.string(),
-    params: NotificationsParamsSchema.optional()
+    params: NotificationsParamsSchema.loose().optional()
 });
 export const ResultSchema = z.looseObject({
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: z
-        .looseObject({
-        /**
-         * If specified, this result is related to the provided task.
-         */
-        [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
-    })
-        .optional()
+    _meta: RequestMetaSchema.optional()
 });
 /**
  * A uniquely identifying ID for a request in JSON-RPC.
@@ -128,14 +133,14 @@ export const isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safePa
 /**
  * A successful (non-error) response to a request.
  */
-export const JSONRPCResponseSchema = z
+export const JSONRPCResultResponseSchema = z
     .object({
     jsonrpc: z.literal(JSONRPC_VERSION),
     id: RequestIdSchema,
     result: ResultSchema
 })
     .strict();
-export const isJSONRPCResponse = (value) => JSONRPCResponseSchema.safeParse(value).success;
+export const isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success;
 /**
  * Error codes defined by the JSON-RPC specification.
  */
@@ -156,10 +161,10 @@ export var ErrorCode;
 /**
  * A response to a request that indicates an error occurred.
  */
-export const JSONRPCErrorSchema = z
+export const JSONRPCErrorResponseSchema = z
     .object({
     jsonrpc: z.literal(JSONRPC_VERSION),
-    id: RequestIdSchema,
+    id: RequestIdSchema.optional(),
     error: z.object({
         /**
          * The error type that occurred.
@@ -172,12 +177,18 @@ export const JSONRPCErrorSchema = z
         /**
          * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.).
          */
-        data: z.optional(z.unknown())
+        data: z.unknown().optional()
     })
 })
     .strict();
-export const isJSONRPCError = (value) => JSONRPCErrorSchema.safeParse(value).success;
-export const JSONRPCMessageSchema = z.union([JSONRPCRequestSchema, JSONRPCNotificationSchema, JSONRPCResponseSchema, JSONRPCErrorSchema]);
+export const isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
+export const JSONRPCMessageSchema = z.union([
+    JSONRPCRequestSchema,
+    JSONRPCNotificationSchema,
+    JSONRPCResultResponseSchema,
+    JSONRPCErrorResponseSchema
+]);
+export const JSONRPCResponseSchema = z.union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
 /* Empty result */
 /**
  * A response that indicates success but carries no data.
@@ -189,7 +200,7 @@ export const CancelledNotificationParamsSchema = NotificationsParamsSchema.exten
      *
      * This MUST correspond to the ID of a request previously issued in the same direction.
      */
-    requestId: RequestIdSchema,
+    requestId: RequestIdSchema.optional(),
     /**
      * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user.
      */
@@ -228,7 +239,15 @@ export const IconSchema = z.object({
      *
      * If not provided, the client should assume that the icon can be used at any size.
      */
-    sizes: z.array(z.string()).optional()
+    sizes: z.array(z.string()).optional(),
+    /**
+     * Optional specifier for the theme this icon is designed for. `light` indicates
+     * the icon is designed to be used with a light background, and `dark` indicates
+     * the icon is designed to be used with a dark background.
+     *
+     * If not provided, the client should assume the icon can be used with any theme.
+     */
+    theme: z.enum(['light', 'dark']).optional()
 });
 /**
  * Base schema to add `icons` property.
@@ -275,7 +294,15 @@ export const ImplementationSchema = BaseMetadataSchema.extend({
     /**
      * An optional URL of the website for this implementation.
      */
-    websiteUrl: z.string().optional()
+    websiteUrl: z.string().optional(),
+    /**
+     * An optional human-readable description of what this implementation does.
+     *
+     * This can be used by clients or servers to provide context about their purpose
+     * and capabilities. For example, a server might describe the types of resources
+     * or tools it provides, while a client might describe its intended use case.
+     */
+    description: z.string().optional()
 });
 const FormElicitationCapabilitySchema = z.intersection(z.object({
     applyDefaults: z.boolean().optional()
@@ -294,71 +321,67 @@ const ElicitationCapabilitySchema = z.preprocess(value => {
 /**
  * Task capabilities for clients, indicating which request types support task creation.
  */
-export const ClientTasksCapabilitySchema = z
-    .object({
+export const ClientTasksCapabilitySchema = z.looseObject({
     /**
      * Present if the client supports listing tasks.
      */
-    list: z.optional(z.object({}).passthrough()),
+    list: AssertObjectSchema.optional(),
     /**
      * Present if the client supports cancelling tasks.
      */
-    cancel: z.optional(z.object({}).passthrough()),
+    cancel: AssertObjectSchema.optional(),
     /**
      * Capabilities for task creation on specific request types.
      */
-    requests: z.optional(z
-        .object({
+    requests: z
+        .looseObject({
         /**
          * Task support for sampling requests.
          */
-        sampling: z.optional(z
-            .object({
-            createMessage: z.optional(z.object({}).passthrough())
+        sampling: z
+            .looseObject({
+            createMessage: AssertObjectSchema.optional()
         })
-            .passthrough()),
+            .optional(),
         /**
          * Task support for elicitation requests.
          */
-        elicitation: z.optional(z
-            .object({
-            create: z.optional(z.object({}).passthrough())
+        elicitation: z
+            .looseObject({
+            create: AssertObjectSchema.optional()
         })
-            .passthrough())
+            .optional()
     })
-        .passthrough())
-})
-    .passthrough();
+        .optional()
+});
 /**
  * Task capabilities for servers, indicating which request types support task creation.
  */
-export const ServerTasksCapabilitySchema = z
-    .object({
+export const ServerTasksCapabilitySchema = z.looseObject({
     /**
      * Present if the server supports listing tasks.
      */
-    list: z.optional(z.object({}).passthrough()),
+    list: AssertObjectSchema.optional(),
     /**
      * Present if the server supports cancelling tasks.
      */
-    cancel: z.optional(z.object({}).passthrough()),
+    cancel: AssertObjectSchema.optional(),
     /**
      * Capabilities for task creation on specific request types.
      */
-    requests: z.optional(z
-        .object({
+    requests: z
+        .looseObject({
         /**
          * Task support for tool requests.
          */
-        tools: z.optional(z
-            .object({
-            call: z.optional(z.object({}).passthrough())
+        tools: z
+            .looseObject({
+            call: AssertObjectSchema.optional()
         })
-            .passthrough())
+            .optional()
     })
-        .passthrough())
-})
-    .passthrough();
+        .optional()
+});
 /**
  * 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.
  */
@@ -401,7 +424,7 @@ export const ClientCapabilitiesSchema = z.object({
     /**
      * Present if the client supports task creation.
      */
-    tasks: z.optional(ClientTasksCapabilitySchema)
+    tasks: ClientTasksCapabilitySchema.optional()
 });
 export const InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
     /**
@@ -422,8 +445,7 @@ export const isInitializeRequest = (value) => InitializeRequestSchema.safeParse(
 /**
  * Capabilities that a server may support. Known capabilities are defined here, in this schema, but this is not a closed set: any server can define its own, additional capabilities.
  */
-export const ServerCapabilitiesSchema = z
-    .object({
+export const ServerCapabilitiesSchema = z.object({
     /**
      * Experimental, non-standard capabilities that the server supports.
      */
@@ -439,12 +461,14 @@ export const ServerCapabilitiesSchema = z
     /**
      * Present if the server offers any prompt templates.
      */
-    prompts: z.optional(z.object({
+    prompts: z
+        .object({
         /**
          * Whether this server supports issuing notifications for changes to the prompt list.
          */
-        listChanged: z.optional(z.boolean())
-    })),
+        listChanged: z.boolean().optional()
+    })
+        .optional(),
     /**
      * Present if the server offers any resources to read.
      */
@@ -474,9 +498,8 @@ export const ServerCapabilitiesSchema = z
     /**
      * Present if the server supports task creation.
      */
-    tasks: z.optional(ServerTasksCapabilitySchema)
-})
-    .passthrough();
+    tasks: ServerTasksCapabilitySchema.optional()
+});
 /**
  * After receiving an initialize request from the client, the server sends this response.
  */
@@ -498,7 +521,8 @@ export const InitializeResultSchema = ResultSchema.extend({
  * This notification is sent from the client to the server after initialization has finished.
  */
 export const InitializedNotificationSchema = NotificationSchema.extend({
-    method: z.literal('notifications/initialized')
+    method: z.literal('notifications/initialized'),
+    params: NotificationsParamsSchema.optional()
 });
 export const isInitializedNotification = (value) => InitializedNotificationSchema.safeParse(value).success;
 /* Ping */
@@ -506,7 +530,8 @@ export const isInitializedNotification = (value) => InitializedNotificationSchem
  * A ping, issued by either the server or the client, to check that the other party is still alive. The receiver must promptly respond, or else may be disconnected.
  */
 export const PingRequestSchema = RequestSchema.extend({
-    method: z.literal('ping')
+    method: z.literal('ping'),
+    params: BaseRequestParamsSchema.optional()
 });
 /* Progress notifications */
 export const ProgressSchema = z.object({
@@ -556,15 +581,19 @@ export const PaginatedResultSchema = ResultSchema.extend({
      * An opaque token representing the pagination position after the last returned result.
      * If present, there may be more results available.
      */
-    nextCursor: z.optional(CursorSchema)
+    nextCursor: CursorSchema.optional()
 });
+/**
+ * The status of a task.
+ * */
+export const TaskStatusSchema = z.enum(['working', 'input_required', 'completed', 'failed', 'cancelled']);
 /* Tasks */
 /**
  * A pollable state object associated with a request.
  */
 export const TaskSchema = z.object({
     taskId: z.string(),
-    status: z.enum(['working', 'input_required', 'completed', 'failed', 'cancelled']),
+    status: TaskStatusSchema,
     /**
      * Time in milliseconds to keep task results available after completion.
      * If null, the task has unlimited lifetime until manually cleaned up.
@@ -623,6 +652,13 @@ export const GetTaskPayloadRequestSchema = RequestSchema.extend({
         taskId: z.string()
     })
 });
+/**
+ * The response to a tasks/result request.
+ * The structure matches the result type of the original request.
+ * For example, a tools/call task would return the CallToolResult structure.
+ *
+ */
+export const GetTaskPayloadResultSchema = ResultSchema.loose();
 /**
  * A request to list tasks.
  */
@@ -685,7 +721,7 @@ const Base64Schema = z.string().refine(val => {
         atob(val);
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }, { message: 'Invalid Base64 string' });
@@ -695,6 +731,10 @@ export const BlobResourceContentsSchema = ResourceContentsSchema.extend({
      */
     blob: Base64Schema
 });
+/**
+ * The sender or recipient of messages and data in a conversation.
+ */
+export const RoleSchema = z.enum(['user', 'assistant']);
 /**
  * Optional annotations providing clients additional context about a resource.
  */
@@ -702,7 +742,7 @@ export const AnnotationsSchema = z.object({
     /**
      * Intended audience(s) for the resource.
      */
-    audience: z.array(z.enum(['user', 'assistant'])).optional(),
+    audience: z.array(RoleSchema).optional(),
     /**
      * Importance hint for the resource, from 0 (least) to 1 (most).
      */
@@ -825,7 +865,8 @@ export const ReadResourceResultSchema = ResultSchema.extend({
  * An optional notification from the server to the client, informing it that the list of resources it can read from has changed. This may be issued by servers without any previous subscription from the client.
  */
 export const ResourceListChangedNotificationSchema = NotificationSchema.extend({
-    method: z.literal('notifications/resources/list_changed')
+    method: z.literal('notifications/resources/list_changed'),
+    params: NotificationsParamsSchema.optional()
 });
 export const SubscribeRequestParamsSchema = ResourceRequestParamsSchema;
 /**
@@ -998,8 +1039,7 @@ export const AudioContentSchema = z.object({
  * A tool call request from an assistant (LLM).
  * Represents the assistant's request to use a tool.
  */
-export const ToolUseContentSchema = z
-    .object({
+export const ToolUseContentSchema = z.object({
     type: z.literal('tool_use'),
     /**
      * The name of the tool to invoke.
@@ -1015,14 +1055,13 @@ export const ToolUseContentSchema = z
      * Arguments to pass to the tool.
      * Must conform to the tool's inputSchema.
      */
-    input: z.object({}).passthrough(),
+    input: z.record(z.string(), z.unknown()),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: z.optional(z.object({}).passthrough())
-})
-    .passthrough();
+    _meta: z.record(z.string(), z.unknown()).optional()
+});
 /**
  * The contents of a resource, embedded into a prompt or tool call result.
  */
@@ -1061,7 +1100,7 @@ export const ContentBlockSchema = z.union([
  * Describes a message returned as part of a prompt.
  */
 export const PromptMessageSchema = z.object({
-    role: z.enum(['user', 'assistant']),
+    role: RoleSchema,
     content: ContentBlockSchema
 });
 /**
@@ -1071,14 +1110,15 @@ export const GetPromptResultSchema = ResultSchema.extend({
     /**
      * An optional description for the prompt.
      */
-    description: z.optional(z.string()),
+    description: z.string().optional(),
     messages: z.array(PromptMessageSchema)
 });
 /**
  * An optional notification from the server to the client, informing it that the list of prompts it offers has changed. This may be issued by servers without any previous subscription from the client.
  */
 export const PromptListChangedNotificationSchema = NotificationSchema.extend({
-    method: z.literal('notifications/prompts/list_changed')
+    method: z.literal('notifications/prompts/list_changed'),
+    params: NotificationsParamsSchema.optional()
 });
 /* Tools */
 /**
@@ -1181,11 +1221,11 @@ export const ToolSchema = z.object({
     /**
      * Optional additional tool information.
      */
-    annotations: z.optional(ToolAnnotationsSchema),
+    annotations: ToolAnnotationsSchema.optional(),
     /**
      * Execution-related properties for this tool.
      */
-    execution: z.optional(ToolExecutionSchema),
+    execution: ToolExecutionSchema.optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -1235,7 +1275,7 @@ export const CallToolResultSchema = ResultSchema.extend({
      * server does not support tool calls, or any other exceptional conditions,
      * should be reported as an MCP error response.
      */
-    isError: z.optional(z.boolean())
+    isError: z.boolean().optional()
 });
 /**
  * CallToolResultSchema extended with backwards compatibility to protocol version 2024-10-07.
@@ -1246,7 +1286,7 @@ export const CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultS
 /**
  * Parameters for a `tools/call` request.
  */
-export const CallToolRequestParamsSchema = BaseRequestParamsSchema.extend({
+export const CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
     /**
      * The name of the tool to call.
      */
@@ -1254,7 +1294,7 @@ export const CallToolRequestParamsSchema = BaseRequestParamsSchema.extend({
     /**
      * Arguments to pass to the tool.
      */
-    arguments: z.optional(z.record(z.string(), z.unknown()))
+    arguments: z.record(z.string(), z.unknown()).optional()
 });
 /**
  * Used by the client to invoke a tool provided by the server.
@@ -1267,7 +1307,32 @@ export const CallToolRequestSchema = RequestSchema.extend({
  * An optional notification from the server to the client, informing it that the list of tools it offers has changed. This may be issued by servers without any previous subscription from the client.
  */
 export const ToolListChangedNotificationSchema = NotificationSchema.extend({
-    method: z.literal('notifications/tools/list_changed')
+    method: z.literal('notifications/tools/list_changed'),
+    params: NotificationsParamsSchema.optional()
+});
+/**
+ * Base schema for list changed subscription options (without callback).
+ * Used internally for Zod validation of autoRefresh and debounceMs.
+ */
+export const ListChangedOptionsBaseSchema = z.object({
+    /**
+     * If true, the list will be refreshed automatically when a list changed notification is received.
+     * The callback will be called with the updated list.
+     *
+     * If false, the callback will be called with null items, allowing manual refresh.
+     *
+     * @default true
+     */
+    autoRefresh: z.boolean().default(true),
+    /**
+     * Debounce time in milliseconds for list changed notification processing.
+     *
+     * Multiple notifications received within this timeframe will only trigger one refresh.
+     * Set to 0 to disable debouncing.
+     *
+     * @default 300
+     */
+    debounceMs: z.number().int().nonnegative().default(300)
 });
 /* Logging */
 /**
@@ -1331,19 +1396,19 @@ export const ModelPreferencesSchema = z.object({
     /**
      * Optional hints to use for model selection.
      */
-    hints: z.optional(z.array(ModelHintSchema)),
+    hints: z.array(ModelHintSchema).optional(),
     /**
      * How much to prioritize cost when selecting a model.
      */
-    costPriority: z.optional(z.number().min(0).max(1)),
+    costPriority: z.number().min(0).max(1).optional(),
     /**
      * How much to prioritize sampling speed (latency) when selecting a model.
      */
-    speedPriority: z.optional(z.number().min(0).max(1)),
+    speedPriority: z.number().min(0).max(1).optional(),
     /**
      * How much to prioritize intelligence and capabilities when selecting a model.
      */
-    intelligencePriority: z.optional(z.number().min(0).max(1))
+    intelligencePriority: z.number().min(0).max(1).optional()
 });
 /**
  * Controls tool usage behavior in sampling requests.
@@ -1355,26 +1420,24 @@ export const ToolChoiceSchema = z.object({
      * - "required": Model MUST use at least one tool before completing
      * - "none": Model MUST NOT use any tools
      */
-    mode: z.optional(z.enum(['auto', 'required', 'none']))
+    mode: z.enum(['auto', 'required', 'none']).optional()
 });
 /**
  * The result of a tool execution, provided by the user (server).
  * Represents the outcome of invoking a tool requested via ToolUseContent.
  */
-export const ToolResultContentSchema = z
-    .object({
+export const ToolResultContentSchema = z.object({
     type: z.literal('tool_result'),
     toolUseId: z.string().describe('The unique identifier for the corresponding tool call.'),
     content: z.array(ContentBlockSchema).default([]),
-    structuredContent: z.object({}).passthrough().optional(),
-    isError: z.optional(z.boolean()),
+    structuredContent: z.object({}).loose().optional(),
+    isError: z.boolean().optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: z.optional(z.object({}).passthrough())
-})
-    .passthrough();
+    _meta: z.record(z.string(), z.unknown()).optional()
+});
 /**
  * Basic content types for sampling responses (without tool use).
  * Used for backwards-compatible CreateMessageResult when tools are not used.
@@ -1394,21 +1457,19 @@ export const SamplingMessageContentBlockSchema = z.discriminatedUnion('type', [
 /**
  * Describes a message issued to or received from an LLM API.
  */
-export const SamplingMessageSchema = z
-    .object({
-    role: z.enum(['user', 'assistant']),
+export const SamplingMessageSchema = z.object({
+    role: RoleSchema,
     content: z.union([SamplingMessageContentBlockSchema, z.array(SamplingMessageContentBlockSchema)]),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: z.optional(z.object({}).passthrough())
-})
-    .passthrough();
+    _meta: z.record(z.string(), z.unknown()).optional()
+});
 /**
  * Parameters for a `sampling/createMessage` request.
  */
-export const CreateMessageRequestParamsSchema = BaseRequestParamsSchema.extend({
+export const CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
     messages: z.array(SamplingMessageSchema),
     /**
      * The server's preferences for which model to select. The client MAY modify or omit this request.
@@ -1442,13 +1503,13 @@ export const CreateMessageRequestParamsSchema = BaseRequestParamsSchema.extend({
      * Tools that the model may use during generation.
      * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared.
      */
-    tools: z.optional(z.array(ToolSchema)),
+    tools: z.array(ToolSchema).optional(),
     /**
      * Controls how the model uses tools.
      * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared.
      * Default is `{ mode: "auto" }`.
      */
-    toolChoice: z.optional(ToolChoiceSchema)
+    toolChoice: ToolChoiceSchema.optional()
 });
 /**
  * A request from the server to sample an LLM via the client. The client has full discretion over which model to select. The client should also inform the user before beginning sampling, to allow them to inspect the request (human in the loop) and decide whether to approve it.
@@ -1478,7 +1539,7 @@ export const CreateMessageResultSchema = ResultSchema.extend({
      * This field is an open string to allow for provider-specific stop reasons.
      */
     stopReason: z.optional(z.enum(['endTurn', 'stopSequence', 'maxTokens']).or(z.string())),
-    role: z.enum(['user', 'assistant']),
+    role: RoleSchema,
     /**
      * Response content. Single content block (text, image, or audio).
      */
@@ -1505,7 +1566,7 @@ export const CreateMessageResultWithToolsSchema = ResultSchema.extend({
      * This field is an open string to allow for provider-specific stop reasons.
      */
     stopReason: z.optional(z.enum(['endTurn', 'stopSequence', 'maxTokens', 'toolUse']).or(z.string())),
-    role: z.enum(['user', 'assistant']),
+    role: RoleSchema,
     /**
      * Response content. May be a single block or array. May include ToolUseContent if stopReason is "toolUse".
      */
@@ -1628,7 +1689,7 @@ export const PrimitiveSchemaDefinitionSchema = z.union([EnumSchemaSchema, Boolea
 /**
  * Parameters for an `elicitation/create` request for form-based elicitation.
  */
-export const ElicitRequestFormParamsSchema = BaseRequestParamsSchema.extend({
+export const ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({
     /**
      * The elicitation mode.
      *
@@ -1652,7 +1713,7 @@ export const ElicitRequestFormParamsSchema = BaseRequestParamsSchema.extend({
 /**
  * Parameters for an `elicitation/create` request for URL-based elicitation.
  */
-export const ElicitRequestURLParamsSchema = BaseRequestParamsSchema.extend({
+export const ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({
     /**
      * The elicitation mode.
      */
@@ -1836,7 +1897,8 @@ export const RootSchema = z.object({
  * Sent from the server to request a list of root URIs from the client.
  */
 export const ListRootsRequestSchema = RequestSchema.extend({
-    method: z.literal('roots/list')
+    method: z.literal('roots/list'),
+    params: BaseRequestParamsSchema.optional()
 });
 /**
  * The client's response to a roots/list request from the server.
@@ -1848,7 +1910,8 @@ export const ListRootsResultSchema = ResultSchema.extend({
  * A notification from the client to the server, informing it that the list of roots has changed.
  */
 export const RootsListChangedNotificationSchema = NotificationSchema.extend({
-    method: z.literal('notifications/roots/list_changed')
+    method: z.literal('notifications/roots/list_changed'),
+    params: NotificationsParamsSchema.optional()
 });
 /* Client messages */
 export const ClientRequestSchema = z.union([
@@ -1867,7 +1930,8 @@ export const ClientRequestSchema = z.union([
     ListToolsRequestSchema,
     GetTaskRequestSchema,
     GetTaskPayloadRequestSchema,
-    ListTasksRequestSchema
+    ListTasksRequestSchema,
+    CancelTaskRequestSchema
 ]);
 export const ClientNotificationSchema = z.union([
     CancelledNotificationSchema,
@@ -1894,7 +1958,8 @@ export const ServerRequestSchema = z.union([
     ListRootsRequestSchema,
     GetTaskRequestSchema,
     GetTaskPayloadRequestSchema,
-    ListTasksRequestSchema
+    ListTasksRequestSchema,
+    CancelTaskRequestSchema
 ]);
 export const ServerNotificationSchema = z.union([
     CancelledNotificationSchema,
@@ -1955,8 +2020,7 @@ export class UrlElicitationRequiredError extends McpError {
         });
     }
     get elicitations() {
-        var _a, _b;
-        return (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.elicitations) !== null && _b !== void 0 ? _b : [];
+        return this.data?.elicitations ?? [];
     }
 }
 //# sourceMappingURL=types.js.map