@opentiny/next-sdk 0.2.0 → 0.2.2

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

@@ -1,7 +1,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 = {};
@@ -3917,7 +3917,7 @@ function requireCore$1() {
         uriResolver
       };
     }
-    class Ajv {
+    class Ajv2 {
       constructor(opts = {}) {
         this.schemas = {};
         this.refs = {};
@@ -4287,9 +4287,9 @@ function requireCore$1() {
         }
       }
     }
-    Ajv.ValidationError = validation_error_1.default;
-    Ajv.MissingRefError = ref_error_1.default;
-    exports.default = Ajv;
+    Ajv2.ValidationError = validation_error_1.default;
+    Ajv2.MissingRefError = ref_error_1.default;
+    exports.default = Ajv2;
     function checkOptions(checkOpts, options, msg, log = "error") {
       for (const key in checkOpts) {
         const opt = key;
@@ -6241,7 +6241,7 @@ const require$$3 = {
 };
 var hasRequiredAjv;
 function requireAjv() {
-  if (hasRequiredAjv) return ajv$1.exports;
+  if (hasRequiredAjv) return ajv.exports;
   hasRequiredAjv = 1;
   (function(module, exports) {
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -6252,7 +6252,7 @@ function requireAjv() {
     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));
@@ -6271,11 +6271,11 @@ function requireAjv() {
         return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
       }
     }
-    exports.Ajv = Ajv;
-    module.exports = exports = Ajv;
-    module.exports.Ajv = Ajv;
+    exports.Ajv = Ajv2;
+    module.exports = exports = Ajv2;
+    module.exports.Ajv = Ajv2;
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.default = Ajv;
+    exports.default = Ajv2;
     var validate_1 = requireValidate();
     Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
       return validate_1.KeywordCxt;
@@ -6307,11 +6307,11 @@ function requireAjv() {
     Object.defineProperty(exports, "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"
 });
@@ -6847,8 +6847,9 @@ const string$1 = (params) => {
   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) => {
@@ -7658,7 +7659,7 @@ const $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
 });
 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 {
@@ -7705,6 +7706,23 @@ const $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
     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;
@@ -8792,6 +8810,14 @@ function _number(Class, params) {
     ...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",
@@ -8807,6 +8833,12 @@ function _boolean(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _null$1(Class, params) {
+  return new Class({
+    type: "null",
+    ...normalizeParams(params)
+  });
+}
 function _any(Class) {
   return new Class({
     type: "any"
@@ -10030,7 +10062,7 @@ const ZodNumber$1 = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
   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) => {
@@ -10047,6 +10079,13 @@ const ZodBoolean$1 = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
 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);
@@ -10415,48 +10454,85 @@ function preprocess(fn, schema) {
 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,
@@ -10468,12 +10544,13 @@ const JSONRPCNotificationSchema = object$1({
   ...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;
 var ErrorCode;
 (function(ErrorCode2) {
   ErrorCode2[ErrorCode2["ConnectionClosed"] = -32e3] = "ConnectionClosed";
@@ -10485,14 +10562,14 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["InternalError"] = -32603] = "InternalError";
   ErrorCode2[ErrorCode2["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
 })(ErrorCode || (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.
      */
@@ -10500,11 +10577,19 @@ const JSONRPCErrorSchema = object$1({
     /**
      * 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({
   /**
@@ -10512,7 +10597,7 @@ const CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
    *
    * 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.
    */
@@ -10537,7 +10622,15 @@ const IconSchema = object$1({
    *
    * 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({
   /**
@@ -10573,7 +10666,15 @@ const ImplementationSchema = BaseMetadataSchema.extend({
   /**
    * 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()
@@ -10589,6 +10690,54 @@ const ElicitationCapabilitySchema = preprocess((value) => {
   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.
@@ -10620,7 +10769,11 @@ const ClientCapabilitiesSchema = object$1({
      * 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({
   /**
@@ -10651,12 +10804,12 @@ const ServerCapabilitiesSchema = object$1({
   /**
    * 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.
    */
@@ -10678,7 +10831,11 @@ const ServerCapabilitiesSchema = object$1({
      * 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({
   /**
@@ -10695,21 +10852,23 @@ const InitializeResultSchema = ResultSchema.extend({
   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.
    */
@@ -10742,8 +10901,66 @@ const PaginatedResultSchema = ResultSchema.extend({
    * An opaque token representing the pagination position after the last returned result.
    * If present, there may be more results available.
    */
-  nextCursor: 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.
@@ -10769,7 +10986,7 @@ const Base64Schema = string().refine((val) => {
   try {
     atob(val);
     return true;
-  } catch (_a) {
+  } catch {
     return false;
   }
 }, { message: "Invalid Base64 string" });
@@ -10779,6 +10996,21 @@ const BlobResourceContentsSchema = ResourceContentsSchema.extend({
    */
   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,
@@ -10796,6 +11028,10 @@ const ResourceSchema = object$1({
    * 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.
@@ -10819,6 +11055,10 @@ const ResourceTemplateSchema = object$1({
    * 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.
@@ -10854,7 +11094,8 @@ const ReadResourceResultSchema = ResultSchema.extend({
   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({
@@ -10933,6 +11174,10 @@ const TextContentSchema = object$1({
    * 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.
@@ -10949,6 +11194,10 @@ const ImageContentSchema = object$1({
    * 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.
@@ -10965,6 +11214,10 @@ const AudioContentSchema = object$1({
    * 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.
@@ -10987,16 +11240,20 @@ const ToolUseContentSchema = object$1({
    * 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.
@@ -11014,18 +11271,19 @@ const ContentBlockSchema = union([
   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({
   /**
@@ -11066,6 +11324,17 @@ const ToolAnnotationsSchema = object$1({
    */
   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,
@@ -11095,7 +11364,11 @@ const ToolSchema = object$1({
   /**
    * 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.
@@ -11136,12 +11409,12 @@ const CallToolResultSchema = ResultSchema.extend({
    * 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.
    */
@@ -11149,14 +11422,35 @@ const CallToolRequestParamsSchema = BaseRequestParamsSchema.extend({
   /**
    * 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({
@@ -11197,19 +11491,19 @@ const ModelPreferencesSchema = object$1({
   /**
    * 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({
   /**
@@ -11218,20 +11512,21 @@ const ToolChoiceSchema = object$1({
    * - "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,
@@ -11240,15 +11535,15 @@ const SamplingMessageContentBlockSchema = discriminatedUnion("type", [
   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.
@@ -11266,13 +11561,13 @@ const CreateMessageRequestParamsSchema = BaseRequestParamsSchema.extend({
    * 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.
@@ -11282,19 +11577,41 @@ const CreateMessageRequestParamsSchema = BaseRequestParamsSchema.extend({
    * Tools that the model may use during generation.
    * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared.
    */
-  tools: 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.
    */
@@ -11311,9 +11628,9 @@ const CreateMessageResultSchema = ResultSchema.extend({
    * 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)])
 });
@@ -11327,8 +11644,8 @@ const StringSchemaSchema = object$1({
   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()
 });
@@ -11336,9 +11653,9 @@ const NumberSchemaSchema = object$1({
   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"),
@@ -11370,8 +11687,8 @@ const UntitledMultiSelectEnumSchemaSchema = object$1({
   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())
@@ -11382,8 +11699,8 @@ const TitledMultiSelectEnumSchemaSchema = object$1({
   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(),
@@ -11395,7 +11712,7 @@ const TitledMultiSelectEnumSchemaSchema = object$1({
 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.
    *
@@ -11416,7 +11733,7 @@ const ElicitRequestFormParamsSchema = BaseRequestParamsSchema.extend({
     required: array(string()).optional()
   })
 });
-const ElicitRequestURLParamsSchema = BaseRequestParamsSchema.extend({
+const ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({
   /**
    * The elicitation mode.
    */
@@ -11461,8 +11778,10 @@ const ElicitResultSchema = ResultSchema.extend({
   /**
    * 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"),
@@ -11524,7 +11843,7 @@ const CompleteResultSchema = ResultSchema.extend({
     /**
      * 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.
      */
@@ -11547,13 +11866,15 @@ const RootSchema = object$1({
   _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,
@@ -11568,16 +11889,39 @@ const ClientRequestSchema = union([
   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,
@@ -11586,6 +11930,7 @@ const ServerNotificationSchema = union([
   ResourceListChangedNotificationSchema,
   ToolListChangedNotificationSchema,
   PromptListChangedNotificationSchema,
+  TaskStatusNotificationSchema,
   ElicitationCompleteNotificationSchema
 ]);
 const ServerResultSchema = union([
@@ -11598,7 +11943,10 @@ const ServerResultSchema = union([
   ListResourceTemplatesResultSchema,
   ReadResourceResultSchema,
   CallToolResultSchema,
-  ListToolsResultSchema
+  ListToolsResultSchema,
+  GetTaskResultSchema,
+  ListTasksResultSchema,
+  CreateTaskResultSchema
 ]);
 class McpError extends Error {
   constructor(code2, message, data) {
@@ -11627,8 +11975,7 @@ class UrlElicitationRequiredError extends McpError {
     });
   }
   get elicitations() {
-    var _a, _b;
-    return (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.elicitations) !== null && _b !== void 0 ? _b : [];
+    return this.data?.elicitations ?? [];
   }
 }
 const MAX_TEMPLATE_LENGTH = 1e6;
@@ -11798,7 +12145,7 @@ class UriTemplate {
     const name = part.name;
     switch (part.operator) {
       case "":
-        pattern2 = part.exploded ? "([^/]+(?:,[^/]+)*)" : "([^/,]+)";
+        pattern2 = part.exploded ? "([^/,]+(?:,[^/,]+)*)" : "([^/,]+)";
         break;
       case "+":
       case "#":
@@ -11808,7 +12155,7 @@ class UriTemplate {
         pattern2 = "\\.([^/,]+)";
         break;
       case "/":
-        pattern2 = "/" + (part.exploded ? "([^/]+(?:,[^/]+)*)" : "([^/,]+)");
+        pattern2 = "/" + (part.exploded ? "([^/,]+(?:,[^/,]+)*)" : "([^/,]+)");
         break;
       default:
         pattern2 = "([^/]+)";
@@ -11866,7 +12213,7 @@ function isCompletable(schema) {
 }
 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;
@@ -11876,11 +12223,10 @@ var McpZodTypeKind;
   McpZodTypeKind2["Completable"] = "McpCompletable";
 })(McpZodTypeKind || (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;
@@ -15533,13 +15879,12 @@ async function safeParseAsync(schema, data) {
   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;
@@ -15549,14 +15894,13 @@ function getObjectShape(schema) {
   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") {
@@ -15571,8 +15915,8 @@ function normalizeObjectSchema(schema) {
   }
   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 {
@@ -15596,38 +15940,30 @@ function getParseErrorMessage(error) {
     }
     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;
@@ -15650,6 +15986,9 @@ function getLiteralValue(schema) {
     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,
@@ -16863,21 +17202,20 @@ function mapMiniTarget(t) {
   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");
   }
@@ -16906,9 +17244,10 @@ class Protocol {
     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);
@@ -16918,6 +17257,117 @@ class Protocol {
       // 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(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(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(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(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
+          }
+          if (isTerminal(task.status)) {
+            throw new McpError(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(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
+          }
+          return {
+            _meta: {},
+            ...cancelledTask
+          };
+        } catch (error) {
+          if (error instanceof McpError) {
+            throw error;
+          }
+          throw new McpError(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, {
@@ -16958,22 +17408,21 @@ class Protocol {
    * 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);
@@ -16986,80 +17435,131 @@ class Protocol {
     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(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: 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"] : 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);
     });
@@ -17078,6 +17578,9 @@ class Protocol {
       try {
         this._resetTimeout(messageId);
       } catch (error) {
+        this._responseHandlers.delete(messageId);
+        this._progressHandlers.delete(messageId);
+        this._cleanupTimeout(messageId);
         responseHandler(error);
         return;
       }
@@ -17086,15 +17589,39 @@ class Protocol {
   }
   _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);
@@ -17108,60 +17635,169 @@ class Protocol {
    * 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 wait for a response.
+   * 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(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(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(ErrorCode.InternalError, `Task ${taskId} failed`)
+            };
+          } else if (task2.status === "cancelled") {
+            yield {
+              type: "error",
+              error: new McpError(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(ErrorCode.InternalError, String(error))
+      };
+    }
+  }
+  /**
+   * 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(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) {
@@ -17178,53 +17814,147 @@ class Protocol {
           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(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);
   }
   /**
@@ -17272,6 +18002,150 @@ class Protocol {
   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(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(ErrorCode.InvalidRequest, "Request cancelled"));
+        return;
+      }
+      const timeoutId = setTimeout(resolve2, interval);
+      signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+        reject(new McpError(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(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(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
+        }
+        if (isTerminal(task.status)) {
+          throw new McpError(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);
@@ -17618,7 +18492,7 @@ function requireDist() {
 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,
@@ -17650,7 +18524,7 @@ class AjvJsonSchemaValidator {
    * ```
    */
   constructor(ajv2) {
-    this._ajv = ajv2 !== null && ajv2 !== void 0 ? ajv2 : createDefaultAjvInstance();
+    this._ajv = ajv2 ?? createDefaultAjvInstance();
   }
   /**
    * Create a validator for the given JSON Schema
@@ -17662,8 +18536,7 @@ class AjvJsonSchemaValidator {
    * @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) {
@@ -17682,6 +18555,187 @@ class AjvJsonSchemaValidator {
     };
   }
 }
+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(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(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(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;
@@ -17700,12 +18754,16 @@ function applyElicitationDefaults(schema, data) {
   }
   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);
+      }
     }
   }
 }
@@ -17724,12 +18782,58 @@ class Client extends Protocol {
    * 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.
@@ -17746,21 +18850,20 @@ class Client extends Protocol {
    * 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");
@@ -17768,34 +18871,41 @@ class Client extends Protocol {
     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(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(ErrorCode.InvalidParams, "Client does not support form-mode elicitation requests");
         }
-        if (mode === "url" && !supportsUrlMode) {
+        if (params.mode === "url" && !supportsUrlMode) {
           throw new McpError(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(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(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 {
             }
           }
         }
@@ -17803,11 +18913,36 @@ class Client extends Protocol {
       };
       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(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(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(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})`);
     }
   }
@@ -17840,6 +18975,10 @@ class Client extends Protocol {
       await this.notification({
         method: "notifications/initialized"
       });
+      if (this._pendingListChangedConfig) {
+        this._setupListChangedHandlers(this._pendingListChangedConfig);
+        this._pendingListChangedConfig = void 0;
+      }
     } catch (error) {
       void this.close();
       throw error;
@@ -17864,16 +19003,15 @@ class Client extends Protocol {
     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;
@@ -17882,7 +19020,7 @@ class Client extends Protocol {
       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) {
@@ -17891,28 +19029,30 @@ class Client extends Protocol {
         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) {
@@ -17929,7 +19069,24 @@ class Client extends Protocol {
           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);
@@ -17961,7 +19118,15 @@ class Client extends Protocol {
   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(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) {
@@ -17984,17 +19149,39 @@ class Client extends Protocol {
     }
     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);
+      }
     }
   }
   /**
@@ -18005,9 +19192,50 @@ class Client extends Protocol {
   }
   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" });
   }
@@ -18181,8 +19409,8 @@ const OAuthClientMetadataSchema = object$1({
 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({
@@ -18282,6 +19510,9 @@ InvalidClientMetadataError.errorCode = "invalid_client_metadata";
 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,
@@ -18298,11 +19529,12 @@ const OAUTH_ERRORS = {
   [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) {
@@ -18375,22 +19607,20 @@ async function parseErrorResponse(input) {
   }
 }
 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 {
@@ -18398,7 +19628,7 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope: sco
     if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
       authorizationServerUrl = resourceMetadata.authorization_servers[0];
     }
-  } catch (_c) {
+  } catch {
   }
   if (!authorizationServerUrl) {
     authorizationServerUrl = new URL("/", serverUrl);
@@ -18412,7 +19642,7 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope: sco
     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}`);
@@ -18422,7 +19652,7 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope: sco
       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");
@@ -18436,23 +19666,19 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope: sco
       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,
@@ -18477,7 +19703,7 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope: sco
     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);
@@ -18490,14 +19716,14 @@ function isHttpsUrl(value) {
   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;
@@ -18521,7 +19747,7 @@ function extractWWWAuthenticateParams(res) {
   if (resourceMetadataMatch) {
     try {
       resourceMetadataUrl = new URL(resourceMetadataMatch);
-    } catch (_a) {
+    } catch {
     }
   }
   const scope2 = extractFieldFromWwwAuth(res, "scope") || void 0;
@@ -18560,19 +19786,21 @@ function extractResourceMetadataUrl(res) {
   }
   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());
@@ -18607,19 +19835,18 @@ function shouldAttemptFallback(response, pathname) {
   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);
   }
@@ -18635,15 +19862,17 @@ async function discoverOAuthMetadata(issuer, { authorizationServerUrl, protocolV
   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());
@@ -18693,6 +19922,7 @@ async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fet
       continue;
     }
     if (!response.ok) {
+      await response.body?.cancel();
       if (response.status >= 400 && response.status < 500) {
         continue;
       }
@@ -18733,7 +19963,7 @@ async function startAuthorization(authorizationServerUrl, { metadata: metadata2,
   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) {
@@ -18741,81 +19971,91 @@ async function startAuthorization(authorizationServerUrl, { metadata: metadata2,
   }
   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;
@@ -18827,7 +20067,7 @@ async function registerClient(authorizationServerUrl, { metadata: metadata2, cli
   } 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"
@@ -19227,7 +20467,7 @@ function createFetchWithInit(baseFetch = fetch, baseInit) {
       ...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);
   };
@@ -19244,14 +20484,13 @@ class SSEClientTransport {
     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");
     }
@@ -19264,7 +20503,7 @@ class SSEClientTransport {
         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") {
@@ -19273,7 +20512,6 @@ class SSEClientTransport {
     return await this._startOrAuth();
   }
   async _commonHeaders() {
-    var _a;
     const headers = {};
     if (this._authProvider) {
       const tokens = await this._authProvider.tokens();
@@ -19284,11 +20522,14 @@ class SSEClientTransport {
     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,
@@ -19309,19 +20550,17 @@ class SSEClientTransport {
       });
       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);
@@ -19330,23 +20569,22 @@ class SSEClientTransport {
           }
         } 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);
       };
     });
   }
@@ -19375,13 +20613,11 @@ class SSEClientTransport {
     }
   }
   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");
     }
@@ -19393,10 +20629,11 @@ class SSEClientTransport {
         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;
@@ -19412,11 +20649,11 @@ class SSEClientTransport {
           }
           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;
     }
   }
@@ -19460,20 +20697,18 @@ class StreamableHTTPError extends Error {
 }
 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");
     }
@@ -19486,7 +20721,7 @@ class StreamableHTTPClientTransport {
         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") {
@@ -19495,7 +20730,6 @@ class StreamableHTTPClientTransport {
     return await this._startOrAuthSse({ resumptionToken: void 0 });
   }
   async _commonHeaders() {
-    var _a;
     const headers = {};
     if (this._authProvider) {
       const tokens = await this._authProvider.tokens();
@@ -19509,14 +20743,13 @@ class StreamableHTTPClientTransport {
     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();
@@ -19524,12 +20757,13 @@ class StreamableHTTPClientTransport {
       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();
         }
@@ -19540,7 +20774,7 @@ class StreamableHTTPClientTransport {
       }
       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;
     }
   }
@@ -19566,17 +20800,15 @@ class StreamableHTTPClientTransport {
    * @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);
@@ -19588,8 +20820,8 @@ class StreamableHTTPClientTransport {
     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) => {
@@ -19604,22 +20836,29 @@ class StreamableHTTPClientTransport {
           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,
@@ -19627,9 +20866,10 @@ class StreamableHTTPClientTransport {
           }, 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,
@@ -19637,7 +20877,7 @@ class StreamableHTTPClientTransport {
               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)}`));
           }
         }
       }
@@ -19669,19 +20909,18 @@ class StreamableHTTPClientTransport {
     }
   }
   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();
@@ -19692,14 +20931,15 @@ class StreamableHTTPClientTransport {
         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");
@@ -19732,7 +20972,7 @@ class StreamableHTTPClientTransport {
             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,
@@ -19745,17 +20985,14 @@ class StreamableHTTPClientTransport {
             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;
       }
@@ -19763,20 +21000,23 @@ class StreamableHTTPClientTransport {
       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;
     }
   }
@@ -19795,7 +21035,6 @@ class StreamableHTTPClientTransport {
    * the server does not allow clients to terminate sessions.
    */
   async terminateSession() {
-    var _a, _b, _c;
     if (!this._sessionId) {
       return;
     }
@@ -19805,15 +21044,16 @@ class StreamableHTTPClientTransport {
         ...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;
     }
   }
@@ -19833,16 +21073,85 @@ class StreamableHTTPClientTransport {
   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();
@@ -19851,18 +21160,14 @@ class Server extends Protocol {
       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) {
@@ -19872,6 +21177,21 @@ class Server extends Protocol {
       });
     }
   }
+  /**
+   * 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.
    *
@@ -19883,28 +21203,77 @@ class Server extends Protocol {
     }
     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(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(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(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) {
@@ -19928,13 +21297,16 @@ class Server extends Protocol {
         }
         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) {
@@ -19965,7 +21337,24 @@ class Server extends Protocol {
           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;
@@ -19997,10 +21386,10 @@ class Server extends Protocol {
   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.");
       }
     }
@@ -20027,6 +21416,9 @@ class Server extends Protocol {
         }
       }
     }
+    if (params.tools) {
+      return this.request({ method: "sampling/createMessage", params }, CreateMessageResultWithToolsSchema, options);
+    }
     return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
   }
   /**
@@ -20037,18 +21429,17 @@ class Server extends Protocol {
    * @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" };
@@ -20080,8 +21471,7 @@ class Server extends Protocol {
    * @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({
@@ -20182,6 +21572,19 @@ function validateAndWarnToolName(name) {
   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 = {};
@@ -20194,6 +21597,21 @@ class McpServer {
     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.
    *
@@ -20233,6 +21651,7 @@ class McpServer {
             }) : EMPTY_OBJECT_JSON_SCHEMA;
           })(),
           annotations: tool.annotations,
+          execution: tool.execution,
           _meta: tool._meta
         };
         if (tool.outputSchema) {
@@ -20248,39 +21667,33 @@ class McpServer {
       })
     }));
     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(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
         }
         if (!tool.enabled) {
           throw new McpError(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(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(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(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(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`);
-          }
+        if (taskSupport === "required" && !isTaskRequest) {
+          throw new McpError(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 === ErrorCode.UrlElicitationRequired) {
@@ -20289,7 +21702,6 @@ class McpServer {
         }
         return this.createToolError(error instanceof Error ? error.message : String(error));
       }
-      return result;
     });
     this._toolHandlersInitialized = true;
   }
@@ -20310,6 +21722,101 @@ class McpServer {
       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(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(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(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(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
+      }
+      task = updatedTask;
+    }
+    return await extra.taskStore.getTaskResult(taskId);
+  }
   setCompletionRequestHandler() {
     if (this._completionHandlerInitialized) {
       return;
@@ -20344,7 +21851,7 @@ class McpServer {
       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;
     }
@@ -20429,7 +21936,6 @@ class McpServer {
       }
       throw new McpError(ErrorCode.InvalidParams, `Resource ${uri2} not found`);
     });
-    this.setCompletionRequestHandler();
     this._resourceHandlersInitialized = true;
   }
   setPromptRequestHandlers() {
@@ -20465,7 +21971,9 @@ class McpServer {
         const argsObj = normalizeObjectSchema(prompt.argsSchema);
         const parseResult = await safeParseAsync(argsObj, request.params.arguments);
         if (!parseResult.success) {
-          throw new McpError(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(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
         }
         const args = parseResult.data;
         const cb = prompt.callback;
@@ -20475,7 +21983,6 @@ class McpServer {
         return await Promise.resolve(cb(extra));
       }
     });
-    this.setCompletionRequestHandler();
     this._promptHandlersInitialized = true;
   }
   resource(name, uriOrTemplate, ...rest) {
@@ -20583,6 +22090,11 @@ class McpServer {
       }
     };
     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) {
@@ -20615,9 +22127,18 @@ class McpServer {
       }
     };
     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,
@@ -20625,8 +22146,9 @@ class McpServer {
       inputSchema: getZodSchemaObject(inputSchema),
       outputSchema: getZodSchemaObject(outputSchema),
       annotations,
+      execution,
       _meta,
-      callback,
+      handler,
       enabled: true,
       disable: () => registeredTool.update({ enabled: false }),
       enable: () => registeredTool.update({ enabled: true }),
@@ -20646,8 +22168,10 @@ class McpServer {
           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")
@@ -20678,9 +22202,9 @@ class McpServer {
     }
     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) {
@@ -20688,7 +22212,7 @@ class McpServer {
       }
     }
     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.
@@ -20698,7 +22222,7 @@ class McpServer {
       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]) {
@@ -20794,28 +22318,36 @@ class ResourceTemplate {
    * 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;
@@ -20836,7 +22368,7 @@ function promptArgumentsFromSchema(schema) {
 }
 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");
   }
@@ -20862,7 +22394,8 @@ const EMPTY_COMPLETION_RESULT = {
   }
 };
 export {
-  ajv as Ajv,
+  Ajv,
+  AnnotationsSchema,
   AudioContentSchema,
   BaseMetadataSchema,
   BlobResourceContentsSchema,
@@ -20871,6 +22404,8 @@ export {
   CallToolRequestParamsSchema,
   CallToolRequestSchema,
   CallToolResultSchema,
+  CancelTaskRequestSchema,
+  CancelTaskResultSchema,
   CancelledNotificationParamsSchema,
   CancelledNotificationSchema,
   Client,
@@ -20878,6 +22413,7 @@ export {
   ClientNotificationSchema,
   ClientRequestSchema,
   ClientResultSchema,
+  ClientTasksCapabilitySchema,
   CompatibilityCallToolResultSchema,
   CompleteRequestParamsSchema,
   CompleteRequestSchema,
@@ -20886,6 +22422,8 @@ export {
   CreateMessageRequestParamsSchema,
   CreateMessageRequestSchema,
   CreateMessageResultSchema,
+  CreateMessageResultWithToolsSchema,
+  CreateTaskResultSchema,
   CursorSchema,
   DEFAULT_NEGOTIATED_PROTOCOL_VERSION,
   DEFAULT_REQUEST_TIMEOUT_MSEC,
@@ -20903,6 +22441,10 @@ export {
   GetPromptRequestParamsSchema,
   GetPromptRequestSchema,
   GetPromptResultSchema,
+  GetTaskPayloadRequestSchema,
+  GetTaskPayloadResultSchema,
+  GetTaskRequestSchema,
+  GetTaskResultSchema,
   IconSchema,
   IconsSchema,
   ImageContentSchema,
@@ -20911,14 +22453,17 @@ export {
   InitializeRequestSchema,
   InitializeResultSchema,
   InitializedNotificationSchema,
+  JSONRPCErrorResponseSchema,
   JSONRPCErrorSchema,
   JSONRPCMessageSchema,
   JSONRPCNotificationSchema,
   JSONRPCRequestSchema,
   JSONRPCResponseSchema,
+  JSONRPCResultResponseSchema,
   JSONRPC_VERSION,
   LATEST_PROTOCOL_VERSION,
   LegacyTitledEnumSchemaSchema,
+  ListChangedOptionsBaseSchema,
   ListPromptsRequestSchema,
   ListPromptsResultSchema,
   ListResourceTemplatesRequestSchema,
@@ -20927,6 +22472,8 @@ export {
   ListResourcesResultSchema,
   ListRootsRequestSchema,
   ListRootsResultSchema,
+  ListTasksRequestSchema,
+  ListTasksResultSchema,
   ListToolsRequestSchema,
   ListToolsResultSchema,
   LoggingLevelSchema,
@@ -20955,9 +22502,11 @@ export {
   PromptReferenceSchema,
   PromptSchema,
   Protocol,
+  RELATED_TASK_META_KEY,
   ReadResourceRequestParamsSchema,
   ReadResourceRequestSchema,
   ReadResourceResultSchema,
+  RelatedTaskMetadataSchema,
   RequestIdSchema,
   RequestSchema,
   ResourceContentsSchema,
@@ -20972,16 +22521,19 @@ export {
   ResourceUpdatedNotificationParamsSchema,
   ResourceUpdatedNotificationSchema,
   ResultSchema,
+  RoleSchema,
   RootSchema,
   RootsListChangedNotificationSchema,
   SSEClientTransport,
   SUPPORTED_PROTOCOL_VERSIONS,
+  SamplingContentSchema,
   SamplingMessageContentBlockSchema,
   SamplingMessageSchema,
   ServerCapabilitiesSchema,
   ServerNotificationSchema,
   ServerRequestSchema,
   ServerResultSchema,
+  ServerTasksCapabilitySchema,
   SetLevelRequestParamsSchema,
   SetLevelRequestSchema,
   SingleSelectEnumSchemaSchema,
@@ -20991,12 +22543,20 @@ export {
   StringSchemaSchema,
   SubscribeRequestParamsSchema,
   SubscribeRequestSchema,
+  TaskAugmentedRequestParamsSchema,
+  TaskCreationParamsSchema,
+  TaskMetadataSchema,
+  TaskSchema,
+  TaskStatusNotificationParamsSchema,
+  TaskStatusNotificationSchema,
+  TaskStatusSchema,
   TextContentSchema,
   TextResourceContentsSchema,
   TitledMultiSelectEnumSchemaSchema,
   TitledSingleSelectEnumSchemaSchema,
   ToolAnnotationsSchema,
   ToolChoiceSchema,
+  ToolExecutionSchema,
   ToolListChangedNotificationSchema,
   ToolResultContentSchema,
   ToolSchema,
@@ -21020,6 +22580,7 @@ export {
   exchangeAuthorization,
   extractResourceMetadataUrl,
   extractWWWAuthenticateParams,
+  fetchToken,
   getCompleter,
   getDisplayName,
   getSupportedElicitationModes,
@@ -21028,12 +22589,16 @@ export {
   isInitializeRequest,
   isInitializedNotification,
   isJSONRPCError,
+  isJSONRPCErrorResponse,
   isJSONRPCNotification,
   isJSONRPCRequest,
   isJSONRPCResponse,
+  isJSONRPCResultResponse,
+  isTaskAugmentedRequestParams,
   mergeCapabilities,
   normalizeHeaders,
   parseErrorResponse,
+  prepareAuthorizationCodeRequest,
   refreshAuthorization,
   registerClient,
   selectClientAuthMethod,