@opentiny/next-sdk 0.2.0 → 0.2.1

package/dist/{mcpsdk@1.23.1.dev.js → mcpsdk@1.25.2.dev.js}

@@ -5,7 +5,7 @@
   function getDefaultExportFromCjs(x) {
     return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
   }
-  var ajv$1 = { exports: {} };
+  var ajv = { exports: {} };
   var core$1 = {};
   var validate = {};
   var boolSchema = {};
@@ -3921,7 +3921,7 @@
           uriResolver
         };
       }
-      class Ajv {
+      class Ajv2 {
         constructor(opts = {}) {
           this.schemas = {};
           this.refs = {};
@@ -4291,9 +4291,9 @@
           }
         }
       }
-      Ajv.ValidationError = validation_error_1.default;
-      Ajv.MissingRefError = ref_error_1.default;
-      exports3.default = Ajv;
+      Ajv2.ValidationError = validation_error_1.default;
+      Ajv2.MissingRefError = ref_error_1.default;
+      exports3.default = Ajv2;
       function checkOptions(checkOpts, options, msg, log = "error") {
         for (const key in checkOpts) {
           const opt = key;
@@ -6245,7 +6245,7 @@
   };
   var hasRequiredAjv;
   function requireAjv() {
-    if (hasRequiredAjv) return ajv$1.exports;
+    if (hasRequiredAjv) return ajv.exports;
     hasRequiredAjv = 1;
     (function(module2, exports3) {
       Object.defineProperty(exports3, "__esModule", { value: true });
@@ -6256,7 +6256,7 @@
       const draft7MetaSchema = require$$3;
       const META_SUPPORT_DATA = ["/properties"];
       const META_SCHEMA_ID = "http://json-schema.org/draft-07/schema";
-      class Ajv extends core_1.default {
+      class Ajv2 extends core_1.default {
         _addVocabularies() {
           super._addVocabularies();
           draft7_1.default.forEach((v) => this.addVocabulary(v));
@@ -6275,11 +6275,11 @@
           return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
         }
       }
-      exports3.Ajv = Ajv;
-      module2.exports = exports3 = Ajv;
-      module2.exports.Ajv = Ajv;
+      exports3.Ajv = Ajv2;
+      module2.exports = exports3 = Ajv2;
+      module2.exports.Ajv = Ajv2;
       Object.defineProperty(exports3, "__esModule", { value: true });
-      exports3.default = Ajv;
+      exports3.default = Ajv2;
       var validate_1 = requireValidate();
       Object.defineProperty(exports3, "KeywordCxt", { enumerable: true, get: function() {
         return validate_1.KeywordCxt;
@@ -6311,11 +6311,11 @@
       Object.defineProperty(exports3, "MissingRefError", { enumerable: true, get: function() {
         return ref_error_1.default;
       } });
-    })(ajv$1, ajv$1.exports);
-    return ajv$1.exports;
+    })(ajv, ajv.exports);
+    return ajv.exports;
   }
   var ajvExports = requireAjv();
-  const ajv = /* @__PURE__ */ getDefaultExportFromCjs(ajvExports);
+  const Ajv = /* @__PURE__ */ getDefaultExportFromCjs(ajvExports);
   const NEVER = Object.freeze({
     status: "aborted"
   });
@@ -6851,8 +6851,9 @@
     return new RegExp(`^${regex}$`);
   };
   const integer = /^\d+$/;
-  const number$1 = /^-?\d+(?:\.\d+)?/i;
+  const number$2 = /^-?\d+(?:\.\d+)?/i;
   const boolean$1 = /true|false/i;
+  const _null$2 = /null/i;
   const lowercase = /^[^A-Z]*$/;
   const uppercase = /^[^a-z]*$/;
   const $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
@@ -7662,7 +7663,7 @@
   });
   const $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
     $ZodType.init(inst, def);
-    inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
+    inst._zod.pattern = inst._zod.bag.pattern ?? number$2;
     inst._zod.parse = (payload, _ctx) => {
       if (def.coerce)
         try {
@@ -7709,6 +7710,23 @@
       return payload;
     };
   });
+  const $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = _null$2;
+    inst._zod.values = /* @__PURE__ */ new Set([null]);
+    inst._zod.parse = (payload, _ctx) => {
+      const input = payload.value;
+      if (input === null)
+        return payload;
+      payload.issues.push({
+        expected: "null",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    };
+  });
   const $ZodAny = /* @__PURE__ */ $constructor("$ZodAny", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.parse = (payload) => payload;
@@ -8796,6 +8814,14 @@
       ...normalizeParams(params)
     });
   }
+  function _coercedNumber(Class, params) {
+    return new Class({
+      type: "number",
+      coerce: true,
+      checks: [],
+      ...normalizeParams(params)
+    });
+  }
   function _int(Class, params) {
     return new Class({
       type: "number",
@@ -8811,6 +8837,12 @@
       ...normalizeParams(params)
     });
   }
+  function _null$1(Class, params) {
+    return new Class({
+      type: "null",
+      ...normalizeParams(params)
+    });
+  }
   function _any(Class) {
     return new Class({
       type: "any"
@@ -10034,7 +10066,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     inst.isFinite = true;
     inst.format = bag.format ?? null;
   });
-  function number(params) {
+  function number$1(params) {
     return _number(ZodNumber$1, params);
   }
   const ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
@@ -10051,6 +10083,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   function boolean(params) {
     return _boolean(ZodBoolean$1, params);
   }
+  const ZodNull$1 = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
+    $ZodNull.init(inst, def);
+    ZodType$1.init(inst, def);
+  });
+  function _null(params) {
+    return _null$1(ZodNull$1, params);
+  }
   const ZodAny$1 = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
     $ZodAny.init(inst, def);
     ZodType$1.init(inst, def);
@@ -10419,48 +10458,85 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   const ZodIssueCode$1 = {
     custom: "custom"
   };
-  const LATEST_PROTOCOL_VERSION = "2025-06-18";
+  function number(params) {
+    return _coercedNumber(ZodNumber$1, params);
+  }
+  const LATEST_PROTOCOL_VERSION = "2025-11-25";
   const DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
-  const SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-03-26", "2024-11-05", "2024-10-07"];
+  const SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
+  const RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
   const JSONRPC_VERSION = "2.0";
   const AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
-  const ProgressTokenSchema = union([string(), number().int()]);
+  const ProgressTokenSchema = union([string(), number$1().int()]);
   const CursorSchema = string();
+  const TaskCreationParamsSchema = looseObject({
+    /**
+     * Time in milliseconds to keep task results available after completion.
+     * If null, the task has unlimited lifetime until manually cleaned up.
+     */
+    ttl: union([number$1(), _null()]).optional(),
+    /**
+     * Time in milliseconds to wait between task status requests.
+     */
+    pollInterval: number$1().optional()
+  });
+  const TaskMetadataSchema = object$1({
+    ttl: number$1().optional()
+  });
+  const RelatedTaskMetadataSchema = object$1({
+    taskId: string()
+  });
   const RequestMetaSchema = looseObject({
     /**
      * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
      */
-    progressToken: ProgressTokenSchema.optional()
+    progressToken: ProgressTokenSchema.optional(),
+    /**
+     * If specified, this request is related to the provided task.
+     */
+    [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
   });
-  const BaseRequestParamsSchema = looseObject({
+  const BaseRequestParamsSchema = object$1({
     /**
      * See [General fields: `_meta`](/specification/draft/basic/index#meta) for notes on `_meta` usage.
      */
     _meta: RequestMetaSchema.optional()
   });
+  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()
+  });
+  const isTaskAugmentedRequestParams = (value) => TaskAugmentedRequestParamsSchema.safeParse(value).success;
   const RequestSchema = object$1({
     method: string(),
-    params: BaseRequestParamsSchema.optional()
+    params: BaseRequestParamsSchema.loose().optional()
   });
-  const NotificationsParamsSchema = looseObject({
+  const NotificationsParamsSchema = object$1({
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: record(string(), unknown()).optional()
+    _meta: RequestMetaSchema.optional()
   });
   const NotificationSchema = object$1({
     method: string(),
-    params: NotificationsParamsSchema.optional()
+    params: NotificationsParamsSchema.loose().optional()
   });
   const ResultSchema = 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: record(string(), unknown()).optional()
+    _meta: RequestMetaSchema.optional()
   });
-  const RequestIdSchema = union([string(), number().int()]);
+  const RequestIdSchema = union([string(), number$1().int()]);
   const JSONRPCRequestSchema = object$1({
     jsonrpc: literal(JSONRPC_VERSION),
     id: RequestIdSchema,
@@ -10472,12 +10548,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     ...NotificationSchema.shape
   }).strict();
   const isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success;
-  const JSONRPCResponseSchema = object$1({
+  const JSONRPCResultResponseSchema = object$1({
     jsonrpc: literal(JSONRPC_VERSION),
     id: RequestIdSchema,
     result: ResultSchema
   }).strict();
-  const isJSONRPCResponse = (value) => JSONRPCResponseSchema.safeParse(value).success;
+  const isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success;
+  const isJSONRPCResponse = isJSONRPCResultResponse;
   exports2.ErrorCode = void 0;
   (function(ErrorCode) {
     ErrorCode[ErrorCode["ConnectionClosed"] = -32e3] = "ConnectionClosed";
@@ -10489,14 +10566,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     ErrorCode[ErrorCode["InternalError"] = -32603] = "InternalError";
     ErrorCode[ErrorCode["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
   })(exports2.ErrorCode || (exports2.ErrorCode = {}));
-  const JSONRPCErrorSchema = object$1({
+  const JSONRPCErrorResponseSchema = object$1({
     jsonrpc: literal(JSONRPC_VERSION),
-    id: RequestIdSchema,
+    id: RequestIdSchema.optional(),
     error: object$1({
       /**
        * The error type that occurred.
        */
-      code: number().int(),
+      code: number$1().int(),
       /**
        * A short description of the error. The message SHOULD be limited to a concise single sentence.
        */
@@ -10504,11 +10581,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       /**
        * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.).
        */
-      data: optional(unknown())
+      data: unknown().optional()
     })
   }).strict();
-  const isJSONRPCError = (value) => JSONRPCErrorSchema.safeParse(value).success;
-  const JSONRPCMessageSchema = union([JSONRPCRequestSchema, JSONRPCNotificationSchema, JSONRPCResponseSchema, JSONRPCErrorSchema]);
+  const JSONRPCErrorSchema = JSONRPCErrorResponseSchema;
+  const isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
+  const isJSONRPCError = isJSONRPCErrorResponse;
+  const JSONRPCMessageSchema = union([
+    JSONRPCRequestSchema,
+    JSONRPCNotificationSchema,
+    JSONRPCResultResponseSchema,
+    JSONRPCErrorResponseSchema
+  ]);
+  const JSONRPCResponseSchema = union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
   const EmptyResultSchema = ResultSchema.strict();
   const CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
     /**
@@ -10516,7 +10601,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      *
      * 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.
      */
@@ -10541,7 +10626,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      *
      * If not provided, the client should assume that the icon can be used at any size.
      */
-    sizes: array(string()).optional()
+    sizes: array(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: _enum(["light", "dark"]).optional()
   });
   const IconsSchema = object$1({
     /**
@@ -10577,7 +10670,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     /**
      * An optional URL of the website for this implementation.
      */
-    websiteUrl: string().optional()
+    websiteUrl: 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: string().optional()
   });
   const FormElicitationCapabilitySchema = intersection(object$1({
     applyDefaults: boolean().optional()
@@ -10593,6 +10694,54 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     form: FormElicitationCapabilitySchema.optional(),
     url: AssertObjectSchema.optional()
   }), record(string(), unknown()).optional()));
+  const ClientTasksCapabilitySchema = looseObject({
+    /**
+     * Present if the client supports listing tasks.
+     */
+    list: AssertObjectSchema.optional(),
+    /**
+     * Present if the client supports cancelling tasks.
+     */
+    cancel: AssertObjectSchema.optional(),
+    /**
+     * Capabilities for task creation on specific request types.
+     */
+    requests: looseObject({
+      /**
+       * Task support for sampling requests.
+       */
+      sampling: looseObject({
+        createMessage: AssertObjectSchema.optional()
+      }).optional(),
+      /**
+       * Task support for elicitation requests.
+       */
+      elicitation: looseObject({
+        create: AssertObjectSchema.optional()
+      }).optional()
+    }).optional()
+  });
+  const ServerTasksCapabilitySchema = looseObject({
+    /**
+     * Present if the server supports listing tasks.
+     */
+    list: AssertObjectSchema.optional(),
+    /**
+     * Present if the server supports cancelling tasks.
+     */
+    cancel: AssertObjectSchema.optional(),
+    /**
+     * Capabilities for task creation on specific request types.
+     */
+    requests: looseObject({
+      /**
+       * Task support for tool requests.
+       */
+      tools: looseObject({
+        call: AssertObjectSchema.optional()
+      }).optional()
+    }).optional()
+  });
   const ClientCapabilitiesSchema = object$1({
     /**
      * Experimental, non-standard capabilities that the client supports.
@@ -10624,7 +10773,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
        * Whether the client supports issuing notifications for changes to the roots list.
        */
       listChanged: boolean().optional()
-    }).optional()
+    }).optional(),
+    /**
+     * Present if the client supports task creation.
+     */
+    tasks: ClientTasksCapabilitySchema.optional()
   });
   const InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
     /**
@@ -10655,12 +10808,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     /**
      * Present if the server offers any prompt templates.
      */
-    prompts: optional(object$1({
+    prompts: object$1({
       /**
        * Whether this server supports issuing notifications for changes to the prompt list.
        */
-      listChanged: optional(boolean())
-    })),
+      listChanged: boolean().optional()
+    }).optional(),
     /**
      * Present if the server offers any resources to read.
      */
@@ -10682,7 +10835,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
        * Whether this server supports issuing notifications for changes to the tool list.
        */
       listChanged: boolean().optional()
-    }).optional()
+    }).optional(),
+    /**
+     * Present if the server supports task creation.
+     */
+    tasks: ServerTasksCapabilitySchema.optional()
   });
   const InitializeResultSchema = ResultSchema.extend({
     /**
@@ -10699,21 +10856,23 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     instructions: string().optional()
   });
   const InitializedNotificationSchema = NotificationSchema.extend({
-    method: literal("notifications/initialized")
+    method: literal("notifications/initialized"),
+    params: NotificationsParamsSchema.optional()
   });
   const isInitializedNotification = (value) => InitializedNotificationSchema.safeParse(value).success;
   const PingRequestSchema = RequestSchema.extend({
-    method: literal("ping")
+    method: literal("ping"),
+    params: BaseRequestParamsSchema.optional()
   });
   const ProgressSchema = object$1({
     /**
      * The progress thus far. This should increase every time progress is made, even if the total is unknown.
      */
-    progress: number(),
+    progress: number$1(),
     /**
      * Total number of items to process (or total progress required), if known.
      */
-    total: optional(number()),
+    total: optional(number$1()),
     /**
      * An optional message describing the current progress.
      */
@@ -10746,8 +10905,66 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * An opaque token representing the pagination position after the last returned result.
      * If present, there may be more results available.
      */
-    nextCursor: optional(CursorSchema)
+    nextCursor: CursorSchema.optional()
+  });
+  const TaskStatusSchema = _enum(["working", "input_required", "completed", "failed", "cancelled"]);
+  const TaskSchema = object$1({
+    taskId: string(),
+    status: TaskStatusSchema,
+    /**
+     * Time in milliseconds to keep task results available after completion.
+     * If null, the task has unlimited lifetime until manually cleaned up.
+     */
+    ttl: union([number$1(), _null()]),
+    /**
+     * ISO 8601 timestamp when the task was created.
+     */
+    createdAt: string(),
+    /**
+     * ISO 8601 timestamp when the task was last updated.
+     */
+    lastUpdatedAt: string(),
+    pollInterval: optional(number$1()),
+    /**
+     * Optional diagnostic message for failed tasks or other status information.
+     */
+    statusMessage: optional(string())
+  });
+  const CreateTaskResultSchema = ResultSchema.extend({
+    task: TaskSchema
+  });
+  const TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema);
+  const TaskStatusNotificationSchema = NotificationSchema.extend({
+    method: literal("notifications/tasks/status"),
+    params: TaskStatusNotificationParamsSchema
+  });
+  const GetTaskRequestSchema = RequestSchema.extend({
+    method: literal("tasks/get"),
+    params: BaseRequestParamsSchema.extend({
+      taskId: string()
+    })
+  });
+  const GetTaskResultSchema = ResultSchema.merge(TaskSchema);
+  const GetTaskPayloadRequestSchema = RequestSchema.extend({
+    method: literal("tasks/result"),
+    params: BaseRequestParamsSchema.extend({
+      taskId: string()
+    })
+  });
+  const GetTaskPayloadResultSchema = ResultSchema.loose();
+  const ListTasksRequestSchema = PaginatedRequestSchema.extend({
+    method: literal("tasks/list")
+  });
+  const ListTasksResultSchema = PaginatedResultSchema.extend({
+    tasks: array(TaskSchema)
+  });
+  const CancelTaskRequestSchema = RequestSchema.extend({
+    method: literal("tasks/cancel"),
+    params: BaseRequestParamsSchema.extend({
+      taskId: string()
+    })
   });
+  const CancelTaskResultSchema = ResultSchema.merge(TaskSchema);
   const ResourceContentsSchema = object$1({
     /**
      * The URI of this resource.
@@ -10773,7 +10990,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     try {
       atob(val);
       return true;
-    } catch (_a) {
+    } catch {
       return false;
     }
   }, { message: "Invalid Base64 string" });
@@ -10783,6 +11000,21 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      */
     blob: Base64Schema
   });
+  const RoleSchema = _enum(["user", "assistant"]);
+  const AnnotationsSchema = object$1({
+    /**
+     * Intended audience(s) for the resource.
+     */
+    audience: array(RoleSchema).optional(),
+    /**
+     * Importance hint for the resource, from 0 (least) to 1 (most).
+     */
+    priority: number$1().min(0).max(1).optional(),
+    /**
+     * ISO 8601 timestamp for the most recent modification.
+     */
+    lastModified: datetime({ offset: true }).optional()
+  });
   const ResourceSchema = object$1({
     ...BaseMetadataSchema.shape,
     ...IconsSchema.shape,
@@ -10800,6 +11032,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * The MIME type of this resource, if known.
      */
     mimeType: optional(string()),
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: AnnotationsSchema.optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -10823,6 +11059,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type.
      */
     mimeType: optional(string()),
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: AnnotationsSchema.optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -10858,7 +11098,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     contents: array(union([TextResourceContentsSchema, BlobResourceContentsSchema]))
   });
   const ResourceListChangedNotificationSchema = NotificationSchema.extend({
-    method: literal("notifications/resources/list_changed")
+    method: literal("notifications/resources/list_changed"),
+    params: NotificationsParamsSchema.optional()
   });
   const SubscribeRequestParamsSchema = ResourceRequestParamsSchema;
   const SubscribeRequestSchema = RequestSchema.extend({
@@ -10937,6 +11178,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * The text content of the message.
      */
     text: string(),
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: AnnotationsSchema.optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -10953,6 +11198,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * The MIME type of the image. Different providers may support different image types.
      */
     mimeType: string(),
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: AnnotationsSchema.optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -10969,6 +11218,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * The MIME type of the audio. Different providers may support different audio types.
      */
     mimeType: string(),
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: AnnotationsSchema.optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -10991,16 +11244,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * Arguments to pass to the tool.
      * Must conform to the tool's inputSchema.
      */
-    input: object$1({}).passthrough(),
+    input: record(string(), 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: optional(object$1({}).passthrough())
-  }).passthrough();
+    _meta: record(string(), unknown()).optional()
+  });
   const EmbeddedResourceSchema = object$1({
     type: literal("resource"),
     resource: union([TextResourceContentsSchema, BlobResourceContentsSchema]),
+    /**
+     * Optional annotations for the client.
+     */
+    annotations: AnnotationsSchema.optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -11018,18 +11275,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     EmbeddedResourceSchema
   ]);
   const PromptMessageSchema = object$1({
-    role: _enum(["user", "assistant"]),
+    role: RoleSchema,
     content: ContentBlockSchema
   });
   const GetPromptResultSchema = ResultSchema.extend({
     /**
      * An optional description for the prompt.
      */
-    description: optional(string()),
+    description: string().optional(),
     messages: array(PromptMessageSchema)
   });
   const PromptListChangedNotificationSchema = NotificationSchema.extend({
-    method: literal("notifications/prompts/list_changed")
+    method: literal("notifications/prompts/list_changed"),
+    params: NotificationsParamsSchema.optional()
   });
   const ToolAnnotationsSchema = object$1({
     /**
@@ -11070,6 +11328,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      */
     openWorldHint: boolean().optional()
   });
+  const ToolExecutionSchema = object$1({
+    /**
+     * Indicates the tool's preference for task-augmented execution.
+     * - "required": Clients MUST invoke the tool as a task
+     * - "optional": Clients MAY invoke the tool as a task or normal request
+     * - "forbidden": Clients MUST NOT attempt to invoke the tool as a task
+     *
+     * If not present, defaults to "forbidden".
+     */
+    taskSupport: _enum(["required", "optional", "forbidden"]).optional()
+  });
   const ToolSchema = object$1({
     ...BaseMetadataSchema.shape,
     ...IconsSchema.shape,
@@ -11099,7 +11368,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     /**
      * Optional additional tool information.
      */
-    annotations: optional(ToolAnnotationsSchema),
+    annotations: ToolAnnotationsSchema.optional(),
+    /**
+     * Execution-related properties for this tool.
+     */
+    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.
@@ -11140,12 +11413,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * server does not support tool calls, or any other exceptional conditions,
      * should be reported as an MCP error response.
      */
-    isError: optional(boolean())
+    isError: boolean().optional()
   });
   const CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({
     toolResult: unknown()
   }));
-  const CallToolRequestParamsSchema = BaseRequestParamsSchema.extend({
+  const CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
     /**
      * The name of the tool to call.
      */
@@ -11153,14 +11426,35 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     /**
      * Arguments to pass to the tool.
      */
-    arguments: optional(record(string(), unknown()))
+    arguments: record(string(), unknown()).optional()
   });
   const CallToolRequestSchema = RequestSchema.extend({
     method: literal("tools/call"),
     params: CallToolRequestParamsSchema
   });
   const ToolListChangedNotificationSchema = NotificationSchema.extend({
-    method: literal("notifications/tools/list_changed")
+    method: literal("notifications/tools/list_changed"),
+    params: NotificationsParamsSchema.optional()
+  });
+  const ListChangedOptionsBaseSchema = object$1({
+    /**
+     * 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: 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: number$1().int().nonnegative().default(300)
   });
   const LoggingLevelSchema = _enum(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
   const SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({
@@ -11201,19 +11495,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     /**
      * Optional hints to use for model selection.
      */
-    hints: optional(array(ModelHintSchema)),
+    hints: array(ModelHintSchema).optional(),
     /**
      * How much to prioritize cost when selecting a model.
      */
-    costPriority: optional(number().min(0).max(1)),
+    costPriority: number$1().min(0).max(1).optional(),
     /**
      * How much to prioritize sampling speed (latency) when selecting a model.
      */
-    speedPriority: optional(number().min(0).max(1)),
+    speedPriority: number$1().min(0).max(1).optional(),
     /**
      * How much to prioritize intelligence and capabilities when selecting a model.
      */
-    intelligencePriority: optional(number().min(0).max(1))
+    intelligencePriority: number$1().min(0).max(1).optional()
   });
   const ToolChoiceSchema = object$1({
     /**
@@ -11222,20 +11516,21 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * - "required": Model MUST use at least one tool before completing
      * - "none": Model MUST NOT use any tools
      */
-    mode: optional(_enum(["auto", "required", "none"]))
+    mode: _enum(["auto", "required", "none"]).optional()
   });
   const ToolResultContentSchema = object$1({
     type: literal("tool_result"),
     toolUseId: string().describe("The unique identifier for the corresponding tool call."),
     content: array(ContentBlockSchema).default([]),
-    structuredContent: object$1({}).passthrough().optional(),
-    isError: optional(boolean()),
+    structuredContent: object$1({}).loose().optional(),
+    isError: 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: optional(object$1({}).passthrough())
-  }).passthrough();
+    _meta: record(string(), unknown()).optional()
+  });
+  const SamplingContentSchema = discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]);
   const SamplingMessageContentBlockSchema = discriminatedUnion("type", [
     TextContentSchema,
     ImageContentSchema,
@@ -11244,15 +11539,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     ToolResultContentSchema
   ]);
   const SamplingMessageSchema = object$1({
-    role: _enum(["user", "assistant"]),
+    role: RoleSchema,
     content: union([SamplingMessageContentBlockSchema, 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: optional(object$1({}).passthrough())
-  }).passthrough();
-  const CreateMessageRequestParamsSchema = BaseRequestParamsSchema.extend({
+    _meta: record(string(), unknown()).optional()
+  });
+  const CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
     messages: array(SamplingMessageSchema),
     /**
      * The server's preferences for which model to select. The client MAY modify or omit this request.
@@ -11270,13 +11565,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * declares ClientCapabilities.sampling.context. These values may be removed in future spec releases.
      */
     includeContext: _enum(["none", "thisServer", "allServers"]).optional(),
-    temperature: number().optional(),
+    temperature: number$1().optional(),
     /**
      * The requested maximum number of tokens to sample (to prevent runaway completions).
      *
      * The client MAY choose to sample fewer tokens than the requested maximum.
      */
-    maxTokens: number().int(),
+    maxTokens: number$1().int(),
     stopSequences: array(string()).optional(),
     /**
      * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.
@@ -11286,19 +11581,41 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * 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: optional(array(ToolSchema)),
+    tools: 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: optional(ToolChoiceSchema)
+    toolChoice: ToolChoiceSchema.optional()
   });
   const CreateMessageRequestSchema = RequestSchema.extend({
     method: literal("sampling/createMessage"),
     params: CreateMessageRequestParamsSchema
   });
   const CreateMessageResultSchema = ResultSchema.extend({
+    /**
+     * The name of the model that generated the message.
+     */
+    model: string(),
+    /**
+     * The reason why sampling stopped, if known.
+     *
+     * Standard values:
+     * - "endTurn": Natural end of the assistant's turn
+     * - "stopSequence": A stop sequence was encountered
+     * - "maxTokens": Maximum token limit was reached
+     *
+     * This field is an open string to allow for provider-specific stop reasons.
+     */
+    stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens"]).or(string())),
+    role: RoleSchema,
+    /**
+     * Response content. Single content block (text, image, or audio).
+     */
+    content: SamplingContentSchema
+  });
+  const CreateMessageResultWithToolsSchema = ResultSchema.extend({
     /**
      * The name of the model that generated the message.
      */
@@ -11315,9 +11632,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * This field is an open string to allow for provider-specific stop reasons.
      */
     stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(string())),
-    role: _enum(["user", "assistant"]),
+    role: RoleSchema,
     /**
-     * Response content. May be ToolUseContent if stopReason is "toolUse".
+     * Response content. May be a single block or array. May include ToolUseContent if stopReason is "toolUse".
      */
     content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)])
   });
@@ -11331,8 +11648,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     type: literal("string"),
     title: string().optional(),
     description: string().optional(),
-    minLength: number().optional(),
-    maxLength: number().optional(),
+    minLength: number$1().optional(),
+    maxLength: number$1().optional(),
     format: _enum(["email", "uri", "date", "date-time"]).optional(),
     default: string().optional()
   });
@@ -11340,9 +11657,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     type: _enum(["number", "integer"]),
     title: string().optional(),
     description: string().optional(),
-    minimum: number().optional(),
-    maximum: number().optional(),
-    default: number().optional()
+    minimum: number$1().optional(),
+    maximum: number$1().optional(),
+    default: number$1().optional()
   });
   const UntitledSingleSelectEnumSchemaSchema = object$1({
     type: literal("string"),
@@ -11374,8 +11691,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     type: literal("array"),
     title: string().optional(),
     description: string().optional(),
-    minItems: number().optional(),
-    maxItems: number().optional(),
+    minItems: number$1().optional(),
+    maxItems: number$1().optional(),
     items: object$1({
       type: literal("string"),
       enum: array(string())
@@ -11386,8 +11703,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     type: literal("array"),
     title: string().optional(),
     description: string().optional(),
-    minItems: number().optional(),
-    maxItems: number().optional(),
+    minItems: number$1().optional(),
+    maxItems: number$1().optional(),
     items: object$1({
       anyOf: array(object$1({
         const: string(),
@@ -11399,7 +11716,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   const MultiSelectEnumSchemaSchema = union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]);
   const EnumSchemaSchema = union([LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema]);
   const PrimitiveSchemaDefinitionSchema = union([EnumSchemaSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema]);
-  const ElicitRequestFormParamsSchema = BaseRequestParamsSchema.extend({
+  const ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({
     /**
      * The elicitation mode.
      *
@@ -11420,7 +11737,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       required: array(string()).optional()
     })
   });
-  const ElicitRequestURLParamsSchema = BaseRequestParamsSchema.extend({
+  const ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({
     /**
      * The elicitation mode.
      */
@@ -11465,8 +11782,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     /**
      * The submitted form data, only present when action is "accept".
      * Contains values matching the requested schema.
+     * Per MCP spec, content is "typically omitted" for decline/cancel actions.
+     * We normalize null to undefined for leniency while maintaining type compatibility.
      */
-    content: record(string(), union([string(), number(), boolean(), array(string())])).optional()
+    content: preprocess((val) => val === null ? void 0 : val, record(string(), union([string(), number$1(), boolean(), array(string())])).optional())
   });
   const ResourceTemplateReferenceSchema = object$1({
     type: literal("ref/resource"),
@@ -11528,7 +11847,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       /**
        * The total number of completion options available. This can exceed the number of values actually sent in the response.
        */
-      total: optional(number().int()),
+      total: optional(number$1().int()),
       /**
        * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
        */
@@ -11551,13 +11870,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     _meta: record(string(), unknown()).optional()
   });
   const ListRootsRequestSchema = RequestSchema.extend({
-    method: literal("roots/list")
+    method: literal("roots/list"),
+    params: BaseRequestParamsSchema.optional()
   });
   const ListRootsResultSchema = ResultSchema.extend({
     roots: array(RootSchema)
   });
   const RootsListChangedNotificationSchema = NotificationSchema.extend({
-    method: literal("notifications/roots/list_changed")
+    method: literal("notifications/roots/list_changed"),
+    params: NotificationsParamsSchema.optional()
   });
   const ClientRequestSchema = union([
     PingRequestSchema,
@@ -11572,16 +11893,39 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     SubscribeRequestSchema,
     UnsubscribeRequestSchema,
     CallToolRequestSchema,
-    ListToolsRequestSchema
+    ListToolsRequestSchema,
+    GetTaskRequestSchema,
+    GetTaskPayloadRequestSchema,
+    ListTasksRequestSchema,
+    CancelTaskRequestSchema
   ]);
   const ClientNotificationSchema = union([
     CancelledNotificationSchema,
     ProgressNotificationSchema,
     InitializedNotificationSchema,
-    RootsListChangedNotificationSchema
+    RootsListChangedNotificationSchema,
+    TaskStatusNotificationSchema
+  ]);
+  const ClientResultSchema = union([
+    EmptyResultSchema,
+    CreateMessageResultSchema,
+    CreateMessageResultWithToolsSchema,
+    ElicitResultSchema,
+    ListRootsResultSchema,
+    GetTaskResultSchema,
+    ListTasksResultSchema,
+    CreateTaskResultSchema
+  ]);
+  const ServerRequestSchema = union([
+    PingRequestSchema,
+    CreateMessageRequestSchema,
+    ElicitRequestSchema,
+    ListRootsRequestSchema,
+    GetTaskRequestSchema,
+    GetTaskPayloadRequestSchema,
+    ListTasksRequestSchema,
+    CancelTaskRequestSchema
   ]);
-  const ClientResultSchema = union([EmptyResultSchema, CreateMessageResultSchema, ElicitResultSchema, ListRootsResultSchema]);
-  const ServerRequestSchema = union([PingRequestSchema, CreateMessageRequestSchema, ElicitRequestSchema, ListRootsRequestSchema]);
   const ServerNotificationSchema = union([
     CancelledNotificationSchema,
     ProgressNotificationSchema,
@@ -11590,6 +11934,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     ResourceListChangedNotificationSchema,
     ToolListChangedNotificationSchema,
     PromptListChangedNotificationSchema,
+    TaskStatusNotificationSchema,
     ElicitationCompleteNotificationSchema
   ]);
   const ServerResultSchema = union([
@@ -11602,7 +11947,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     ListResourceTemplatesResultSchema,
     ReadResourceResultSchema,
     CallToolResultSchema,
-    ListToolsResultSchema
+    ListToolsResultSchema,
+    GetTaskResultSchema,
+    ListTasksResultSchema,
+    CreateTaskResultSchema
   ]);
   class McpError extends Error {
     constructor(code2, message, data) {
@@ -11631,8 +11979,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       });
     }
     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 ?? [];
     }
   }
   const MAX_TEMPLATE_LENGTH = 1e6;
@@ -11802,7 +12149,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const name = part.name;
       switch (part.operator) {
         case "":
-          pattern2 = part.exploded ? "([^/]+(?:,[^/]+)*)" : "([^/,]+)";
+          pattern2 = part.exploded ? "([^/,]+(?:,[^/,]+)*)" : "([^/,]+)";
           break;
         case "+":
         case "#":
@@ -11812,7 +12159,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           pattern2 = "\\.([^/,]+)";
           break;
         case "/":
-          pattern2 = "/" + (part.exploded ? "([^/]+(?:,[^/]+)*)" : "([^/,]+)");
+          pattern2 = "/" + (part.exploded ? "([^/,]+(?:,[^/,]+)*)" : "([^/,]+)");
           break;
         default:
           pattern2 = "([^/]+)";
@@ -11870,7 +12217,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   function getCompleter(schema) {
     const meta = schema[COMPLETABLE_SYMBOL];
-    return meta === null || meta === void 0 ? void 0 : meta.complete;
+    return meta?.complete;
   }
   function unwrapCompletable(schema) {
     return schema;
@@ -11880,11 +12227,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     McpZodTypeKind["Completable"] = "McpCompletable";
   })(exports2.McpZodTypeKind || (exports2.McpZodTypeKind = {}));
   function getDisplayName(metadata2) {
-    var _a;
     if (metadata2.title !== void 0 && metadata2.title !== "") {
       return metadata2.title;
     }
-    if ((_a = metadata2.annotations) === null || _a === void 0 ? void 0 : _a.title) {
+    if ("annotations" in metadata2 && metadata2.annotations?.title) {
       return metadata2.annotations.title;
     }
     return metadata2.name;
@@ -15537,13 +15883,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return result;
   }
   function getObjectShape(schema) {
-    var _a, _b;
     if (!schema)
       return void 0;
     let rawShape;
     if (isZ4Schema(schema)) {
       const v4Schema = schema;
-      rawShape = (_b = (_a = v4Schema._zod) === null || _a === void 0 ? void 0 : _a.def) === null || _b === void 0 ? void 0 : _b.shape;
+      rawShape = v4Schema._zod?.def?.shape;
     } else {
       const v3Schema = schema;
       rawShape = v3Schema.shape;
@@ -15553,14 +15898,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     if (typeof rawShape === "function") {
       try {
         return rawShape();
-      } catch (_c) {
+      } catch {
         return void 0;
       }
     }
     return rawShape;
   }
   function normalizeObjectSchema(schema) {
-    var _a;
     if (!schema)
       return void 0;
     if (typeof schema === "object") {
@@ -15575,8 +15919,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     if (isZ4Schema(schema)) {
       const v4Schema = schema;
-      const def = (_a = v4Schema._zod) === null || _a === void 0 ? void 0 : _a.def;
-      if (def && (def.typeName === "object" || def.shape !== void 0)) {
+      const def = v4Schema._zod?.def;
+      if (def && (def.type === "object" || def.shape !== void 0)) {
         return schema;
       }
     } else {
@@ -15600,38 +15944,30 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       try {
         return JSON.stringify(error);
-      } catch (_a) {
+      } catch {
         return String(error);
       }
     }
     return String(error);
   }
   function getSchemaDescription(schema) {
-    var _a, _b, _c, _d;
-    if (isZ4Schema(schema)) {
-      const v4Schema = schema;
-      return (_b = (_a = v4Schema._zod) === null || _a === void 0 ? void 0 : _a.def) === null || _b === void 0 ? void 0 : _b.description;
-    }
-    const v3Schema = schema;
-    return (_c = schema.description) !== null && _c !== void 0 ? _c : (_d = v3Schema._def) === null || _d === void 0 ? void 0 : _d.description;
+    return schema.description;
   }
   function isSchemaOptional(schema) {
-    var _a, _b, _c;
     if (isZ4Schema(schema)) {
       const v4Schema = schema;
-      return ((_b = (_a = v4Schema._zod) === null || _a === void 0 ? void 0 : _a.def) === null || _b === void 0 ? void 0 : _b.typeName) === "ZodOptional";
+      return v4Schema._zod?.def?.type === "optional";
     }
     const v3Schema = schema;
     if (typeof schema.isOptional === "function") {
       return schema.isOptional();
     }
-    return ((_c = v3Schema._def) === null || _c === void 0 ? void 0 : _c.typeName) === "ZodOptional";
+    return v3Schema._def?.typeName === "ZodOptional";
   }
   function getLiteralValue(schema) {
-    var _a;
     if (isZ4Schema(schema)) {
       const v4Schema = schema;
-      const def2 = (_a = v4Schema._zod) === null || _a === void 0 ? void 0 : _a.def;
+      const def2 = v4Schema._zod?.def;
       if (def2) {
         if (def2.value !== void 0)
           return def2.value;
@@ -15654,6 +15990,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return directValue;
     return void 0;
   }
+  function isTerminal(status) {
+    return status === "completed" || status === "failed" || status === "cancelled";
+  }
   const ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
   const defaultOptions = {
     name: void 0,
@@ -16867,21 +17206,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return "draft-7";
   }
   function toJsonSchemaCompat(schema, opts) {
-    var _a, _b, _c;
     if (isZ4Schema(schema)) {
       return toJSONSchema(schema, {
-        target: mapMiniTarget(opts === null || opts === void 0 ? void 0 : opts.target),
-        io: (_a = opts === null || opts === void 0 ? void 0 : opts.pipeStrategy) !== null && _a !== void 0 ? _a : "input"
+        target: mapMiniTarget(opts?.target),
+        io: opts?.pipeStrategy ?? "input"
       });
     }
     return zodToJsonSchema(schema, {
-      strictUnions: (_b = opts === null || opts === void 0 ? void 0 : opts.strictUnions) !== null && _b !== void 0 ? _b : true,
-      pipeStrategy: (_c = opts === null || opts === void 0 ? void 0 : opts.pipeStrategy) !== null && _c !== void 0 ? _c : "input"
+      strictUnions: opts?.strictUnions ?? true,
+      pipeStrategy: opts?.pipeStrategy ?? "input"
     });
   }
   function getMethodLiteral(schema) {
     const shape = getObjectShape(schema);
-    const methodSchema = shape === null || shape === void 0 ? void 0 : shape.method;
+    const methodSchema = shape?.method;
     if (!methodSchema) {
       throw new Error("Schema is missing a method literal");
     }
@@ -16910,9 +17248,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this._progressHandlers = /* @__PURE__ */ new Map();
       this._timeoutInfo = /* @__PURE__ */ new Map();
       this._pendingDebouncedNotifications = /* @__PURE__ */ new Set();
+      this._taskProgressTokens = /* @__PURE__ */ new Map();
+      this._requestResolvers = /* @__PURE__ */ new Map();
       this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
-        const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
-        controller === null || controller === void 0 ? void 0 : controller.abort(notification.params.reason);
+        this._oncancel(notification);
       });
       this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
         this._onprogress(notification);
@@ -16922,6 +17261,117 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         // Automatic pong by default.
         (_request) => ({})
       );
+      this._taskStore = _options?.taskStore;
+      this._taskMessageQueue = _options?.taskMessageQueue;
+      if (this._taskStore) {
+        this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
+          const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+          if (!task) {
+            throw new McpError(exports2.ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+          }
+          return {
+            ...task
+          };
+        });
+        this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
+          const handleTaskResult = async () => {
+            const taskId = request.params.taskId;
+            if (this._taskMessageQueue) {
+              let queuedMessage;
+              while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
+                if (queuedMessage.type === "response" || queuedMessage.type === "error") {
+                  const message = queuedMessage.message;
+                  const requestId = message.id;
+                  const resolver = this._requestResolvers.get(requestId);
+                  if (resolver) {
+                    this._requestResolvers.delete(requestId);
+                    if (queuedMessage.type === "response") {
+                      resolver(message);
+                    } else {
+                      const errorMessage = message;
+                      const error = new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data);
+                      resolver(error);
+                    }
+                  } else {
+                    const messageType = queuedMessage.type === "response" ? "Response" : "Error";
+                    this._onerror(new Error(`${messageType} handler missing for request ${requestId}`));
+                  }
+                  continue;
+                }
+                await this._transport?.send(queuedMessage.message, { relatedRequestId: extra.requestId });
+              }
+            }
+            const task = await this._taskStore.getTask(taskId, extra.sessionId);
+            if (!task) {
+              throw new McpError(exports2.ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+            }
+            if (!isTerminal(task.status)) {
+              await this._waitForTaskUpdate(taskId, extra.signal);
+              return await handleTaskResult();
+            }
+            if (isTerminal(task.status)) {
+              const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
+              this._clearTaskQueue(taskId);
+              return {
+                ...result,
+                _meta: {
+                  ...result._meta,
+                  [RELATED_TASK_META_KEY]: {
+                    taskId
+                  }
+                }
+              };
+            }
+            return await handleTaskResult();
+          };
+          return await handleTaskResult();
+        });
+        this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
+          try {
+            const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
+            return {
+              tasks,
+              nextCursor,
+              _meta: {}
+            };
+          } catch (error) {
+            throw new McpError(exports2.ErrorCode.InvalidParams, `Failed to list tasks: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        });
+        this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => {
+          try {
+            const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+            if (!task) {
+              throw new McpError(exports2.ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
+            }
+            if (isTerminal(task.status)) {
+              throw new McpError(exports2.ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
+            }
+            await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
+            this._clearTaskQueue(request.params.taskId);
+            const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+            if (!cancelledTask) {
+              throw new McpError(exports2.ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
+            }
+            return {
+              _meta: {},
+              ...cancelledTask
+            };
+          } catch (error) {
+            if (error instanceof McpError) {
+              throw error;
+            }
+            throw new McpError(exports2.ErrorCode.InvalidRequest, `Failed to cancel task: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        });
+      }
+    }
+    async _oncancel(notification) {
+      if (!notification.params.requestId) {
+        return;
+      }
+      const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
+      controller?.abort(notification.params.reason);
     }
     _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
       this._timeoutInfo.set(messageId, {
@@ -16962,22 +17412,21 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
      */
     async connect(transport) {
-      var _a, _b, _c;
       this._transport = transport;
-      const _onclose = (_a = this.transport) === null || _a === void 0 ? void 0 : _a.onclose;
+      const _onclose = this.transport?.onclose;
       this._transport.onclose = () => {
-        _onclose === null || _onclose === void 0 ? void 0 : _onclose();
+        _onclose?.();
         this._onclose();
       };
-      const _onerror = (_b = this.transport) === null || _b === void 0 ? void 0 : _b.onerror;
+      const _onerror = this.transport?.onerror;
       this._transport.onerror = (error) => {
-        _onerror === null || _onerror === void 0 ? void 0 : _onerror(error);
+        _onerror?.(error);
         this._onerror(error);
       };
-      const _onmessage = (_c = this._transport) === null || _c === void 0 ? void 0 : _c.onmessage;
+      const _onmessage = this._transport?.onmessage;
       this._transport.onmessage = (message, extra) => {
-        _onmessage === null || _onmessage === void 0 ? void 0 : _onmessage(message, extra);
-        if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
+        _onmessage?.(message, extra);
+        if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
           this._onresponse(message);
         } else if (isJSONRPCRequest(message)) {
           this._onrequest(message, extra);
@@ -16990,80 +17439,131 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       await this._transport.start();
     }
     _onclose() {
-      var _a;
       const responseHandlers = this._responseHandlers;
       this._responseHandlers = /* @__PURE__ */ new Map();
       this._progressHandlers.clear();
+      this._taskProgressTokens.clear();
       this._pendingDebouncedNotifications.clear();
-      this._transport = void 0;
-      (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
       const error = McpError.fromError(exports2.ErrorCode.ConnectionClosed, "Connection closed");
+      this._transport = void 0;
+      this.onclose?.();
       for (const handler of responseHandlers.values()) {
         handler(error);
       }
     }
     _onerror(error) {
-      var _a;
-      (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+      this.onerror?.(error);
     }
     _onnotification(notification) {
-      var _a;
-      const handler = (_a = this._notificationHandlers.get(notification.method)) !== null && _a !== void 0 ? _a : this.fallbackNotificationHandler;
+      const handler = this._notificationHandlers.get(notification.method) ?? this.fallbackNotificationHandler;
       if (handler === void 0) {
         return;
       }
       Promise.resolve().then(() => handler(notification)).catch((error) => this._onerror(new Error(`Uncaught error in notification handler: ${error}`)));
     }
     _onrequest(request, extra) {
-      var _a, _b;
-      const handler = (_a = this._requestHandlers.get(request.method)) !== null && _a !== void 0 ? _a : this.fallbackRequestHandler;
+      const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
       const capturedTransport = this._transport;
+      const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
       if (handler === void 0) {
-        capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
+        const errorResponse = {
           jsonrpc: "2.0",
           id: request.id,
           error: {
             code: exports2.ErrorCode.MethodNotFound,
             message: "Method not found"
           }
-        }).catch((error) => this._onerror(new Error(`Failed to send an error response: ${error}`)));
+        };
+        if (relatedTaskId && this._taskMessageQueue) {
+          this._enqueueTaskMessage(relatedTaskId, {
+            type: "error",
+            message: errorResponse,
+            timestamp: Date.now()
+          }, capturedTransport?.sessionId).catch((error) => this._onerror(new Error(`Failed to enqueue error response: ${error}`)));
+        } else {
+          capturedTransport?.send(errorResponse).catch((error) => this._onerror(new Error(`Failed to send an error response: ${error}`)));
+        }
         return;
       }
       const abortController = new AbortController();
       this._requestHandlerAbortControllers.set(request.id, abortController);
+      const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : void 0;
+      const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : void 0;
       const fullExtra = {
         signal: abortController.signal,
-        sessionId: capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId,
-        _meta: (_b = request.params) === null || _b === void 0 ? void 0 : _b._meta,
-        sendNotification: (notification) => this.notification(notification, { relatedRequestId: request.id }),
-        sendRequest: (r, resultSchema, options) => this.request(r, resultSchema, { ...options, relatedRequestId: request.id }),
-        authInfo: extra === null || extra === void 0 ? void 0 : extra.authInfo,
+        sessionId: capturedTransport?.sessionId,
+        _meta: request.params?._meta,
+        sendNotification: async (notification) => {
+          const notificationOptions = { relatedRequestId: request.id };
+          if (relatedTaskId) {
+            notificationOptions.relatedTask = { taskId: relatedTaskId };
+          }
+          await this.notification(notification, notificationOptions);
+        },
+        sendRequest: async (r, resultSchema, options) => {
+          const requestOptions = { ...options, relatedRequestId: request.id };
+          if (relatedTaskId && !requestOptions.relatedTask) {
+            requestOptions.relatedTask = { taskId: relatedTaskId };
+          }
+          const effectiveTaskId = requestOptions.relatedTask?.taskId ?? relatedTaskId;
+          if (effectiveTaskId && taskStore) {
+            await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
+          }
+          return await this.request(r, resultSchema, requestOptions);
+        },
+        authInfo: extra?.authInfo,
         requestId: request.id,
-        requestInfo: extra === null || extra === void 0 ? void 0 : extra.requestInfo
+        requestInfo: extra?.requestInfo,
+        taskId: relatedTaskId,
+        taskStore,
+        taskRequestedTtl: taskCreationParams?.ttl,
+        closeSSEStream: extra?.closeSSEStream,
+        closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
       };
-      Promise.resolve().then(() => handler(request, fullExtra)).then((result) => {
+      Promise.resolve().then(() => {
+        if (taskCreationParams) {
+          this.assertTaskHandlerCapability(request.method);
+        }
+      }).then(() => handler(request, fullExtra)).then(async (result) => {
         if (abortController.signal.aborted) {
           return;
         }
-        return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
+        const response = {
           result,
           jsonrpc: "2.0",
           id: request.id
-        });
-      }, (error) => {
-        var _a2;
+        };
+        if (relatedTaskId && this._taskMessageQueue) {
+          await this._enqueueTaskMessage(relatedTaskId, {
+            type: "response",
+            message: response,
+            timestamp: Date.now()
+          }, capturedTransport?.sessionId);
+        } else {
+          await capturedTransport?.send(response);
+        }
+      }, async (error) => {
         if (abortController.signal.aborted) {
           return;
         }
-        return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
+        const errorResponse = {
           jsonrpc: "2.0",
           id: request.id,
           error: {
             code: Number.isSafeInteger(error["code"]) ? error["code"] : exports2.ErrorCode.InternalError,
-            message: (_a2 = error.message) !== null && _a2 !== void 0 ? _a2 : "Internal error",
+            message: error.message ?? "Internal error",
             ...error["data"] !== void 0 && { data: error["data"] }
           }
-        });
+        };
+        if (relatedTaskId && this._taskMessageQueue) {
+          await this._enqueueTaskMessage(relatedTaskId, {
+            type: "error",
+            message: errorResponse,
+            timestamp: Date.now()
+          }, capturedTransport?.sessionId);
+        } else {
+          await capturedTransport?.send(errorResponse);
+        }
       }).catch((error) => this._onerror(new Error(`Failed to send response: ${error}`))).finally(() => {
         this._requestHandlerAbortControllers.delete(request.id);
       });
@@ -17082,6 +17582,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         try {
           this._resetTimeout(messageId);
         } catch (error) {
+          this._responseHandlers.delete(messageId);
+          this._progressHandlers.delete(messageId);
+          this._cleanupTimeout(messageId);
           responseHandler(error);
           return;
         }
@@ -17090,15 +17593,39 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     _onresponse(response) {
       const messageId = Number(response.id);
+      const resolver = this._requestResolvers.get(messageId);
+      if (resolver) {
+        this._requestResolvers.delete(messageId);
+        if (isJSONRPCResultResponse(response)) {
+          resolver(response);
+        } else {
+          const error = new McpError(response.error.code, response.error.message, response.error.data);
+          resolver(error);
+        }
+        return;
+      }
       const handler = this._responseHandlers.get(messageId);
       if (handler === void 0) {
         this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
         return;
       }
       this._responseHandlers.delete(messageId);
-      this._progressHandlers.delete(messageId);
       this._cleanupTimeout(messageId);
-      if (isJSONRPCResponse(response)) {
+      let isTaskResponse = false;
+      if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") {
+        const result = response.result;
+        if (result.task && typeof result.task === "object") {
+          const task = result.task;
+          if (typeof task.taskId === "string") {
+            isTaskResponse = true;
+            this._taskProgressTokens.set(task.taskId, messageId);
+          }
+        }
+      }
+      if (!isTaskResponse) {
+        this._progressHandlers.delete(messageId);
+      }
+      if (isJSONRPCResultResponse(response)) {
         handler(response);
       } else {
         const error = McpError.fromError(response.error.code, response.error.message, response.error.data);
@@ -17112,60 +17639,169 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * Closes the connection.
      */
     async close() {
-      var _a;
-      await ((_a = this._transport) === null || _a === void 0 ? void 0 : _a.close());
+      await this._transport?.close();
+    }
+    /**
+     * Sends a request and returns an AsyncGenerator that yields response messages.
+     * The generator is guaranteed to end with either a 'result' or 'error' message.
+     *
+     * @example
+     * ```typescript
+     * const stream = protocol.requestStream(request, resultSchema, options);
+     * for await (const message of stream) {
+     *   switch (message.type) {
+     *     case 'taskCreated':
+     *       console.log('Task created:', message.task.taskId);
+     *       break;
+     *     case 'taskStatus':
+     *       console.log('Task status:', message.task.status);
+     *       break;
+     *     case 'result':
+     *       console.log('Final result:', message.result);
+     *       break;
+     *     case 'error':
+     *       console.error('Error:', message.error);
+     *       break;
+     *   }
+     * }
+     * ```
+     *
+     * @experimental Use `client.experimental.tasks.requestStream()` to access this method.
+     */
+    async *requestStream(request, resultSchema, options) {
+      const { task } = options ?? {};
+      if (!task) {
+        try {
+          const result = await this.request(request, resultSchema, options);
+          yield { type: "result", result };
+        } catch (error) {
+          yield {
+            type: "error",
+            error: error instanceof McpError ? error : new McpError(exports2.ErrorCode.InternalError, String(error))
+          };
+        }
+        return;
+      }
+      let taskId;
+      try {
+        const createResult = await this.request(request, CreateTaskResultSchema, options);
+        if (createResult.task) {
+          taskId = createResult.task.taskId;
+          yield { type: "taskCreated", task: createResult.task };
+        } else {
+          throw new McpError(exports2.ErrorCode.InternalError, "Task creation did not return a task");
+        }
+        while (true) {
+          const task2 = await this.getTask({ taskId }, options);
+          yield { type: "taskStatus", task: task2 };
+          if (isTerminal(task2.status)) {
+            if (task2.status === "completed") {
+              const result = await this.getTaskResult({ taskId }, resultSchema, options);
+              yield { type: "result", result };
+            } else if (task2.status === "failed") {
+              yield {
+                type: "error",
+                error: new McpError(exports2.ErrorCode.InternalError, `Task ${taskId} failed`)
+              };
+            } else if (task2.status === "cancelled") {
+              yield {
+                type: "error",
+                error: new McpError(exports2.ErrorCode.InternalError, `Task ${taskId} was cancelled`)
+              };
+            }
+            return;
+          }
+          if (task2.status === "input_required") {
+            const result = await this.getTaskResult({ taskId }, resultSchema, options);
+            yield { type: "result", result };
+            return;
+          }
+          const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
+          await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+          options?.signal?.throwIfAborted();
+        }
+      } catch (error) {
+        yield {
+          type: "error",
+          error: error instanceof McpError ? error : new McpError(exports2.ErrorCode.InternalError, String(error))
+        };
+      }
     }
     /**
-     * Sends a request and wait for a response.
+     * Sends a request and waits for a response.
      *
      * Do not use this method to emit notifications! Use notification() instead.
      */
     request(request, resultSchema, options) {
-      const { relatedRequestId, resumptionToken, onresumptiontoken } = options !== null && options !== void 0 ? options : {};
+      const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
       return new Promise((resolve2, reject) => {
-        var _a, _b, _c, _d, _e, _f;
+        const earlyReject = (error) => {
+          reject(error);
+        };
         if (!this._transport) {
-          reject(new Error("Not connected"));
+          earlyReject(new Error("Not connected"));
           return;
         }
-        if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.enforceStrictCapabilities) === true) {
-          this.assertCapabilityForMethod(request.method);
+        if (this._options?.enforceStrictCapabilities === true) {
+          try {
+            this.assertCapabilityForMethod(request.method);
+            if (task) {
+              this.assertTaskCapability(request.method);
+            }
+          } catch (e) {
+            earlyReject(e);
+            return;
+          }
         }
-        (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
+        options?.signal?.throwIfAborted();
         const messageId = this._requestMessageId++;
         const jsonrpcRequest = {
           ...request,
           jsonrpc: "2.0",
           id: messageId
         };
-        if (options === null || options === void 0 ? void 0 : options.onprogress) {
+        if (options?.onprogress) {
           this._progressHandlers.set(messageId, options.onprogress);
           jsonrpcRequest.params = {
             ...request.params,
             _meta: {
-              ...((_c = request.params) === null || _c === void 0 ? void 0 : _c._meta) || {},
+              ...request.params?._meta || {},
               progressToken: messageId
             }
           };
         }
+        if (task) {
+          jsonrpcRequest.params = {
+            ...jsonrpcRequest.params,
+            task
+          };
+        }
+        if (relatedTask) {
+          jsonrpcRequest.params = {
+            ...jsonrpcRequest.params,
+            _meta: {
+              ...jsonrpcRequest.params?._meta || {},
+              [RELATED_TASK_META_KEY]: relatedTask
+            }
+          };
+        }
         const cancel = (reason) => {
-          var _a2;
           this._responseHandlers.delete(messageId);
           this._progressHandlers.delete(messageId);
           this._cleanupTimeout(messageId);
-          (_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.send({
+          this._transport?.send({
             jsonrpc: "2.0",
             method: "notifications/cancelled",
             params: {
               requestId: messageId,
               reason: String(reason)
             }
-          }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => this._onerror(new Error(`Failed to send cancellation: ${error}`)));
-          reject(reason);
+          }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error2) => this._onerror(new Error(`Failed to send cancellation: ${error2}`)));
+          const error = reason instanceof McpError ? reason : new McpError(exports2.ErrorCode.RequestTimeout, String(reason));
+          reject(error);
         };
         this._responseHandlers.set(messageId, (response) => {
-          var _a2;
-          if ((_a2 = options === null || options === void 0 ? void 0 : options.signal) === null || _a2 === void 0 ? void 0 : _a2.aborted) {
+          if (options?.signal?.aborted) {
             return;
           }
           if (response instanceof Error) {
@@ -17182,53 +17818,147 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             reject(error);
           }
         });
-        (_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.addEventListener("abort", () => {
-          var _a2;
-          cancel((_a2 = options === null || options === void 0 ? void 0 : options.signal) === null || _a2 === void 0 ? void 0 : _a2.reason);
+        options?.signal?.addEventListener("abort", () => {
+          cancel(options?.signal?.reason);
         });
-        const timeout = (_e = options === null || options === void 0 ? void 0 : options.timeout) !== null && _e !== void 0 ? _e : DEFAULT_REQUEST_TIMEOUT_MSEC;
+        const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
         const timeoutHandler = () => cancel(McpError.fromError(exports2.ErrorCode.RequestTimeout, "Request timed out", { timeout }));
-        this._setupTimeout(messageId, timeout, options === null || options === void 0 ? void 0 : options.maxTotalTimeout, timeoutHandler, (_f = options === null || options === void 0 ? void 0 : options.resetTimeoutOnProgress) !== null && _f !== void 0 ? _f : false);
-        this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => {
-          this._cleanupTimeout(messageId);
-          reject(error);
-        });
+        this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
+        const relatedTaskId = relatedTask?.taskId;
+        if (relatedTaskId) {
+          const responseResolver = (response) => {
+            const handler = this._responseHandlers.get(messageId);
+            if (handler) {
+              handler(response);
+            } else {
+              this._onerror(new Error(`Response handler missing for side-channeled request ${messageId}`));
+            }
+          };
+          this._requestResolvers.set(messageId, responseResolver);
+          this._enqueueTaskMessage(relatedTaskId, {
+            type: "request",
+            message: jsonrpcRequest,
+            timestamp: Date.now()
+          }).catch((error) => {
+            this._cleanupTimeout(messageId);
+            reject(error);
+          });
+        } else {
+          this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => {
+            this._cleanupTimeout(messageId);
+            reject(error);
+          });
+        }
       });
     }
+    /**
+     * Gets the current status of a task.
+     *
+     * @experimental Use `client.experimental.tasks.getTask()` to access this method.
+     */
+    async getTask(params, options) {
+      return this.request({ method: "tasks/get", params }, GetTaskResultSchema, options);
+    }
+    /**
+     * Retrieves the result of a completed task.
+     *
+     * @experimental Use `client.experimental.tasks.getTaskResult()` to access this method.
+     */
+    async getTaskResult(params, resultSchema, options) {
+      return this.request({ method: "tasks/result", params }, resultSchema, options);
+    }
+    /**
+     * Lists tasks, optionally starting from a pagination cursor.
+     *
+     * @experimental Use `client.experimental.tasks.listTasks()` to access this method.
+     */
+    async listTasks(params, options) {
+      return this.request({ method: "tasks/list", params }, ListTasksResultSchema, options);
+    }
+    /**
+     * Cancels a specific task.
+     *
+     * @experimental Use `client.experimental.tasks.cancelTask()` to access this method.
+     */
+    async cancelTask(params, options) {
+      return this.request({ method: "tasks/cancel", params }, CancelTaskResultSchema, options);
+    }
     /**
      * Emits a notification, which is a one-way message that does not expect a response.
      */
     async notification(notification, options) {
-      var _a, _b;
       if (!this._transport) {
         throw new Error("Not connected");
       }
       this.assertNotificationCapability(notification.method);
-      const debouncedMethods = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.debouncedNotificationMethods) !== null && _b !== void 0 ? _b : [];
-      const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !(options === null || options === void 0 ? void 0 : options.relatedRequestId);
+      const relatedTaskId = options?.relatedTask?.taskId;
+      if (relatedTaskId) {
+        const jsonrpcNotification2 = {
+          ...notification,
+          jsonrpc: "2.0",
+          params: {
+            ...notification.params,
+            _meta: {
+              ...notification.params?._meta || {},
+              [RELATED_TASK_META_KEY]: options.relatedTask
+            }
+          }
+        };
+        await this._enqueueTaskMessage(relatedTaskId, {
+          type: "notification",
+          message: jsonrpcNotification2,
+          timestamp: Date.now()
+        });
+        return;
+      }
+      const debouncedMethods = this._options?.debouncedNotificationMethods ?? [];
+      const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !options?.relatedRequestId && !options?.relatedTask;
       if (canDebounce) {
         if (this._pendingDebouncedNotifications.has(notification.method)) {
           return;
         }
         this._pendingDebouncedNotifications.add(notification.method);
         Promise.resolve().then(() => {
-          var _a2;
           this._pendingDebouncedNotifications.delete(notification.method);
           if (!this._transport) {
             return;
           }
-          const jsonrpcNotification2 = {
+          let jsonrpcNotification2 = {
             ...notification,
             jsonrpc: "2.0"
           };
-          (_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.send(jsonrpcNotification2, options).catch((error) => this._onerror(error));
+          if (options?.relatedTask) {
+            jsonrpcNotification2 = {
+              ...jsonrpcNotification2,
+              params: {
+                ...jsonrpcNotification2.params,
+                _meta: {
+                  ...jsonrpcNotification2.params?._meta || {},
+                  [RELATED_TASK_META_KEY]: options.relatedTask
+                }
+              }
+            };
+          }
+          this._transport?.send(jsonrpcNotification2, options).catch((error) => this._onerror(error));
         });
         return;
       }
-      const jsonrpcNotification = {
+      let jsonrpcNotification = {
         ...notification,
         jsonrpc: "2.0"
       };
+      if (options?.relatedTask) {
+        jsonrpcNotification = {
+          ...jsonrpcNotification,
+          params: {
+            ...jsonrpcNotification.params,
+            _meta: {
+              ...jsonrpcNotification.params?._meta || {},
+              [RELATED_TASK_META_KEY]: options.relatedTask
+            }
+          }
+        };
+      }
       await this._transport.send(jsonrpcNotification, options);
     }
     /**
@@ -17276,6 +18006,150 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     removeNotificationHandler(method) {
       this._notificationHandlers.delete(method);
     }
+    /**
+     * Cleans up the progress handler associated with a task.
+     * This should be called when a task reaches a terminal status.
+     */
+    _cleanupTaskProgressHandler(taskId) {
+      const progressToken = this._taskProgressTokens.get(taskId);
+      if (progressToken !== void 0) {
+        this._progressHandlers.delete(progressToken);
+        this._taskProgressTokens.delete(taskId);
+      }
+    }
+    /**
+     * Enqueues a task-related message for side-channel delivery via tasks/result.
+     * @param taskId The task ID to associate the message with
+     * @param message The message to enqueue
+     * @param sessionId Optional session ID for binding the operation to a specific session
+     * @throws Error if taskStore is not configured or if enqueue fails (e.g., queue overflow)
+     *
+     * Note: If enqueue fails, it's the TaskMessageQueue implementation's responsibility to handle
+     * the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer
+     * simply propagates the error.
+     */
+    async _enqueueTaskMessage(taskId, message, sessionId) {
+      if (!this._taskStore || !this._taskMessageQueue) {
+        throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
+      }
+      const maxQueueSize = this._options?.maxTaskQueueSize;
+      await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+    }
+    /**
+     * Clears the message queue for a task and rejects any pending request resolvers.
+     * @param taskId The task ID whose queue should be cleared
+     * @param sessionId Optional session ID for binding the operation to a specific session
+     */
+    async _clearTaskQueue(taskId, sessionId) {
+      if (this._taskMessageQueue) {
+        const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
+        for (const message of messages) {
+          if (message.type === "request" && isJSONRPCRequest(message.message)) {
+            const requestId = message.message.id;
+            const resolver = this._requestResolvers.get(requestId);
+            if (resolver) {
+              resolver(new McpError(exports2.ErrorCode.InternalError, "Task cancelled or completed"));
+              this._requestResolvers.delete(requestId);
+            } else {
+              this._onerror(new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
+            }
+          }
+        }
+      }
+    }
+    /**
+     * Waits for a task update (new messages or status change) with abort signal support.
+     * Uses polling to check for updates at the task's configured poll interval.
+     * @param taskId The task ID to wait for
+     * @param signal Abort signal to cancel the wait
+     * @returns Promise that resolves when an update occurs or rejects if aborted
+     */
+    async _waitForTaskUpdate(taskId, signal) {
+      let interval = this._options?.defaultTaskPollInterval ?? 1e3;
+      try {
+        const task = await this._taskStore?.getTask(taskId);
+        if (task?.pollInterval) {
+          interval = task.pollInterval;
+        }
+      } catch {
+      }
+      return new Promise((resolve2, reject) => {
+        if (signal.aborted) {
+          reject(new McpError(exports2.ErrorCode.InvalidRequest, "Request cancelled"));
+          return;
+        }
+        const timeoutId = setTimeout(resolve2, interval);
+        signal.addEventListener("abort", () => {
+          clearTimeout(timeoutId);
+          reject(new McpError(exports2.ErrorCode.InvalidRequest, "Request cancelled"));
+        }, { once: true });
+      });
+    }
+    requestTaskStore(request, sessionId) {
+      const taskStore = this._taskStore;
+      if (!taskStore) {
+        throw new Error("No task store configured");
+      }
+      return {
+        createTask: async (taskParams) => {
+          if (!request) {
+            throw new Error("No request provided");
+          }
+          return await taskStore.createTask(taskParams, request.id, {
+            method: request.method,
+            params: request.params
+          }, sessionId);
+        },
+        getTask: async (taskId) => {
+          const task = await taskStore.getTask(taskId, sessionId);
+          if (!task) {
+            throw new McpError(exports2.ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+          }
+          return task;
+        },
+        storeTaskResult: async (taskId, status, result) => {
+          await taskStore.storeTaskResult(taskId, status, result, sessionId);
+          const task = await taskStore.getTask(taskId, sessionId);
+          if (task) {
+            const notification = TaskStatusNotificationSchema.parse({
+              method: "notifications/tasks/status",
+              params: task
+            });
+            await this.notification(notification);
+            if (isTerminal(task.status)) {
+              this._cleanupTaskProgressHandler(taskId);
+            }
+          }
+        },
+        getTaskResult: (taskId) => {
+          return taskStore.getTaskResult(taskId, sessionId);
+        },
+        updateTaskStatus: async (taskId, status, statusMessage) => {
+          const task = await taskStore.getTask(taskId, sessionId);
+          if (!task) {
+            throw new McpError(exports2.ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
+          }
+          if (isTerminal(task.status)) {
+            throw new McpError(exports2.ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
+          }
+          await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
+          const updatedTask = await taskStore.getTask(taskId, sessionId);
+          if (updatedTask) {
+            const notification = TaskStatusNotificationSchema.parse({
+              method: "notifications/tasks/status",
+              params: updatedTask
+            });
+            await this.notification(notification);
+            if (isTerminal(updatedTask.status)) {
+              this._cleanupTaskProgressHandler(taskId);
+            }
+          }
+        },
+        listTasks: (cursor) => {
+          return taskStore.listTasks(cursor, sessionId);
+        }
+      };
+    }
   }
   function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -17622,7 +18496,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   var distExports = requireDist();
   const _addFormats = /* @__PURE__ */ getDefaultExportFromCjs(distExports);
   function createDefaultAjvInstance() {
-    const ajv2 = new ajvExports.Ajv({
+    const ajv2 = new Ajv({
       strict: false,
       validateFormats: true,
       validateSchema: false,
@@ -17654,7 +18528,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * ```
      */
     constructor(ajv2) {
-      this._ajv = ajv2 !== null && ajv2 !== void 0 ? ajv2 : createDefaultAjvInstance();
+      this._ajv = ajv2 ?? createDefaultAjvInstance();
     }
     /**
      * Create a validator for the given JSON Schema
@@ -17666,8 +18540,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * @returns A validator function that validates input data
      */
     getValidator(schema) {
-      var _a;
-      const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? (_a = this._ajv.getSchema(schema.$id)) !== null && _a !== void 0 ? _a : this._ajv.compile(schema) : this._ajv.compile(schema);
+      const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema);
       return (input) => {
         const valid = ajvValidator(input);
         if (valid) {
@@ -17686,6 +18559,187 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       };
     }
   }
+  class ExperimentalClientTasks {
+    constructor(_client) {
+      this._client = _client;
+    }
+    /**
+     * Calls a tool and returns an AsyncGenerator that yields response messages.
+     * The generator is guaranteed to end with either a 'result' or 'error' message.
+     *
+     * This method provides streaming access to tool execution, allowing you to
+     * observe intermediate task status updates for long-running tool calls.
+     * Automatically validates structured output if the tool has an outputSchema.
+     *
+     * @example
+     * ```typescript
+     * const stream = client.experimental.tasks.callToolStream({ name: 'myTool', arguments: {} });
+     * for await (const message of stream) {
+     *   switch (message.type) {
+     *     case 'taskCreated':
+     *       console.log('Tool execution started:', message.task.taskId);
+     *       break;
+     *     case 'taskStatus':
+     *       console.log('Tool status:', message.task.status);
+     *       break;
+     *     case 'result':
+     *       console.log('Tool result:', message.result);
+     *       break;
+     *     case 'error':
+     *       console.error('Tool error:', message.error);
+     *       break;
+     *   }
+     * }
+     * ```
+     *
+     * @param params - Tool call parameters (name and arguments)
+     * @param resultSchema - Zod schema for validating the result (defaults to CallToolResultSchema)
+     * @param options - Optional request options (timeout, signal, task creation params, etc.)
+     * @returns AsyncGenerator that yields ResponseMessage objects
+     *
+     * @experimental
+     */
+    async *callToolStream(params, resultSchema = CallToolResultSchema, options) {
+      const clientInternal = this._client;
+      const optionsWithTask = {
+        ...options,
+        // We check if the tool is known to be a task during auto-configuration, but assume
+        // the caller knows what they're doing if they pass this explicitly
+        task: options?.task ?? (clientInternal.isToolTask(params.name) ? {} : void 0)
+      };
+      const stream = clientInternal.requestStream({ method: "tools/call", params }, resultSchema, optionsWithTask);
+      const validator = clientInternal.getToolOutputValidator(params.name);
+      for await (const message of stream) {
+        if (message.type === "result" && validator) {
+          const result = message.result;
+          if (!result.structuredContent && !result.isError) {
+            yield {
+              type: "error",
+              error: new McpError(exports2.ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`)
+            };
+            return;
+          }
+          if (result.structuredContent) {
+            try {
+              const validationResult = validator(result.structuredContent);
+              if (!validationResult.valid) {
+                yield {
+                  type: "error",
+                  error: new McpError(exports2.ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`)
+                };
+                return;
+              }
+            } catch (error) {
+              if (error instanceof McpError) {
+                yield { type: "error", error };
+                return;
+              }
+              yield {
+                type: "error",
+                error: new McpError(exports2.ErrorCode.InvalidParams, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`)
+              };
+              return;
+            }
+          }
+        }
+        yield message;
+      }
+    }
+    /**
+     * Gets the current status of a task.
+     *
+     * @param taskId - The task identifier
+     * @param options - Optional request options
+     * @returns The task status
+     *
+     * @experimental
+     */
+    async getTask(taskId, options) {
+      return this._client.getTask({ taskId }, options);
+    }
+    /**
+     * Retrieves the result of a completed task.
+     *
+     * @param taskId - The task identifier
+     * @param resultSchema - Zod schema for validating the result
+     * @param options - Optional request options
+     * @returns The task result
+     *
+     * @experimental
+     */
+    async getTaskResult(taskId, resultSchema, options) {
+      return this._client.getTaskResult({ taskId }, resultSchema, options);
+    }
+    /**
+     * Lists tasks with optional pagination.
+     *
+     * @param cursor - Optional pagination cursor
+     * @param options - Optional request options
+     * @returns List of tasks with optional next cursor
+     *
+     * @experimental
+     */
+    async listTasks(cursor, options) {
+      return this._client.listTasks(cursor ? { cursor } : void 0, options);
+    }
+    /**
+     * Cancels a running task.
+     *
+     * @param taskId - The task identifier
+     * @param options - Optional request options
+     *
+     * @experimental
+     */
+    async cancelTask(taskId, options) {
+      return this._client.cancelTask({ taskId }, options);
+    }
+    /**
+     * Sends a request and returns an AsyncGenerator that yields response messages.
+     * The generator is guaranteed to end with either a 'result' or 'error' message.
+     *
+     * This method provides streaming access to request processing, allowing you to
+     * observe intermediate task status updates for task-augmented requests.
+     *
+     * @param request - The request to send
+     * @param resultSchema - Zod schema for validating the result
+     * @param options - Optional request options (timeout, signal, task creation params, etc.)
+     * @returns AsyncGenerator that yields ResponseMessage objects
+     *
+     * @experimental
+     */
+    requestStream(request, resultSchema, options) {
+      return this._client.requestStream(request, resultSchema, options);
+    }
+  }
+  function assertToolsCallTaskCapability(requests, method, entityName) {
+    if (!requests) {
+      throw new Error(`${entityName} does not support task creation (required for ${method})`);
+    }
+    switch (method) {
+      case "tools/call":
+        if (!requests.tools?.call) {
+          throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+        }
+        break;
+    }
+  }
+  function assertClientRequestTaskCapability(requests, method, entityName) {
+    if (!requests) {
+      throw new Error(`${entityName} does not support task creation (required for ${method})`);
+    }
+    switch (method) {
+      case "sampling/createMessage":
+        if (!requests.sampling?.createMessage) {
+          throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+        }
+        break;
+      case "elicitation/create":
+        if (!requests.elicitation?.create) {
+          throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+        }
+        break;
+    }
+  }
   function applyElicitationDefaults(schema, data) {
     if (!schema || data === null || typeof data !== "object")
       return;
@@ -17704,12 +18758,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     if (Array.isArray(schema.anyOf)) {
       for (const sub of schema.anyOf) {
-        applyElicitationDefaults(sub, data);
+        if (typeof sub !== "boolean") {
+          applyElicitationDefaults(sub, data);
+        }
       }
     }
     if (Array.isArray(schema.oneOf)) {
       for (const sub of schema.oneOf) {
-        applyElicitationDefaults(sub, data);
+        if (typeof sub !== "boolean") {
+          applyElicitationDefaults(sub, data);
+        }
       }
     }
   }
@@ -17728,12 +18786,58 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * Initializes this client with the given name and version information.
      */
     constructor(_clientInfo, options) {
-      var _a, _b;
       super(options);
       this._clientInfo = _clientInfo;
       this._cachedToolOutputValidators = /* @__PURE__ */ new Map();
-      this._capabilities = (_a = options === null || options === void 0 ? void 0 : options.capabilities) !== null && _a !== void 0 ? _a : {};
-      this._jsonSchemaValidator = (_b = options === null || options === void 0 ? void 0 : options.jsonSchemaValidator) !== null && _b !== void 0 ? _b : new AjvJsonSchemaValidator();
+      this._cachedKnownTaskTools = /* @__PURE__ */ new Set();
+      this._cachedRequiredTaskTools = /* @__PURE__ */ new Set();
+      this._listChangedDebounceTimers = /* @__PURE__ */ new Map();
+      this._capabilities = options?.capabilities ?? {};
+      this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
+      if (options?.listChanged) {
+        this._pendingListChangedConfig = options.listChanged;
+      }
+    }
+    /**
+     * Set up handlers for list changed notifications based on config and server capabilities.
+     * This should only be called after initialization when server capabilities are known.
+     * Handlers are silently skipped if the server doesn't advertise the corresponding listChanged capability.
+     * @internal
+     */
+    _setupListChangedHandlers(config2) {
+      if (config2.tools && this._serverCapabilities?.tools?.listChanged) {
+        this._setupListChangedHandler("tools", ToolListChangedNotificationSchema, config2.tools, async () => {
+          const result = await this.listTools();
+          return result.tools;
+        });
+      }
+      if (config2.prompts && this._serverCapabilities?.prompts?.listChanged) {
+        this._setupListChangedHandler("prompts", PromptListChangedNotificationSchema, config2.prompts, async () => {
+          const result = await this.listPrompts();
+          return result.prompts;
+        });
+      }
+      if (config2.resources && this._serverCapabilities?.resources?.listChanged) {
+        this._setupListChangedHandler("resources", ResourceListChangedNotificationSchema, config2.resources, async () => {
+          const result = await this.listResources();
+          return result.resources;
+        });
+      }
+    }
+    /**
+     * Access experimental features.
+     *
+     * WARNING: These APIs are experimental and may change without notice.
+     *
+     * @experimental
+     */
+    get experimental() {
+      if (!this._experimental) {
+        this._experimental = {
+          tasks: new ExperimentalClientTasks(this)
+        };
+      }
+      return this._experimental;
     }
     /**
      * Registers new capabilities. This can only be called before connecting to a transport.
@@ -17750,21 +18854,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * Override request handler registration to enforce client-side validation for elicitation.
      */
     setRequestHandler(requestSchema, handler) {
-      var _a, _b, _c;
       const shape = getObjectShape(requestSchema);
-      const methodSchema = shape === null || shape === void 0 ? void 0 : shape.method;
+      const methodSchema = shape?.method;
       if (!methodSchema) {
         throw new Error("Schema is missing a method literal");
       }
       let methodValue;
       if (isZ4Schema(methodSchema)) {
         const v4Schema = methodSchema;
-        const v4Def = (_a = v4Schema._zod) === null || _a === void 0 ? void 0 : _a.def;
-        methodValue = (_b = v4Def === null || v4Def === void 0 ? void 0 : v4Def.value) !== null && _b !== void 0 ? _b : v4Schema.value;
+        const v4Def = v4Schema._zod?.def;
+        methodValue = v4Def?.value ?? v4Schema.value;
       } else {
         const v3Schema = methodSchema;
         const legacyDef = v3Schema._def;
-        methodValue = (_c = legacyDef === null || legacyDef === void 0 ? void 0 : legacyDef.value) !== null && _c !== void 0 ? _c : v3Schema.value;
+        methodValue = legacyDef?.value ?? v3Schema.value;
       }
       if (typeof methodValue !== "string") {
         throw new Error("Schema method literal must be a string");
@@ -17772,34 +18875,41 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const method = methodValue;
       if (method === "elicitation/create") {
         const wrappedHandler = async (request, extra) => {
-          var _a2, _b2, _c2;
           const validatedRequest = safeParse(ElicitRequestSchema, request);
           if (!validatedRequest.success) {
             const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
             throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid elicitation request: ${errorMessage}`);
           }
           const { params } = validatedRequest.data;
-          const mode = (_a2 = params.mode) !== null && _a2 !== void 0 ? _a2 : "form";
+          params.mode = params.mode ?? "form";
           const { supportsFormMode, supportsUrlMode } = getSupportedElicitationModes(this._capabilities.elicitation);
-          if (mode === "form" && !supportsFormMode) {
+          if (params.mode === "form" && !supportsFormMode) {
             throw new McpError(exports2.ErrorCode.InvalidParams, "Client does not support form-mode elicitation requests");
           }
-          if (mode === "url" && !supportsUrlMode) {
+          if (params.mode === "url" && !supportsUrlMode) {
             throw new McpError(exports2.ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
           }
           const result = await Promise.resolve(handler(request, extra));
+          if (params.task) {
+            const taskValidationResult = safeParse(CreateTaskResultSchema, result);
+            if (!taskValidationResult.success) {
+              const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+              throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+            }
+            return taskValidationResult.data;
+          }
           const validationResult = safeParse(ElicitResultSchema, result);
           if (!validationResult.success) {
             const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
             throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid elicitation result: ${errorMessage}`);
           }
           const validatedResult = validationResult.data;
-          const requestedSchema = mode === "form" ? params.requestedSchema : void 0;
-          if (mode === "form" && validatedResult.action === "accept" && validatedResult.content && requestedSchema) {
-            if ((_c2 = (_b2 = this._capabilities.elicitation) === null || _b2 === void 0 ? void 0 : _b2.form) === null || _c2 === void 0 ? void 0 : _c2.applyDefaults) {
+          const requestedSchema = params.mode === "form" ? params.requestedSchema : void 0;
+          if (params.mode === "form" && validatedResult.action === "accept" && validatedResult.content && requestedSchema) {
+            if (this._capabilities.elicitation?.form?.applyDefaults) {
               try {
                 applyElicitationDefaults(requestedSchema, validatedResult.content);
-              } catch (_d) {
+              } catch {
               }
             }
           }
@@ -17807,11 +18917,36 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         };
         return super.setRequestHandler(requestSchema, wrappedHandler);
       }
+      if (method === "sampling/createMessage") {
+        const wrappedHandler = async (request, extra) => {
+          const validatedRequest = safeParse(CreateMessageRequestSchema, request);
+          if (!validatedRequest.success) {
+            const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+            throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage}`);
+          }
+          const { params } = validatedRequest.data;
+          const result = await Promise.resolve(handler(request, extra));
+          if (params.task) {
+            const taskValidationResult = safeParse(CreateTaskResultSchema, result);
+            if (!taskValidationResult.success) {
+              const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+              throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+            }
+            return taskValidationResult.data;
+          }
+          const validationResult = safeParse(CreateMessageResultSchema, result);
+          if (!validationResult.success) {
+            const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+            throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid sampling result: ${errorMessage}`);
+          }
+          return validationResult.data;
+        };
+        return super.setRequestHandler(requestSchema, wrappedHandler);
+      }
       return super.setRequestHandler(requestSchema, handler);
     }
     assertCapability(capability, method) {
-      var _a;
-      if (!((_a = this._serverCapabilities) === null || _a === void 0 ? void 0 : _a[capability])) {
+      if (!this._serverCapabilities?.[capability]) {
         throw new Error(`Server does not support ${capability} (required for ${method})`);
       }
     }
@@ -17844,6 +18979,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         await this.notification({
           method: "notifications/initialized"
         });
+        if (this._pendingListChangedConfig) {
+          this._setupListChangedHandlers(this._pendingListChangedConfig);
+          this._pendingListChangedConfig = void 0;
+        }
       } catch (error) {
         void this.close();
         throw error;
@@ -17868,16 +19007,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return this._instructions;
     }
     assertCapabilityForMethod(method) {
-      var _a, _b, _c, _d, _e;
       switch (method) {
         case "logging/setLevel":
-          if (!((_a = this._serverCapabilities) === null || _a === void 0 ? void 0 : _a.logging)) {
+          if (!this._serverCapabilities?.logging) {
             throw new Error(`Server does not support logging (required for ${method})`);
           }
           break;
         case "prompts/get":
         case "prompts/list":
-          if (!((_b = this._serverCapabilities) === null || _b === void 0 ? void 0 : _b.prompts)) {
+          if (!this._serverCapabilities?.prompts) {
             throw new Error(`Server does not support prompts (required for ${method})`);
           }
           break;
@@ -17886,7 +19024,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         case "resources/read":
         case "resources/subscribe":
         case "resources/unsubscribe":
-          if (!((_c = this._serverCapabilities) === null || _c === void 0 ? void 0 : _c.resources)) {
+          if (!this._serverCapabilities?.resources) {
             throw new Error(`Server does not support resources (required for ${method})`);
           }
           if (method === "resources/subscribe" && !this._serverCapabilities.resources.subscribe) {
@@ -17895,28 +19033,30 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           break;
         case "tools/call":
         case "tools/list":
-          if (!((_d = this._serverCapabilities) === null || _d === void 0 ? void 0 : _d.tools)) {
+          if (!this._serverCapabilities?.tools) {
             throw new Error(`Server does not support tools (required for ${method})`);
           }
           break;
         case "completion/complete":
-          if (!((_e = this._serverCapabilities) === null || _e === void 0 ? void 0 : _e.completions)) {
+          if (!this._serverCapabilities?.completions) {
             throw new Error(`Server does not support completions (required for ${method})`);
           }
           break;
       }
     }
     assertNotificationCapability(method) {
-      var _a;
       switch (method) {
         case "notifications/roots/list_changed":
-          if (!((_a = this._capabilities.roots) === null || _a === void 0 ? void 0 : _a.listChanged)) {
+          if (!this._capabilities.roots?.listChanged) {
             throw new Error(`Client does not support roots list changed notifications (required for ${method})`);
           }
           break;
       }
     }
     assertRequestHandlerCapability(method) {
+      if (!this._capabilities) {
+        return;
+      }
       switch (method) {
         case "sampling/createMessage":
           if (!this._capabilities.sampling) {
@@ -17933,7 +19073,24 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             throw new Error(`Client does not support roots capability (required for ${method})`);
           }
           break;
+        case "tasks/get":
+        case "tasks/list":
+        case "tasks/result":
+        case "tasks/cancel":
+          if (!this._capabilities.tasks) {
+            throw new Error(`Client does not support tasks capability (required for ${method})`);
+          }
+          break;
+      }
+    }
+    assertTaskCapability(method) {
+      assertToolsCallTaskCapability(this._serverCapabilities?.tasks?.requests, method, "Server");
+    }
+    assertTaskHandlerCapability(method) {
+      if (!this._capabilities) {
+        return;
       }
+      assertClientRequestTaskCapability(this._capabilities.tasks?.requests, method, "Client");
     }
     async ping(options) {
       return this.request({ method: "ping" }, EmptyResultSchema, options);
@@ -17965,7 +19122,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     async unsubscribeResource(params, options) {
       return this.request({ method: "resources/unsubscribe", params }, EmptyResultSchema, options);
     }
+    /**
+     * Calls a tool and waits for the result. Automatically validates structured output if the tool has an outputSchema.
+     *
+     * For task-based execution with streaming behavior, use client.experimental.tasks.callToolStream() instead.
+     */
     async callTool(params, resultSchema = CallToolResultSchema, options) {
+      if (this.isToolTaskRequired(params.name)) {
+        throw new McpError(exports2.ErrorCode.InvalidRequest, `Tool "${params.name}" requires task-based execution. Use client.experimental.tasks.callToolStream() instead.`);
+      }
       const result = await this.request({ method: "tools/call", params }, resultSchema, options);
       const validator = this.getToolOutputValidator(params.name);
       if (validator) {
@@ -17988,17 +19153,39 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       return result;
     }
+    isToolTask(toolName) {
+      if (!this._serverCapabilities?.tasks?.requests?.tools?.call) {
+        return false;
+      }
+      return this._cachedKnownTaskTools.has(toolName);
+    }
+    /**
+     * Check if a tool requires task-based execution.
+     * Unlike isToolTask which includes 'optional' tools, this only checks for 'required'.
+     */
+    isToolTaskRequired(toolName) {
+      return this._cachedRequiredTaskTools.has(toolName);
+    }
     /**
      * Cache validators for tool output schemas.
      * Called after listTools() to pre-compile validators for better performance.
      */
-    cacheToolOutputSchemas(tools) {
+    cacheToolMetadata(tools) {
       this._cachedToolOutputValidators.clear();
+      this._cachedKnownTaskTools.clear();
+      this._cachedRequiredTaskTools.clear();
       for (const tool of tools) {
         if (tool.outputSchema) {
           const toolValidator = this._jsonSchemaValidator.getValidator(tool.outputSchema);
           this._cachedToolOutputValidators.set(tool.name, toolValidator);
         }
+        const taskSupport = tool.execution?.taskSupport;
+        if (taskSupport === "required" || taskSupport === "optional") {
+          this._cachedKnownTaskTools.add(tool.name);
+        }
+        if (taskSupport === "required") {
+          this._cachedRequiredTaskTools.add(tool.name);
+        }
       }
     }
     /**
@@ -18009,9 +19196,50 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     async listTools(params, options) {
       const result = await this.request({ method: "tools/list", params }, ListToolsResultSchema, options);
-      this.cacheToolOutputSchemas(result.tools);
+      this.cacheToolMetadata(result.tools);
       return result;
     }
+    /**
+     * Set up a single list changed handler.
+     * @internal
+     */
+    _setupListChangedHandler(listType, notificationSchema, options, fetcher) {
+      const parseResult = ListChangedOptionsBaseSchema.safeParse(options);
+      if (!parseResult.success) {
+        throw new Error(`Invalid ${listType} listChanged options: ${parseResult.error.message}`);
+      }
+      if (typeof options.onChanged !== "function") {
+        throw new Error(`Invalid ${listType} listChanged options: onChanged must be a function`);
+      }
+      const { autoRefresh, debounceMs } = parseResult.data;
+      const { onChanged } = options;
+      const refresh = async () => {
+        if (!autoRefresh) {
+          onChanged(null, null);
+          return;
+        }
+        try {
+          const items2 = await fetcher();
+          onChanged(null, items2);
+        } catch (e) {
+          const error = e instanceof Error ? e : new Error(String(e));
+          onChanged(error, null);
+        }
+      };
+      const handler = () => {
+        if (debounceMs) {
+          const existingTimer = this._listChangedDebounceTimers.get(listType);
+          if (existingTimer) {
+            clearTimeout(existingTimer);
+          }
+          const timer = setTimeout(refresh, debounceMs);
+          this._listChangedDebounceTimers.set(listType, timer);
+        } else {
+          refresh();
+        }
+      };
+      this.setNotificationHandler(notificationSchema, handler);
+    }
     async sendRootsListChanged() {
       return this.notification({ method: "notifications/roots/list_changed" });
     }
@@ -18185,8 +19413,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   const OAuthClientInformationSchema = object$1({
     client_id: string(),
     client_secret: string().optional(),
-    client_id_issued_at: number().optional(),
-    client_secret_expires_at: number().optional()
+    client_id_issued_at: number$1().optional(),
+    client_secret_expires_at: number$1().optional()
   }).strip();
   const OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
   object$1({
@@ -18286,6 +19514,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   class InsufficientScopeError extends OAuthError {
   }
   InsufficientScopeError.errorCode = "insufficient_scope";
+  class InvalidTargetError extends OAuthError {
+  }
+  InvalidTargetError.errorCode = "invalid_target";
   const OAUTH_ERRORS = {
     [InvalidRequestError.errorCode]: InvalidRequestError,
     [InvalidClientError.errorCode]: InvalidClientError,
@@ -18302,11 +19533,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     [MethodNotAllowedError.errorCode]: MethodNotAllowedError,
     [TooManyRequestsError.errorCode]: TooManyRequestsError,
     [InvalidClientMetadataError.errorCode]: InvalidClientMetadataError,
-    [InsufficientScopeError.errorCode]: InsufficientScopeError
+    [InsufficientScopeError.errorCode]: InsufficientScopeError,
+    [InvalidTargetError.errorCode]: InvalidTargetError
   };
   class UnauthorizedError extends Error {
     constructor(message) {
-      super(message !== null && message !== void 0 ? message : "Unauthorized");
+      super(message ?? "Unauthorized");
     }
   }
   function isClientAuthMethod(method) {
@@ -18379,22 +19611,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   }
   async function auth(provider, options) {
-    var _a, _b;
     try {
       return await authInternal(provider, options);
     } catch (error) {
       if (error instanceof InvalidClientError || error instanceof UnauthorizedClientError) {
-        await ((_a = provider.invalidateCredentials) === null || _a === void 0 ? void 0 : _a.call(provider, "all"));
+        await provider.invalidateCredentials?.("all");
         return await authInternal(provider, options);
       } else if (error instanceof InvalidGrantError) {
-        await ((_b = provider.invalidateCredentials) === null || _b === void 0 ? void 0 : _b.call(provider, "tokens"));
+        await provider.invalidateCredentials?.("tokens");
         return await authInternal(provider, options);
       }
       throw error;
     }
   }
   async function authInternal(provider, { serverUrl, authorizationCode, scope: scope2, resourceMetadataUrl, fetchFn }) {
-    var _a, _b;
     let resourceMetadata;
     let authorizationServerUrl;
     try {
@@ -18402,7 +19632,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
         authorizationServerUrl = resourceMetadata.authorization_servers[0];
       }
-    } catch (_c) {
+    } catch {
     }
     if (!authorizationServerUrl) {
       authorizationServerUrl = new URL("/", serverUrl);
@@ -18416,7 +19646,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (authorizationCode !== void 0) {
         throw new Error("Existing OAuth client information is required when exchanging an authorization code");
       }
-      const supportsUrlBasedClientId = (metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.client_id_metadata_document_supported) === true;
+      const supportsUrlBasedClientId = metadata2?.client_id_metadata_document_supported === true;
       const clientMetadataUrl = provider.clientMetadataUrl;
       if (clientMetadataUrl && !isHttpsUrl(clientMetadataUrl)) {
         throw new InvalidClientMetadataError(`clientMetadataUrl must be a valid HTTPS URL with a non-root pathname, got: ${clientMetadataUrl}`);
@@ -18426,7 +19656,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         clientInformation = {
           client_id: clientMetadataUrl
         };
-        await ((_a = provider.saveClientInformation) === null || _a === void 0 ? void 0 : _a.call(provider, clientInformation));
+        await provider.saveClientInformation?.(clientInformation);
       } else {
         if (!provider.saveClientInformation) {
           throw new Error("OAuth client information must be saveable for dynamic registration");
@@ -18440,23 +19670,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         clientInformation = fullInformation;
       }
     }
-    if (authorizationCode !== void 0) {
-      const codeVerifier2 = await provider.codeVerifier();
-      const tokens2 = await exchangeAuthorization(authorizationServerUrl, {
+    const nonInteractiveFlow = !provider.redirectUrl;
+    if (authorizationCode !== void 0 || nonInteractiveFlow) {
+      const tokens2 = await fetchToken(provider, authorizationServerUrl, {
         metadata: metadata2,
-        clientInformation,
-        authorizationCode,
-        codeVerifier: codeVerifier2,
-        redirectUri: provider.redirectUrl,
         resource,
-        addClientAuthentication: provider.addClientAuthentication,
+        authorizationCode,
         fetchFn
       });
       await provider.saveTokens(tokens2);
       return "AUTHORIZED";
     }
     const tokens = await provider.tokens();
-    if (tokens === null || tokens === void 0 ? void 0 : tokens.refresh_token) {
+    if (tokens?.refresh_token) {
       try {
         const newTokens = await refreshAuthorization(authorizationServerUrl, {
           metadata: metadata2,
@@ -18481,7 +19707,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       clientInformation,
       state,
       redirectUrl: provider.redirectUrl,
-      scope: scope2 || ((_b = resourceMetadata === null || resourceMetadata === void 0 ? void 0 : resourceMetadata.scopes_supported) === null || _b === void 0 ? void 0 : _b.join(" ")) || provider.clientMetadata.scope,
+      scope: scope2 || resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope,
       resource
     });
     await provider.saveCodeVerifier(codeVerifier);
@@ -18494,14 +19720,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     try {
       const url2 = new URL(value);
       return url2.protocol === "https:" && url2.pathname !== "/";
-    } catch (_a) {
+    } catch {
       return false;
     }
   }
   async function selectResourceURL(serverUrl, provider, resourceMetadata) {
     const defaultResource = resourceUrlFromServerUrl(serverUrl);
     if (provider.validateResourceURL) {
-      return await provider.validateResourceURL(defaultResource, resourceMetadata === null || resourceMetadata === void 0 ? void 0 : resourceMetadata.resource);
+      return await provider.validateResourceURL(defaultResource, resourceMetadata?.resource);
     }
     if (!resourceMetadata) {
       return void 0;
@@ -18525,7 +19751,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     if (resourceMetadataMatch) {
       try {
         resourceMetadataUrl = new URL(resourceMetadataMatch);
-      } catch (_a) {
+      } catch {
       }
     }
     const scope2 = extractFieldFromWwwAuth(res, "scope") || void 0;
@@ -18564,19 +19790,21 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     try {
       return new URL(match[1]);
-    } catch (_a) {
+    } catch {
       return void 0;
     }
   }
   async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) {
     const response = await discoverMetadataWithFallback(serverUrl, "oauth-protected-resource", fetchFn, {
-      protocolVersion: opts === null || opts === void 0 ? void 0 : opts.protocolVersion,
-      metadataUrl: opts === null || opts === void 0 ? void 0 : opts.resourceMetadataUrl
+      protocolVersion: opts?.protocolVersion,
+      metadataUrl: opts?.resourceMetadataUrl
     });
     if (!response || response.status === 404) {
+      await response?.body?.cancel();
       throw new Error(`Resource server does not implement OAuth 2.0 Protected Resource Metadata.`);
     }
     if (!response.ok) {
+      await response.body?.cancel();
       throw new Error(`HTTP ${response.status} trying to load well-known OAuth protected resource metadata.`);
     }
     return OAuthProtectedResourceMetadataSchema.parse(await response.json());
@@ -18611,19 +19839,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return !response || response.status >= 400 && response.status < 500 && pathname !== "/";
   }
   async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, opts) {
-    var _a, _b;
     const issuer = new URL(serverUrl);
-    const protocolVersion = (_a = opts === null || opts === void 0 ? void 0 : opts.protocolVersion) !== null && _a !== void 0 ? _a : LATEST_PROTOCOL_VERSION;
+    const protocolVersion = opts?.protocolVersion ?? LATEST_PROTOCOL_VERSION;
     let url2;
-    if (opts === null || opts === void 0 ? void 0 : opts.metadataUrl) {
+    if (opts?.metadataUrl) {
       url2 = new URL(opts.metadataUrl);
     } else {
       const wellKnownPath = buildWellKnownPath(wellKnownType, issuer.pathname);
-      url2 = new URL(wellKnownPath, (_b = opts === null || opts === void 0 ? void 0 : opts.metadataServerUrl) !== null && _b !== void 0 ? _b : issuer);
+      url2 = new URL(wellKnownPath, opts?.metadataServerUrl ?? issuer);
       url2.search = issuer.search;
     }
     let response = await tryMetadataDiscovery(url2, protocolVersion, fetchFn);
-    if (!(opts === null || opts === void 0 ? void 0 : opts.metadataUrl) && shouldAttemptFallback(response, issuer.pathname)) {
+    if (!opts?.metadataUrl && shouldAttemptFallback(response, issuer.pathname)) {
       const rootUrl = new URL(`/.well-known/${wellKnownType}`, issuer);
       response = await tryMetadataDiscovery(rootUrl, protocolVersion, fetchFn);
     }
@@ -18639,15 +19866,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     if (typeof authorizationServerUrl === "string") {
       authorizationServerUrl = new URL(authorizationServerUrl);
     }
-    protocolVersion !== null && protocolVersion !== void 0 ? protocolVersion : protocolVersion = LATEST_PROTOCOL_VERSION;
+    protocolVersion ?? (protocolVersion = LATEST_PROTOCOL_VERSION);
     const response = await discoverMetadataWithFallback(authorizationServerUrl, "oauth-authorization-server", fetchFn, {
       protocolVersion,
       metadataServerUrl: authorizationServerUrl
     });
     if (!response || response.status === 404) {
+      await response?.body?.cancel();
       return void 0;
     }
     if (!response.ok) {
+      await response.body?.cancel();
       throw new Error(`HTTP ${response.status} trying to load well-known OAuth metadata`);
     }
     return OAuthMetadataSchema.parse(await response.json());
@@ -18697,6 +19926,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         continue;
       }
       if (!response.ok) {
+        await response.body?.cancel();
         if (response.status >= 400 && response.status < 500) {
           continue;
         }
@@ -18737,7 +19967,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     if (scope2) {
       authorizationUrl.searchParams.set("scope", scope2);
     }
-    if (scope2 === null || scope2 === void 0 ? void 0 : scope2.includes("offline_access")) {
+    if (scope2?.includes("offline_access")) {
       authorizationUrl.searchParams.append("prompt", "consent");
     }
     if (resource) {
@@ -18745,81 +19975,91 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     return { authorizationUrl, codeVerifier };
   }
-  async function exchangeAuthorization(authorizationServerUrl, { metadata: metadata2, clientInformation, authorizationCode, codeVerifier, redirectUri, resource, addClientAuthentication, fetchFn }) {
-    var _a;
-    const grantType = "authorization_code";
-    const tokenUrl = (metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.token_endpoint) ? new URL(metadata2.token_endpoint) : new URL("/token", authorizationServerUrl);
-    if ((metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.grant_types_supported) && !metadata2.grant_types_supported.includes(grantType)) {
-      throw new Error(`Incompatible auth server: does not support grant type ${grantType}`);
-    }
-    const headers = new Headers({
-      "Content-Type": "application/x-www-form-urlencoded",
-      Accept: "application/json"
-    });
-    const params = new URLSearchParams({
-      grant_type: grantType,
+  function prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, redirectUri) {
+    return new URLSearchParams({
+      grant_type: "authorization_code",
       code: authorizationCode,
       code_verifier: codeVerifier,
       redirect_uri: String(redirectUri)
     });
+  }
+  async function executeTokenRequest(authorizationServerUrl, { metadata: metadata2, tokenRequestParams, clientInformation, addClientAuthentication, resource, fetchFn }) {
+    const tokenUrl = metadata2?.token_endpoint ? new URL(metadata2.token_endpoint) : new URL("/token", authorizationServerUrl);
+    const headers = new Headers({
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json"
+    });
+    if (resource) {
+      tokenRequestParams.set("resource", resource.href);
+    }
     if (addClientAuthentication) {
-      addClientAuthentication(headers, params, authorizationServerUrl, metadata2);
-    } else {
-      const supportedMethods = (_a = metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.token_endpoint_auth_methods_supported) !== null && _a !== void 0 ? _a : [];
+      await addClientAuthentication(headers, tokenRequestParams, tokenUrl, metadata2);
+    } else if (clientInformation) {
+      const supportedMethods = metadata2?.token_endpoint_auth_methods_supported ?? [];
       const authMethod = selectClientAuthMethod(clientInformation, supportedMethods);
-      applyClientAuthentication(authMethod, clientInformation, headers, params);
+      applyClientAuthentication(authMethod, clientInformation, headers, tokenRequestParams);
     }
-    if (resource) {
-      params.set("resource", resource.href);
-    }
-    const response = await (fetchFn !== null && fetchFn !== void 0 ? fetchFn : fetch)(tokenUrl, {
+    const response = await (fetchFn ?? fetch)(tokenUrl, {
       method: "POST",
       headers,
-      body: params
+      body: tokenRequestParams
     });
     if (!response.ok) {
       throw await parseErrorResponse(response);
     }
     return OAuthTokensSchema.parse(await response.json());
   }
-  async function refreshAuthorization(authorizationServerUrl, { metadata: metadata2, clientInformation, refreshToken, resource, addClientAuthentication, fetchFn }) {
-    var _a;
-    const grantType = "refresh_token";
-    let tokenUrl;
-    if (metadata2) {
-      tokenUrl = new URL(metadata2.token_endpoint);
-      if (metadata2.grant_types_supported && !metadata2.grant_types_supported.includes(grantType)) {
-        throw new Error(`Incompatible auth server: does not support grant type ${grantType}`);
-      }
-    } else {
-      tokenUrl = new URL("/token", authorizationServerUrl);
-    }
-    const headers = new Headers({
-      "Content-Type": "application/x-www-form-urlencoded"
+  async function exchangeAuthorization(authorizationServerUrl, { metadata: metadata2, clientInformation, authorizationCode, codeVerifier, redirectUri, resource, addClientAuthentication, fetchFn }) {
+    const tokenRequestParams = prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, redirectUri);
+    return executeTokenRequest(authorizationServerUrl, {
+      metadata: metadata2,
+      tokenRequestParams,
+      clientInformation,
+      addClientAuthentication,
+      resource,
+      fetchFn
     });
-    const params = new URLSearchParams({
-      grant_type: grantType,
+  }
+  async function refreshAuthorization(authorizationServerUrl, { metadata: metadata2, clientInformation, refreshToken, resource, addClientAuthentication, fetchFn }) {
+    const tokenRequestParams = new URLSearchParams({
+      grant_type: "refresh_token",
       refresh_token: refreshToken
     });
-    if (addClientAuthentication) {
-      addClientAuthentication(headers, params, authorizationServerUrl, metadata2);
-    } else {
-      const supportedMethods = (_a = metadata2 === null || metadata2 === void 0 ? void 0 : metadata2.token_endpoint_auth_methods_supported) !== null && _a !== void 0 ? _a : [];
-      const authMethod = selectClientAuthMethod(clientInformation, supportedMethods);
-      applyClientAuthentication(authMethod, clientInformation, headers, params);
+    const tokens = await executeTokenRequest(authorizationServerUrl, {
+      metadata: metadata2,
+      tokenRequestParams,
+      clientInformation,
+      addClientAuthentication,
+      resource,
+      fetchFn
+    });
+    return { refresh_token: refreshToken, ...tokens };
+  }
+  async function fetchToken(provider, authorizationServerUrl, { metadata: metadata2, resource, authorizationCode, fetchFn } = {}) {
+    const scope2 = provider.clientMetadata.scope;
+    let tokenRequestParams;
+    if (provider.prepareTokenRequest) {
+      tokenRequestParams = await provider.prepareTokenRequest(scope2);
     }
-    if (resource) {
-      params.set("resource", resource.href);
+    if (!tokenRequestParams) {
+      if (!authorizationCode) {
+        throw new Error("Either provider.prepareTokenRequest() or authorizationCode is required");
+      }
+      if (!provider.redirectUrl) {
+        throw new Error("redirectUrl is required for authorization_code flow");
+      }
+      const codeVerifier = await provider.codeVerifier();
+      tokenRequestParams = prepareAuthorizationCodeRequest(authorizationCode, codeVerifier, provider.redirectUrl);
     }
-    const response = await (fetchFn !== null && fetchFn !== void 0 ? fetchFn : fetch)(tokenUrl, {
-      method: "POST",
-      headers,
-      body: params
+    const clientInformation = await provider.clientInformation();
+    return executeTokenRequest(authorizationServerUrl, {
+      metadata: metadata2,
+      tokenRequestParams,
+      clientInformation: clientInformation ?? void 0,
+      addClientAuthentication: provider.addClientAuthentication,
+      resource,
+      fetchFn
     });
-    if (!response.ok) {
-      throw await parseErrorResponse(response);
-    }
-    return OAuthTokensSchema.parse({ refresh_token: refreshToken, ...await response.json() });
   }
   async function registerClient(authorizationServerUrl, { metadata: metadata2, clientMetadata, fetchFn }) {
     let registrationUrl;
@@ -18831,7 +20071,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     } else {
       registrationUrl = new URL("/register", authorizationServerUrl);
     }
-    const response = await (fetchFn !== null && fetchFn !== void 0 ? fetchFn : fetch)(registrationUrl, {
+    const response = await (fetchFn ?? fetch)(registrationUrl, {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
@@ -19231,7 +20471,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         ...baseInit,
         ...init,
         // Headers need special handling - merge instead of replace
-        headers: (init === null || init === void 0 ? void 0 : init.headers) ? { ...normalizeHeaders(baseInit.headers), ...normalizeHeaders(init.headers) } : baseInit.headers
+        headers: init?.headers ? { ...normalizeHeaders(baseInit.headers), ...normalizeHeaders(init.headers) } : baseInit.headers
       };
       return baseFetch(url2, mergedInit);
     };
@@ -19248,14 +20488,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this._url = url2;
       this._resourceMetadataUrl = void 0;
       this._scope = void 0;
-      this._eventSourceInit = opts === null || opts === void 0 ? void 0 : opts.eventSourceInit;
-      this._requestInit = opts === null || opts === void 0 ? void 0 : opts.requestInit;
-      this._authProvider = opts === null || opts === void 0 ? void 0 : opts.authProvider;
-      this._fetch = opts === null || opts === void 0 ? void 0 : opts.fetch;
-      this._fetchWithInit = createFetchWithInit(opts === null || opts === void 0 ? void 0 : opts.fetch, opts === null || opts === void 0 ? void 0 : opts.requestInit);
+      this._eventSourceInit = opts?.eventSourceInit;
+      this._requestInit = opts?.requestInit;
+      this._authProvider = opts?.authProvider;
+      this._fetch = opts?.fetch;
+      this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
     }
     async _authThenStart() {
-      var _a;
       if (!this._authProvider) {
         throw new UnauthorizedError("No auth provider");
       }
@@ -19268,7 +20507,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           fetchFn: this._fetchWithInit
         });
       } catch (error) {
-        (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+        this.onerror?.(error);
         throw error;
       }
       if (result !== "AUTHORIZED") {
@@ -19277,7 +20516,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return await this._startOrAuth();
     }
     async _commonHeaders() {
-      var _a;
       const headers = {};
       if (this._authProvider) {
         const tokens = await this._authProvider.tokens();
@@ -19288,11 +20526,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (this._protocolVersion) {
         headers["mcp-protocol-version"] = this._protocolVersion;
       }
-      return new Headers({ ...headers, ...(_a = this._requestInit) === null || _a === void 0 ? void 0 : _a.headers });
+      const extraHeaders = normalizeHeaders(this._requestInit?.headers);
+      return new Headers({
+        ...headers,
+        ...extraHeaders
+      });
     }
     _startOrAuth() {
-      var _a, _b, _c;
-      const fetchImpl = (_c = (_b = (_a = this === null || this === void 0 ? void 0 : this._eventSourceInit) === null || _a === void 0 ? void 0 : _a.fetch) !== null && _b !== void 0 ? _b : this._fetch) !== null && _c !== void 0 ? _c : fetch;
+      const fetchImpl = this?._eventSourceInit?.fetch ?? this._fetch ?? fetch;
       return new Promise((resolve2, reject) => {
         this._eventSource = new EventSource(this._url.href, {
           ...this._eventSourceInit,
@@ -19313,19 +20554,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         });
         this._abortController = new AbortController();
         this._eventSource.onerror = (event) => {
-          var _a2;
           if (event.code === 401 && this._authProvider) {
             this._authThenStart().then(resolve2, reject);
             return;
           }
           const error = new SseError(event.code, event.message, event);
           reject(error);
-          (_a2 = this.onerror) === null || _a2 === void 0 ? void 0 : _a2.call(this, error);
+          this.onerror?.(error);
         };
         this._eventSource.onopen = () => {
         };
         this._eventSource.addEventListener("endpoint", (event) => {
-          var _a2;
           const messageEvent = event;
           try {
             this._endpoint = new URL(messageEvent.data, this._url);
@@ -19334,23 +20573,22 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             }
           } catch (error) {
             reject(error);
-            (_a2 = this.onerror) === null || _a2 === void 0 ? void 0 : _a2.call(this, error);
+            this.onerror?.(error);
             void this.close();
             return;
           }
           resolve2();
         });
         this._eventSource.onmessage = (event) => {
-          var _a2, _b2;
           const messageEvent = event;
           let message;
           try {
             message = JSONRPCMessageSchema.parse(JSON.parse(messageEvent.data));
           } catch (error) {
-            (_a2 = this.onerror) === null || _a2 === void 0 ? void 0 : _a2.call(this, error);
+            this.onerror?.(error);
             return;
           }
-          (_b2 = this.onmessage) === null || _b2 === void 0 ? void 0 : _b2.call(this, message);
+          this.onmessage?.(message);
         };
       });
     }
@@ -19379,13 +20617,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     }
     async close() {
-      var _a, _b, _c;
-      (_a = this._abortController) === null || _a === void 0 ? void 0 : _a.abort();
-      (_b = this._eventSource) === null || _b === void 0 ? void 0 : _b.close();
-      (_c = this.onclose) === null || _c === void 0 ? void 0 : _c.call(this);
+      this._abortController?.abort();
+      this._eventSource?.close();
+      this.onclose?.();
     }
     async send(message) {
-      var _a, _b, _c;
       if (!this._endpoint) {
         throw new Error("Not connected");
       }
@@ -19397,10 +20633,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           method: "POST",
           headers,
           body: JSON.stringify(message),
-          signal: (_a = this._abortController) === null || _a === void 0 ? void 0 : _a.signal
+          signal: this._abortController?.signal
         };
-        const response = await ((_b = this._fetch) !== null && _b !== void 0 ? _b : fetch)(this._endpoint, init);
+        const response = await (this._fetch ?? fetch)(this._endpoint, init);
         if (!response.ok) {
+          const text = await response.text().catch(() => null);
           if (response.status === 401 && this._authProvider) {
             const { resourceMetadataUrl, scope: scope2 } = extractWWWAuthenticateParams(response);
             this._resourceMetadataUrl = resourceMetadataUrl;
@@ -19416,11 +20653,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             }
             return this.send(message);
           }
-          const text = await response.text().catch(() => null);
           throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${text}`);
         }
+        await response.body?.cancel();
       } catch (error) {
-        (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, error);
+        this.onerror?.(error);
         throw error;
       }
     }
@@ -19464,20 +20701,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   class StreamableHTTPClientTransport {
     constructor(url2, opts) {
-      var _a;
       this._hasCompletedAuthFlow = false;
       this._url = url2;
       this._resourceMetadataUrl = void 0;
       this._scope = void 0;
-      this._requestInit = opts === null || opts === void 0 ? void 0 : opts.requestInit;
-      this._authProvider = opts === null || opts === void 0 ? void 0 : opts.authProvider;
-      this._fetch = opts === null || opts === void 0 ? void 0 : opts.fetch;
-      this._fetchWithInit = createFetchWithInit(opts === null || opts === void 0 ? void 0 : opts.fetch, opts === null || opts === void 0 ? void 0 : opts.requestInit);
-      this._sessionId = opts === null || opts === void 0 ? void 0 : opts.sessionId;
-      this._reconnectionOptions = (_a = opts === null || opts === void 0 ? void 0 : opts.reconnectionOptions) !== null && _a !== void 0 ? _a : DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS;
+      this._requestInit = opts?.requestInit;
+      this._authProvider = opts?.authProvider;
+      this._fetch = opts?.fetch;
+      this._fetchWithInit = createFetchWithInit(opts?.fetch, opts?.requestInit);
+      this._sessionId = opts?.sessionId;
+      this._reconnectionOptions = opts?.reconnectionOptions ?? DEFAULT_STREAMABLE_HTTP_RECONNECTION_OPTIONS;
     }
     async _authThenStart() {
-      var _a;
       if (!this._authProvider) {
         throw new UnauthorizedError("No auth provider");
       }
@@ -19490,7 +20725,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           fetchFn: this._fetchWithInit
         });
       } catch (error) {
-        (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+        this.onerror?.(error);
         throw error;
       }
       if (result !== "AUTHORIZED") {
@@ -19499,7 +20734,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return await this._startOrAuthSse({ resumptionToken: void 0 });
     }
     async _commonHeaders() {
-      var _a;
       const headers = {};
       if (this._authProvider) {
         const tokens = await this._authProvider.tokens();
@@ -19513,14 +20747,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (this._protocolVersion) {
         headers["mcp-protocol-version"] = this._protocolVersion;
       }
-      const extraHeaders = normalizeHeaders((_a = this._requestInit) === null || _a === void 0 ? void 0 : _a.headers);
+      const extraHeaders = normalizeHeaders(this._requestInit?.headers);
       return new Headers({
         ...headers,
         ...extraHeaders
       });
     }
     async _startOrAuthSse(options) {
-      var _a, _b, _c;
       const { resumptionToken } = options;
       try {
         const headers = await this._commonHeaders();
@@ -19528,12 +20761,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         if (resumptionToken) {
           headers.set("last-event-id", resumptionToken);
         }
-        const response = await ((_a = this._fetch) !== null && _a !== void 0 ? _a : fetch)(this._url, {
+        const response = await (this._fetch ?? fetch)(this._url, {
           method: "GET",
           headers,
-          signal: (_b = this._abortController) === null || _b === void 0 ? void 0 : _b.signal
+          signal: this._abortController?.signal
         });
         if (!response.ok) {
+          await response.body?.cancel();
           if (response.status === 401 && this._authProvider) {
             return await this._authThenStart();
           }
@@ -19544,7 +20778,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         }
         this._handleSseStream(response.body, options, true);
       } catch (error) {
-        (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, error);
+        this.onerror?.(error);
         throw error;
       }
     }
@@ -19570,17 +20804,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * @param attemptCount Current reconnection attempt count for this specific stream
      */
     _scheduleReconnection(options, attemptCount = 0) {
-      var _a;
       const maxRetries = this._reconnectionOptions.maxRetries;
-      if (maxRetries > 0 && attemptCount >= maxRetries) {
-        (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
+      if (attemptCount >= maxRetries) {
+        this.onerror?.(new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
         return;
       }
       const delay = this._getNextReconnectionDelay(attemptCount);
-      setTimeout(() => {
+      this._reconnectionTimeout = setTimeout(() => {
         this._startOrAuthSse(options).catch((error) => {
-          var _a2;
-          (_a2 = this.onerror) === null || _a2 === void 0 ? void 0 : _a2.call(this, new Error(`Failed to reconnect SSE stream: ${error instanceof Error ? error.message : String(error)}`));
+          this.onerror?.(new Error(`Failed to reconnect SSE stream: ${error instanceof Error ? error.message : String(error)}`));
           this._scheduleReconnection(options, attemptCount + 1);
         });
       }, delay);
@@ -19592,8 +20824,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const { onresumptiontoken, replayMessageId } = options;
       let lastEventId;
       let hasPrimingEvent = false;
+      let receivedResponse = false;
       const processStream = async () => {
-        var _a, _b, _c, _d;
         try {
           const reader = stream.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream({
             onRetry: (retryMs) => {
@@ -19608,22 +20840,29 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             if (event.id) {
               lastEventId = event.id;
               hasPrimingEvent = true;
-              onresumptiontoken === null || onresumptiontoken === void 0 ? void 0 : onresumptiontoken(event.id);
+              onresumptiontoken?.(event.id);
+            }
+            if (!event.data) {
+              continue;
             }
             if (!event.event || event.event === "message") {
               try {
                 const message = JSONRPCMessageSchema.parse(JSON.parse(event.data));
-                if (replayMessageId !== void 0 && isJSONRPCResponse(message)) {
-                  message.id = replayMessageId;
+                if (isJSONRPCResultResponse(message)) {
+                  receivedResponse = true;
+                  if (replayMessageId !== void 0) {
+                    message.id = replayMessageId;
+                  }
                 }
-                (_a = this.onmessage) === null || _a === void 0 ? void 0 : _a.call(this, message);
+                this.onmessage?.(message);
               } catch (error) {
-                (_b = this.onerror) === null || _b === void 0 ? void 0 : _b.call(this, error);
+                this.onerror?.(error);
               }
             }
           }
           const canResume = isReconnectable || hasPrimingEvent;
-          if (canResume && this._abortController && !this._abortController.signal.aborted) {
+          const needsReconnect = canResume && !receivedResponse;
+          if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
             this._scheduleReconnection({
               resumptionToken: lastEventId,
               onresumptiontoken,
@@ -19631,9 +20870,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             }, 0);
           }
         } catch (error) {
-          (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, new Error(`SSE stream disconnected: ${error}`));
+          this.onerror?.(new Error(`SSE stream disconnected: ${error}`));
           const canResume = isReconnectable || hasPrimingEvent;
-          if (canResume && this._abortController && !this._abortController.signal.aborted) {
+          const needsReconnect = canResume && !receivedResponse;
+          if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
             try {
               this._scheduleReconnection({
                 resumptionToken: lastEventId,
@@ -19641,7 +20881,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
                 replayMessageId
               }, 0);
             } catch (error2) {
-              (_d = this.onerror) === null || _d === void 0 ? void 0 : _d.call(this, new Error(`Failed to reconnect: ${error2 instanceof Error ? error2.message : String(error2)}`));
+              this.onerror?.(new Error(`Failed to reconnect: ${error2 instanceof Error ? error2.message : String(error2)}`));
             }
           }
         }
@@ -19673,19 +20913,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     }
     async close() {
-      var _a, _b;
-      (_a = this._abortController) === null || _a === void 0 ? void 0 : _a.abort();
-      (_b = this.onclose) === null || _b === void 0 ? void 0 : _b.call(this);
+      if (this._reconnectionTimeout) {
+        clearTimeout(this._reconnectionTimeout);
+        this._reconnectionTimeout = void 0;
+      }
+      this._abortController?.abort();
+      this.onclose?.();
     }
     async send(message, options) {
-      var _a, _b, _c, _d;
       try {
         const { resumptionToken, onresumptiontoken } = options || {};
         if (resumptionToken) {
-          this._startOrAuthSse({ resumptionToken, replayMessageId: isJSONRPCRequest(message) ? message.id : void 0 }).catch((err) => {
-            var _a2;
-            return (_a2 = this.onerror) === null || _a2 === void 0 ? void 0 : _a2.call(this, err);
-          });
+          this._startOrAuthSse({ resumptionToken, replayMessageId: isJSONRPCRequest(message) ? message.id : void 0 }).catch((err) => this.onerror?.(err));
           return;
         }
         const headers = await this._commonHeaders();
@@ -19696,14 +20935,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           method: "POST",
           headers,
           body: JSON.stringify(message),
-          signal: (_a = this._abortController) === null || _a === void 0 ? void 0 : _a.signal
+          signal: this._abortController?.signal
         };
-        const response = await ((_b = this._fetch) !== null && _b !== void 0 ? _b : fetch)(this._url, init);
+        const response = await (this._fetch ?? fetch)(this._url, init);
         const sessionId = response.headers.get("mcp-session-id");
         if (sessionId) {
           this._sessionId = sessionId;
         }
         if (!response.ok) {
+          const text = await response.text().catch(() => null);
           if (response.status === 401 && this._authProvider) {
             if (this._hasCompletedAuthFlow) {
               throw new StreamableHTTPError(401, "Server returned 401 after successful authentication");
@@ -19736,7 +20976,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
               if (resourceMetadataUrl) {
                 this._resourceMetadataUrl = resourceMetadataUrl;
               }
-              this._lastUpscopingHeader = wwwAuthHeader !== null && wwwAuthHeader !== void 0 ? wwwAuthHeader : void 0;
+              this._lastUpscopingHeader = wwwAuthHeader ?? void 0;
               const result = await auth(this._authProvider, {
                 serverUrl: this._url,
                 resourceMetadataUrl: this._resourceMetadataUrl,
@@ -19749,17 +20989,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
               return this.send(message);
             }
           }
-          const text = await response.text().catch(() => null);
-          throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${text}`);
+          throw new StreamableHTTPError(response.status, `Error POSTing to endpoint: ${text}`);
         }
         this._hasCompletedAuthFlow = false;
         this._lastUpscopingHeader = void 0;
         if (response.status === 202) {
+          await response.body?.cancel();
           if (isInitializedNotification(message)) {
-            this._startOrAuthSse({ resumptionToken: void 0 }).catch((err) => {
-              var _a2;
-              return (_a2 = this.onerror) === null || _a2 === void 0 ? void 0 : _a2.call(this, err);
-            });
+            this._startOrAuthSse({ resumptionToken: void 0 }).catch((err) => this.onerror?.(err));
           }
           return;
         }
@@ -19767,20 +21004,23 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         const hasRequests = messages.filter((msg) => "method" in msg && "id" in msg && msg.id !== void 0).length > 0;
         const contentType = response.headers.get("content-type");
         if (hasRequests) {
-          if (contentType === null || contentType === void 0 ? void 0 : contentType.includes("text/event-stream")) {
+          if (contentType?.includes("text/event-stream")) {
             this._handleSseStream(response.body, { onresumptiontoken }, false);
-          } else if (contentType === null || contentType === void 0 ? void 0 : contentType.includes("application/json")) {
+          } else if (contentType?.includes("application/json")) {
             const data = await response.json();
             const responseMessages = Array.isArray(data) ? data.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(data)];
             for (const msg of responseMessages) {
-              (_c = this.onmessage) === null || _c === void 0 ? void 0 : _c.call(this, msg);
+              this.onmessage?.(msg);
             }
           } else {
+            await response.body?.cancel();
             throw new StreamableHTTPError(-1, `Unexpected content type: ${contentType}`);
           }
+        } else {
+          await response.body?.cancel();
         }
       } catch (error) {
-        (_d = this.onerror) === null || _d === void 0 ? void 0 : _d.call(this, error);
+        this.onerror?.(error);
         throw error;
       }
     }
@@ -19799,7 +21039,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * the server does not allow clients to terminate sessions.
      */
     async terminateSession() {
-      var _a, _b, _c;
       if (!this._sessionId) {
         return;
       }
@@ -19809,15 +21048,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           ...this._requestInit,
           method: "DELETE",
           headers,
-          signal: (_a = this._abortController) === null || _a === void 0 ? void 0 : _a.signal
+          signal: this._abortController?.signal
         };
-        const response = await ((_b = this._fetch) !== null && _b !== void 0 ? _b : fetch)(this._url, init);
+        const response = await (this._fetch ?? fetch)(this._url, init);
+        await response.body?.cancel();
         if (!response.ok && response.status !== 405) {
           throw new StreamableHTTPError(response.status, `Failed to terminate session: ${response.statusText}`);
         }
         this._sessionId = void 0;
       } catch (error) {
-        (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, error);
+        this.onerror?.(error);
         throw error;
       }
     }
@@ -19837,16 +21077,85 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     async resumeStream(lastEventId, options) {
       await this._startOrAuthSse({
         resumptionToken: lastEventId,
-        onresumptiontoken: options === null || options === void 0 ? void 0 : options.onresumptiontoken
+        onresumptiontoken: options?.onresumptiontoken
       });
     }
   }
+  class ExperimentalServerTasks {
+    constructor(_server) {
+      this._server = _server;
+    }
+    /**
+     * Sends a request and returns an AsyncGenerator that yields response messages.
+     * The generator is guaranteed to end with either a 'result' or 'error' message.
+     *
+     * This method provides streaming access to request processing, allowing you to
+     * observe intermediate task status updates for task-augmented requests.
+     *
+     * @param request - The request to send
+     * @param resultSchema - Zod schema for validating the result
+     * @param options - Optional request options (timeout, signal, task creation params, etc.)
+     * @returns AsyncGenerator that yields ResponseMessage objects
+     *
+     * @experimental
+     */
+    requestStream(request, resultSchema, options) {
+      return this._server.requestStream(request, resultSchema, options);
+    }
+    /**
+     * Gets the current status of a task.
+     *
+     * @param taskId - The task identifier
+     * @param options - Optional request options
+     * @returns The task status
+     *
+     * @experimental
+     */
+    async getTask(taskId, options) {
+      return this._server.getTask({ taskId }, options);
+    }
+    /**
+     * Retrieves the result of a completed task.
+     *
+     * @param taskId - The task identifier
+     * @param resultSchema - Zod schema for validating the result
+     * @param options - Optional request options
+     * @returns The task result
+     *
+     * @experimental
+     */
+    async getTaskResult(taskId, resultSchema, options) {
+      return this._server.getTaskResult({ taskId }, resultSchema, options);
+    }
+    /**
+     * Lists tasks with optional pagination.
+     *
+     * @param cursor - Optional pagination cursor
+     * @param options - Optional request options
+     * @returns List of tasks with optional next cursor
+     *
+     * @experimental
+     */
+    async listTasks(cursor, options) {
+      return this._server.listTasks(cursor ? { cursor } : void 0, options);
+    }
+    /**
+     * Cancels a running task.
+     *
+     * @param taskId - The task identifier
+     * @param options - Optional request options
+     *
+     * @experimental
+     */
+    async cancelTask(taskId, options) {
+      return this._server.cancelTask({ taskId }, options);
+    }
+  }
   class Server extends Protocol {
     /**
      * Initializes this server with the given name and version information.
      */
     constructor(_serverInfo, options) {
-      var _a, _b;
       super(options);
       this._serverInfo = _serverInfo;
       this._loggingLevels = /* @__PURE__ */ new Map();
@@ -19855,18 +21164,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         const currentLevel = this._loggingLevels.get(sessionId);
         return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
       };
-      this._capabilities = (_a = options === null || options === void 0 ? void 0 : options.capabilities) !== null && _a !== void 0 ? _a : {};
-      this._instructions = options === null || options === void 0 ? void 0 : options.instructions;
-      this._jsonSchemaValidator = (_b = options === null || options === void 0 ? void 0 : options.jsonSchemaValidator) !== null && _b !== void 0 ? _b : new AjvJsonSchemaValidator();
+      this._capabilities = options?.capabilities ?? {};
+      this._instructions = options?.instructions;
+      this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
       this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
-      this.setNotificationHandler(InitializedNotificationSchema, () => {
-        var _a2;
-        return (_a2 = this.oninitialized) === null || _a2 === void 0 ? void 0 : _a2.call(this);
-      });
+      this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
       if (this._capabilities.logging) {
         this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
-          var _a2;
-          const transportSessionId = extra.sessionId || ((_a2 = extra.requestInfo) === null || _a2 === void 0 ? void 0 : _a2.headers["mcp-session-id"]) || void 0;
+          const transportSessionId = extra.sessionId || extra.requestInfo?.headers["mcp-session-id"] || void 0;
           const { level } = request.params;
           const parseResult = LoggingLevelSchema.safeParse(level);
           if (parseResult.success) {
@@ -19876,6 +21181,21 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         });
       }
     }
+    /**
+     * Access experimental features.
+     *
+     * WARNING: These APIs are experimental and may change without notice.
+     *
+     * @experimental
+     */
+    get experimental() {
+      if (!this._experimental) {
+        this._experimental = {
+          tasks: new ExperimentalServerTasks(this)
+        };
+      }
+      return this._experimental;
+    }
     /**
      * Registers new capabilities. This can only be called before connecting to a transport.
      *
@@ -19887,28 +21207,77 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       this._capabilities = mergeCapabilities(this._capabilities, capabilities);
     }
+    /**
+     * Override request handler registration to enforce server-side validation for tools/call.
+     */
+    setRequestHandler(requestSchema, handler) {
+      const shape = getObjectShape(requestSchema);
+      const methodSchema = shape?.method;
+      if (!methodSchema) {
+        throw new Error("Schema is missing a method literal");
+      }
+      let methodValue;
+      if (isZ4Schema(methodSchema)) {
+        const v4Schema = methodSchema;
+        const v4Def = v4Schema._zod?.def;
+        methodValue = v4Def?.value ?? v4Schema.value;
+      } else {
+        const v3Schema = methodSchema;
+        const legacyDef = v3Schema._def;
+        methodValue = legacyDef?.value ?? v3Schema.value;
+      }
+      if (typeof methodValue !== "string") {
+        throw new Error("Schema method literal must be a string");
+      }
+      const method = methodValue;
+      if (method === "tools/call") {
+        const wrappedHandler = async (request, extra) => {
+          const validatedRequest = safeParse(CallToolRequestSchema, request);
+          if (!validatedRequest.success) {
+            const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+            throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+          }
+          const { params } = validatedRequest.data;
+          const result = await Promise.resolve(handler(request, extra));
+          if (params.task) {
+            const taskValidationResult = safeParse(CreateTaskResultSchema, result);
+            if (!taskValidationResult.success) {
+              const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+              throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+            }
+            return taskValidationResult.data;
+          }
+          const validationResult = safeParse(CallToolResultSchema, result);
+          if (!validationResult.success) {
+            const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+            throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+          }
+          return validationResult.data;
+        };
+        return super.setRequestHandler(requestSchema, wrappedHandler);
+      }
+      return super.setRequestHandler(requestSchema, handler);
+    }
     assertCapabilityForMethod(method) {
-      var _a, _b, _c;
       switch (method) {
         case "sampling/createMessage":
-          if (!((_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.sampling)) {
+          if (!this._clientCapabilities?.sampling) {
             throw new Error(`Client does not support sampling (required for ${method})`);
           }
           break;
         case "elicitation/create":
-          if (!((_b = this._clientCapabilities) === null || _b === void 0 ? void 0 : _b.elicitation)) {
+          if (!this._clientCapabilities?.elicitation) {
             throw new Error(`Client does not support elicitation (required for ${method})`);
           }
           break;
         case "roots/list":
-          if (!((_c = this._clientCapabilities) === null || _c === void 0 ? void 0 : _c.roots)) {
+          if (!this._clientCapabilities?.roots) {
             throw new Error(`Client does not support listing roots (required for ${method})`);
           }
           break;
       }
     }
     assertNotificationCapability(method) {
-      var _a, _b;
       switch (method) {
         case "notifications/message":
           if (!this._capabilities.logging) {
@@ -19932,13 +21301,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           }
           break;
         case "notifications/elicitation/complete":
-          if (!((_b = (_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.elicitation) === null || _b === void 0 ? void 0 : _b.url)) {
+          if (!this._clientCapabilities?.elicitation?.url) {
             throw new Error(`Client does not support URL elicitation (required for ${method})`);
           }
           break;
       }
     }
     assertRequestHandlerCapability(method) {
+      if (!this._capabilities) {
+        return;
+      }
       switch (method) {
         case "completion/complete":
           if (!this._capabilities.completions) {
@@ -19969,7 +21341,24 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             throw new Error(`Server does not support tools (required for ${method})`);
           }
           break;
+        case "tasks/get":
+        case "tasks/list":
+        case "tasks/result":
+        case "tasks/cancel":
+          if (!this._capabilities.tasks) {
+            throw new Error(`Server does not support tasks capability (required for ${method})`);
+          }
+          break;
+      }
+    }
+    assertTaskCapability(method) {
+      assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
+    }
+    assertTaskHandlerCapability(method) {
+      if (!this._capabilities) {
+        return;
       }
+      assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server");
     }
     async _oninitialize(request) {
       const requestedVersion = request.params.protocolVersion;
@@ -20001,10 +21390,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     async ping() {
       return this.request({ method: "ping" }, EmptyResultSchema);
     }
+    // Implementation
     async createMessage(params, options) {
-      var _a, _b;
       if (params.tools || params.toolChoice) {
-        if (!((_b = (_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.sampling) === null || _b === void 0 ? void 0 : _b.tools)) {
+        if (!this._clientCapabilities?.sampling?.tools) {
           throw new Error("Client does not support sampling tools capability.");
         }
       }
@@ -20031,6 +21420,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           }
         }
       }
+      if (params.tools) {
+        return this.request({ method: "sampling/createMessage", params }, CreateMessageResultWithToolsSchema, options);
+      }
       return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
     }
     /**
@@ -20041,18 +21433,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * @returns The result of the elicitation request.
      */
     async elicitInput(params, options) {
-      var _a, _b, _c, _d, _e;
-      const mode = (_a = params.mode) !== null && _a !== void 0 ? _a : "form";
+      const mode = params.mode ?? "form";
       switch (mode) {
         case "url": {
-          if (!((_c = (_b = this._clientCapabilities) === null || _b === void 0 ? void 0 : _b.elicitation) === null || _c === void 0 ? void 0 : _c.url)) {
+          if (!this._clientCapabilities?.elicitation?.url) {
             throw new Error("Client does not support url elicitation.");
           }
           const urlParams = params;
           return this.request({ method: "elicitation/create", params: urlParams }, ElicitResultSchema, options);
         }
         case "form": {
-          if (!((_e = (_d = this._clientCapabilities) === null || _d === void 0 ? void 0 : _d.elicitation) === null || _e === void 0 ? void 0 : _e.form)) {
+          if (!this._clientCapabilities?.elicitation?.form) {
             throw new Error("Client does not support form elicitation.");
           }
           const formParams = params.mode === "form" ? params : { ...params, mode: "form" };
@@ -20084,8 +21475,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * @returns A function that emits the completion notification when awaited.
      */
     createElicitationCompletionNotifier(elicitationId, options) {
-      var _a, _b;
-      if (!((_b = (_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.elicitation) === null || _b === void 0 ? void 0 : _b.url)) {
+      if (!this._clientCapabilities?.elicitation?.url) {
         throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
       }
       return () => this.notification({
@@ -20186,6 +21576,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     issueToolNameWarning(name, result.warnings);
     return result.isValid;
   }
+  class ExperimentalMcpServerTasks {
+    constructor(_mcpServer) {
+      this._mcpServer = _mcpServer;
+    }
+    registerToolTask(name, config2, handler) {
+      const execution = { taskSupport: "required", ...config2.execution };
+      if (execution.taskSupport === "forbidden") {
+        throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
+      }
+      const mcpServerInternal = this._mcpServer;
+      return mcpServerInternal._createRegisteredTool(name, config2.title, config2.description, config2.inputSchema, config2.outputSchema, config2.annotations, execution, config2._meta, handler);
+    }
+  }
   class McpServer {
     constructor(serverInfo, options) {
       this._registeredResources = {};
@@ -20198,6 +21601,21 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this._promptHandlersInitialized = false;
       this.server = new Server(serverInfo, options);
     }
+    /**
+     * Access experimental features.
+     *
+     * WARNING: These APIs are experimental and may change without notice.
+     *
+     * @experimental
+     */
+    get experimental() {
+      if (!this._experimental) {
+        this._experimental = {
+          tasks: new ExperimentalMcpServerTasks(this)
+        };
+      }
+      return this._experimental;
+    }
     /**
      * Attaches to the given transport, starts it, and starts listening for messages.
      *
@@ -20237,6 +21655,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
               }) : EMPTY_OBJECT_JSON_SCHEMA;
             })(),
             annotations: tool.annotations,
+            execution: tool.execution,
             _meta: tool._meta
           };
           if (tool.outputSchema) {
@@ -20252,39 +21671,33 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         })
       }));
       this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-        const tool = this._registeredTools[request.params.name];
-        let result;
         try {
+          const tool = this._registeredTools[request.params.name];
           if (!tool) {
             throw new McpError(exports2.ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
           }
           if (!tool.enabled) {
             throw new McpError(exports2.ErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
           }
-          if (tool.inputSchema) {
-            const cb = tool.callback;
-            const inputObj = normalizeObjectSchema(tool.inputSchema);
-            const schemaToParse = inputObj !== null && inputObj !== void 0 ? inputObj : tool.inputSchema;
-            const parseResult = await safeParseAsync(schemaToParse, request.params.arguments);
-            if (!parseResult.success) {
-              throw new McpError(exports2.ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`);
-            }
-            const args = parseResult.data;
-            result = await Promise.resolve(cb(args, extra));
-          } else {
-            const cb = tool.callback;
-            result = await Promise.resolve(cb(extra));
+          const isTaskRequest = !!request.params.task;
+          const taskSupport = tool.execution?.taskSupport;
+          const isTaskHandler = "createTask" in tool.handler;
+          if ((taskSupport === "required" || taskSupport === "optional") && !isTaskHandler) {
+            throw new McpError(exports2.ErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
           }
-          if (tool.outputSchema && !result.isError) {
-            if (!result.structuredContent) {
-              throw new McpError(exports2.ErrorCode.InvalidParams, `Output validation error: Tool ${request.params.name} has an output schema but no structured content was provided`);
-            }
-            const outputObj = normalizeObjectSchema(tool.outputSchema);
-            const parseResult = await safeParseAsync(outputObj, result.structuredContent);
-            if (!parseResult.success) {
-              throw new McpError(exports2.ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`);
-            }
+          if (taskSupport === "required" && !isTaskRequest) {
+            throw new McpError(exports2.ErrorCode.MethodNotFound, `Tool ${request.params.name} requires task augmentation (taskSupport: 'required')`);
+          }
+          if (taskSupport === "optional" && !isTaskRequest && isTaskHandler) {
+            return await this.handleAutomaticTaskPolling(tool, request, extra);
+          }
+          const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
+          const result = await this.executeToolHandler(tool, args, extra);
+          if (isTaskRequest) {
+            return result;
           }
+          await this.validateToolOutput(tool, result, request.params.name);
+          return result;
         } catch (error) {
           if (error instanceof McpError) {
             if (error.code === exports2.ErrorCode.UrlElicitationRequired) {
@@ -20293,7 +21706,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           }
           return this.createToolError(error instanceof Error ? error.message : String(error));
         }
-        return result;
       });
       this._toolHandlersInitialized = true;
     }
@@ -20314,6 +21726,101 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         isError: true
       };
     }
+    /**
+     * Validates tool input arguments against the tool's input schema.
+     */
+    async validateToolInput(tool, args, toolName) {
+      if (!tool.inputSchema) {
+        return void 0;
+      }
+      const inputObj = normalizeObjectSchema(tool.inputSchema);
+      const schemaToParse = inputObj ?? tool.inputSchema;
+      const parseResult = await safeParseAsync(schemaToParse, args);
+      if (!parseResult.success) {
+        const error = "error" in parseResult ? parseResult.error : "Unknown error";
+        const errorMessage = getParseErrorMessage(error);
+        throw new McpError(exports2.ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
+      }
+      return parseResult.data;
+    }
+    /**
+     * Validates tool output against the tool's output schema.
+     */
+    async validateToolOutput(tool, result, toolName) {
+      if (!tool.outputSchema) {
+        return;
+      }
+      if (!("content" in result)) {
+        return;
+      }
+      if (result.isError) {
+        return;
+      }
+      if (!result.structuredContent) {
+        throw new McpError(exports2.ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
+      }
+      const outputObj = normalizeObjectSchema(tool.outputSchema);
+      const parseResult = await safeParseAsync(outputObj, result.structuredContent);
+      if (!parseResult.success) {
+        const error = "error" in parseResult ? parseResult.error : "Unknown error";
+        const errorMessage = getParseErrorMessage(error);
+        throw new McpError(exports2.ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
+      }
+    }
+    /**
+     * Executes a tool handler (either regular or task-based).
+     */
+    async executeToolHandler(tool, args, extra) {
+      const handler = tool.handler;
+      const isTaskHandler = "createTask" in handler;
+      if (isTaskHandler) {
+        if (!extra.taskStore) {
+          throw new Error("No task store provided.");
+        }
+        const taskExtra = { ...extra, taskStore: extra.taskStore };
+        if (tool.inputSchema) {
+          const typedHandler = handler;
+          return await Promise.resolve(typedHandler.createTask(args, taskExtra));
+        } else {
+          const typedHandler = handler;
+          return await Promise.resolve(typedHandler.createTask(taskExtra));
+        }
+      }
+      if (tool.inputSchema) {
+        const typedHandler = handler;
+        return await Promise.resolve(typedHandler(args, extra));
+      } else {
+        const typedHandler = handler;
+        return await Promise.resolve(typedHandler(extra));
+      }
+    }
+    /**
+     * Handles automatic task polling for tools with taskSupport 'optional'.
+     */
+    async handleAutomaticTaskPolling(tool, request, extra) {
+      if (!extra.taskStore) {
+        throw new Error("No task store provided for task-capable tool.");
+      }
+      const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
+      const handler = tool.handler;
+      const taskExtra = { ...extra, taskStore: extra.taskStore };
+      const createTaskResult = args ? await Promise.resolve(handler.createTask(args, taskExtra)) : (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await Promise.resolve(handler.createTask(taskExtra))
+      );
+      const taskId = createTaskResult.task.taskId;
+      let task = createTaskResult.task;
+      const pollInterval = task.pollInterval ?? 5e3;
+      while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+        const updatedTask = await extra.taskStore.getTask(taskId);
+        if (!updatedTask) {
+          throw new McpError(exports2.ErrorCode.InternalError, `Task ${taskId} not found during polling`);
+        }
+        task = updatedTask;
+      }
+      return await extra.taskStore.getTaskResult(taskId);
+    }
     setCompletionRequestHandler() {
       if (this._completionHandlerInitialized) {
         return;
@@ -20348,7 +21855,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         return EMPTY_COMPLETION_RESULT;
       }
       const promptShape = getObjectShape(prompt.argsSchema);
-      const field = promptShape === null || promptShape === void 0 ? void 0 : promptShape[request.params.argument.name];
+      const field = promptShape?.[request.params.argument.name];
       if (!isCompletable(field)) {
         return EMPTY_COMPLETION_RESULT;
       }
@@ -20433,7 +21940,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         }
         throw new McpError(exports2.ErrorCode.InvalidParams, `Resource ${uri2} not found`);
       });
-      this.setCompletionRequestHandler();
       this._resourceHandlersInitialized = true;
     }
     setPromptRequestHandlers() {
@@ -20469,7 +21975,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           const argsObj = normalizeObjectSchema(prompt.argsSchema);
           const parseResult = await safeParseAsync(argsObj, request.params.arguments);
           if (!parseResult.success) {
-            throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`);
+            const error = "error" in parseResult ? parseResult.error : "Unknown error";
+            const errorMessage = getParseErrorMessage(error);
+            throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
           }
           const args = parseResult.data;
           const cb = prompt.callback;
@@ -20479,7 +21987,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           return await Promise.resolve(cb(extra));
         }
       });
-      this.setCompletionRequestHandler();
       this._promptHandlersInitialized = true;
     }
     resource(name, uriOrTemplate, ...rest) {
@@ -20587,6 +22094,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         }
       };
       this._registeredResourceTemplates[name] = registeredResourceTemplate;
+      const variableNames = template.uriTemplate.variableNames;
+      const hasCompleter = Array.isArray(variableNames) && variableNames.some((v) => !!template.completeCallback(v));
+      if (hasCompleter) {
+        this.setCompletionRequestHandler();
+      }
       return registeredResourceTemplate;
     }
     _createRegisteredPrompt(name, title2, description2, argsSchema, callback) {
@@ -20619,9 +22131,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         }
       };
       this._registeredPrompts[name] = registeredPrompt;
+      if (argsSchema) {
+        const hasCompletable = Object.values(argsSchema).some((field) => {
+          const inner = field instanceof ZodOptional ? field._def?.innerType : field;
+          return isCompletable(inner);
+        });
+        if (hasCompletable) {
+          this.setCompletionRequestHandler();
+        }
+      }
       return registeredPrompt;
     }
-    _createRegisteredTool(name, title2, description2, inputSchema, outputSchema, annotations, _meta, callback) {
+    _createRegisteredTool(name, title2, description2, inputSchema, outputSchema, annotations, execution, _meta, handler) {
       validateAndWarnToolName(name);
       const registeredTool = {
         title: title2,
@@ -20629,8 +22150,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         inputSchema: getZodSchemaObject(inputSchema),
         outputSchema: getZodSchemaObject(outputSchema),
         annotations,
+        execution,
         _meta,
-        callback,
+        handler,
         enabled: true,
         disable: () => registeredTool.update({ enabled: false }),
         enable: () => registeredTool.update({ enabled: true }),
@@ -20650,8 +22172,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             registeredTool.description = updates.description;
           if (typeof updates.paramsSchema !== "undefined")
             registeredTool.inputSchema = objectFromShape(updates.paramsSchema);
+          if (typeof updates.outputSchema !== "undefined")
+            registeredTool.outputSchema = objectFromShape(updates.outputSchema);
           if (typeof updates.callback !== "undefined")
-            registeredTool.callback = updates.callback;
+            registeredTool.handler = updates.callback;
           if (typeof updates.annotations !== "undefined")
             registeredTool.annotations = updates.annotations;
           if (typeof updates._meta !== "undefined")
@@ -20682,9 +22206,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       if (rest.length > 1) {
         const firstArg = rest[0];
-        if (isZodRawShape(firstArg)) {
+        if (isZodRawShapeCompat(firstArg)) {
           inputSchema = rest.shift();
-          if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShape(rest[0])) {
+          if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShapeCompat(rest[0])) {
             annotations = rest.shift();
           }
         } else if (typeof firstArg === "object" && firstArg !== null) {
@@ -20692,7 +22216,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         }
       }
       const callback = rest[0];
-      return this._createRegisteredTool(name, void 0, description2, inputSchema, outputSchema, annotations, void 0, callback);
+      return this._createRegisteredTool(name, void 0, description2, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, void 0, callback);
     }
     /**
      * Registers a tool with a config object and callback.
@@ -20702,7 +22226,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         throw new Error(`Tool ${name} is already registered`);
       }
       const { title: title2, description: description2, inputSchema, outputSchema, annotations, _meta } = config2;
-      return this._createRegisteredTool(name, title2, description2, inputSchema, outputSchema, annotations, _meta, cb);
+      return this._createRegisteredTool(name, title2, description2, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
     }
     prompt(name, ...rest) {
       if (this._registeredPrompts[name]) {
@@ -20798,28 +22322,36 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * Gets the callback for completing a specific URI template variable, if one was provided.
      */
     completeCallback(variable) {
-      var _a;
-      return (_a = this._callbacks.complete) === null || _a === void 0 ? void 0 : _a[variable];
+      return this._callbacks.complete?.[variable];
     }
   }
   const EMPTY_OBJECT_JSON_SCHEMA = {
     type: "object",
     properties: {}
   };
-  function isZodRawShape(obj) {
-    if (typeof obj !== "object" || obj === null)
-      return false;
-    const isEmptyObject = Object.keys(obj).length === 0;
-    return isEmptyObject || Object.values(obj).some(isZodTypeLike);
-  }
   function isZodTypeLike(value) {
     return value !== null && typeof value === "object" && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
   }
+  function isZodSchemaInstance(obj) {
+    return "_def" in obj || "_zod" in obj || isZodTypeLike(obj);
+  }
+  function isZodRawShapeCompat(obj) {
+    if (typeof obj !== "object" || obj === null) {
+      return false;
+    }
+    if (isZodSchemaInstance(obj)) {
+      return false;
+    }
+    if (Object.keys(obj).length === 0) {
+      return true;
+    }
+    return Object.values(obj).some(isZodTypeLike);
+  }
   function getZodSchemaObject(schema) {
     if (!schema) {
       return void 0;
     }
-    if (isZodRawShape(schema)) {
+    if (isZodRawShapeCompat(schema)) {
       return objectFromShape(schema);
     }
     return schema;
@@ -20840,7 +22372,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   }
   function getMethodValue(schema) {
     const shape = getObjectShape(schema);
-    const methodSchema = shape === null || shape === void 0 ? void 0 : shape.method;
+    const methodSchema = shape?.method;
     if (!methodSchema) {
       throw new Error("Schema is missing a method literal");
     }
@@ -20865,7 +22397,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       hasMore: false
     }
   };
-  exports2.Ajv = ajv;
+  exports2.Ajv = Ajv;
+  exports2.AnnotationsSchema = AnnotationsSchema;
   exports2.AudioContentSchema = AudioContentSchema;
   exports2.BaseMetadataSchema = BaseMetadataSchema;
   exports2.BlobResourceContentsSchema = BlobResourceContentsSchema;
@@ -20874,6 +22407,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.CallToolRequestParamsSchema = CallToolRequestParamsSchema;
   exports2.CallToolRequestSchema = CallToolRequestSchema;
   exports2.CallToolResultSchema = CallToolResultSchema;
+  exports2.CancelTaskRequestSchema = CancelTaskRequestSchema;
+  exports2.CancelTaskResultSchema = CancelTaskResultSchema;
   exports2.CancelledNotificationParamsSchema = CancelledNotificationParamsSchema;
   exports2.CancelledNotificationSchema = CancelledNotificationSchema;
   exports2.Client = Client;
@@ -20881,6 +22416,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.ClientNotificationSchema = ClientNotificationSchema;
   exports2.ClientRequestSchema = ClientRequestSchema;
   exports2.ClientResultSchema = ClientResultSchema;
+  exports2.ClientTasksCapabilitySchema = ClientTasksCapabilitySchema;
   exports2.CompatibilityCallToolResultSchema = CompatibilityCallToolResultSchema;
   exports2.CompleteRequestParamsSchema = CompleteRequestParamsSchema;
   exports2.CompleteRequestSchema = CompleteRequestSchema;
@@ -20889,6 +22425,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.CreateMessageRequestParamsSchema = CreateMessageRequestParamsSchema;
   exports2.CreateMessageRequestSchema = CreateMessageRequestSchema;
   exports2.CreateMessageResultSchema = CreateMessageResultSchema;
+  exports2.CreateMessageResultWithToolsSchema = CreateMessageResultWithToolsSchema;
+  exports2.CreateTaskResultSchema = CreateTaskResultSchema;
   exports2.CursorSchema = CursorSchema;
   exports2.DEFAULT_NEGOTIATED_PROTOCOL_VERSION = DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
   exports2.DEFAULT_REQUEST_TIMEOUT_MSEC = DEFAULT_REQUEST_TIMEOUT_MSEC;
@@ -20905,6 +22443,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.GetPromptRequestParamsSchema = GetPromptRequestParamsSchema;
   exports2.GetPromptRequestSchema = GetPromptRequestSchema;
   exports2.GetPromptResultSchema = GetPromptResultSchema;
+  exports2.GetTaskPayloadRequestSchema = GetTaskPayloadRequestSchema;
+  exports2.GetTaskPayloadResultSchema = GetTaskPayloadResultSchema;
+  exports2.GetTaskRequestSchema = GetTaskRequestSchema;
+  exports2.GetTaskResultSchema = GetTaskResultSchema;
   exports2.IconSchema = IconSchema;
   exports2.IconsSchema = IconsSchema;
   exports2.ImageContentSchema = ImageContentSchema;
@@ -20913,14 +22455,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.InitializeRequestSchema = InitializeRequestSchema;
   exports2.InitializeResultSchema = InitializeResultSchema;
   exports2.InitializedNotificationSchema = InitializedNotificationSchema;
+  exports2.JSONRPCErrorResponseSchema = JSONRPCErrorResponseSchema;
   exports2.JSONRPCErrorSchema = JSONRPCErrorSchema;
   exports2.JSONRPCMessageSchema = JSONRPCMessageSchema;
   exports2.JSONRPCNotificationSchema = JSONRPCNotificationSchema;
   exports2.JSONRPCRequestSchema = JSONRPCRequestSchema;
   exports2.JSONRPCResponseSchema = JSONRPCResponseSchema;
+  exports2.JSONRPCResultResponseSchema = JSONRPCResultResponseSchema;
   exports2.JSONRPC_VERSION = JSONRPC_VERSION;
   exports2.LATEST_PROTOCOL_VERSION = LATEST_PROTOCOL_VERSION;
   exports2.LegacyTitledEnumSchemaSchema = LegacyTitledEnumSchemaSchema;
+  exports2.ListChangedOptionsBaseSchema = ListChangedOptionsBaseSchema;
   exports2.ListPromptsRequestSchema = ListPromptsRequestSchema;
   exports2.ListPromptsResultSchema = ListPromptsResultSchema;
   exports2.ListResourceTemplatesRequestSchema = ListResourceTemplatesRequestSchema;
@@ -20929,6 +22474,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.ListResourcesResultSchema = ListResourcesResultSchema;
   exports2.ListRootsRequestSchema = ListRootsRequestSchema;
   exports2.ListRootsResultSchema = ListRootsResultSchema;
+  exports2.ListTasksRequestSchema = ListTasksRequestSchema;
+  exports2.ListTasksResultSchema = ListTasksResultSchema;
   exports2.ListToolsRequestSchema = ListToolsRequestSchema;
   exports2.ListToolsResultSchema = ListToolsResultSchema;
   exports2.LoggingLevelSchema = LoggingLevelSchema;
@@ -20956,9 +22503,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.PromptReferenceSchema = PromptReferenceSchema;
   exports2.PromptSchema = PromptSchema;
   exports2.Protocol = Protocol;
+  exports2.RELATED_TASK_META_KEY = RELATED_TASK_META_KEY;
   exports2.ReadResourceRequestParamsSchema = ReadResourceRequestParamsSchema;
   exports2.ReadResourceRequestSchema = ReadResourceRequestSchema;
   exports2.ReadResourceResultSchema = ReadResourceResultSchema;
+  exports2.RelatedTaskMetadataSchema = RelatedTaskMetadataSchema;
   exports2.RequestIdSchema = RequestIdSchema;
   exports2.RequestSchema = RequestSchema;
   exports2.ResourceContentsSchema = ResourceContentsSchema;
@@ -20973,16 +22522,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.ResourceUpdatedNotificationParamsSchema = ResourceUpdatedNotificationParamsSchema;
   exports2.ResourceUpdatedNotificationSchema = ResourceUpdatedNotificationSchema;
   exports2.ResultSchema = ResultSchema;
+  exports2.RoleSchema = RoleSchema;
   exports2.RootSchema = RootSchema;
   exports2.RootsListChangedNotificationSchema = RootsListChangedNotificationSchema;
   exports2.SSEClientTransport = SSEClientTransport;
   exports2.SUPPORTED_PROTOCOL_VERSIONS = SUPPORTED_PROTOCOL_VERSIONS;
+  exports2.SamplingContentSchema = SamplingContentSchema;
   exports2.SamplingMessageContentBlockSchema = SamplingMessageContentBlockSchema;
   exports2.SamplingMessageSchema = SamplingMessageSchema;
   exports2.ServerCapabilitiesSchema = ServerCapabilitiesSchema;
   exports2.ServerNotificationSchema = ServerNotificationSchema;
   exports2.ServerRequestSchema = ServerRequestSchema;
   exports2.ServerResultSchema = ServerResultSchema;
+  exports2.ServerTasksCapabilitySchema = ServerTasksCapabilitySchema;
   exports2.SetLevelRequestParamsSchema = SetLevelRequestParamsSchema;
   exports2.SetLevelRequestSchema = SetLevelRequestSchema;
   exports2.SingleSelectEnumSchemaSchema = SingleSelectEnumSchemaSchema;
@@ -20992,12 +22544,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.StringSchemaSchema = StringSchemaSchema;
   exports2.SubscribeRequestParamsSchema = SubscribeRequestParamsSchema;
   exports2.SubscribeRequestSchema = SubscribeRequestSchema;
+  exports2.TaskAugmentedRequestParamsSchema = TaskAugmentedRequestParamsSchema;
+  exports2.TaskCreationParamsSchema = TaskCreationParamsSchema;
+  exports2.TaskMetadataSchema = TaskMetadataSchema;
+  exports2.TaskSchema = TaskSchema;
+  exports2.TaskStatusNotificationParamsSchema = TaskStatusNotificationParamsSchema;
+  exports2.TaskStatusNotificationSchema = TaskStatusNotificationSchema;
+  exports2.TaskStatusSchema = TaskStatusSchema;
   exports2.TextContentSchema = TextContentSchema;
   exports2.TextResourceContentsSchema = TextResourceContentsSchema;
   exports2.TitledMultiSelectEnumSchemaSchema = TitledMultiSelectEnumSchemaSchema;
   exports2.TitledSingleSelectEnumSchemaSchema = TitledSingleSelectEnumSchemaSchema;
   exports2.ToolAnnotationsSchema = ToolAnnotationsSchema;
   exports2.ToolChoiceSchema = ToolChoiceSchema;
+  exports2.ToolExecutionSchema = ToolExecutionSchema;
   exports2.ToolListChangedNotificationSchema = ToolListChangedNotificationSchema;
   exports2.ToolResultContentSchema = ToolResultContentSchema;
   exports2.ToolSchema = ToolSchema;
@@ -21021,6 +22581,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.exchangeAuthorization = exchangeAuthorization;
   exports2.extractResourceMetadataUrl = extractResourceMetadataUrl;
   exports2.extractWWWAuthenticateParams = extractWWWAuthenticateParams;
+  exports2.fetchToken = fetchToken;
   exports2.getCompleter = getCompleter;
   exports2.getDisplayName = getDisplayName;
   exports2.getSupportedElicitationModes = getSupportedElicitationModes;
@@ -21029,12 +22590,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.isInitializeRequest = isInitializeRequest;
   exports2.isInitializedNotification = isInitializedNotification;
   exports2.isJSONRPCError = isJSONRPCError;
+  exports2.isJSONRPCErrorResponse = isJSONRPCErrorResponse;
   exports2.isJSONRPCNotification = isJSONRPCNotification;
   exports2.isJSONRPCRequest = isJSONRPCRequest;
   exports2.isJSONRPCResponse = isJSONRPCResponse;
+  exports2.isJSONRPCResultResponse = isJSONRPCResultResponse;
+  exports2.isTaskAugmentedRequestParams = isTaskAugmentedRequestParams;
   exports2.mergeCapabilities = mergeCapabilities;
   exports2.normalizeHeaders = normalizeHeaders;
   exports2.parseErrorResponse = parseErrorResponse;
+  exports2.prepareAuthorizationCodeRequest = prepareAuthorizationCodeRequest;
   exports2.refreshAuthorization = refreshAuthorization;
   exports2.registerClient = registerClient;
   exports2.selectClientAuthMethod = selectClientAuthMethod;