@opentiny/next-sdk 0.1.15-beta.3 → 0.1.15-beta.5

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

@@ -6851,9 +6851,8 @@
     return new RegExp(`^${regex}$`);
   };
   const integer = /^\d+$/;
-  const number$2 = /^-?\d+(?:\.\d+)?/i;
+  const number$1 = /^-?\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) => {
@@ -7663,7 +7662,7 @@
   });
   const $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
     $ZodType.init(inst, def);
-    inst._zod.pattern = inst._zod.bag.pattern ?? number$2;
+    inst._zod.pattern = inst._zod.bag.pattern ?? number$1;
     inst._zod.parse = (payload, _ctx) => {
       if (def.coerce)
         try {
@@ -7710,23 +7709,6 @@
       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;
@@ -8814,14 +8796,6 @@
       ...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",
@@ -8837,12 +8811,6 @@
       ...normalizeParams(params)
     });
   }
-  function _null$1(Class, params) {
-    return new Class({
-      type: "null",
-      ...normalizeParams(params)
-    });
-  }
   function _any(Class) {
     return new Class({
       type: "any"
@@ -10066,7 +10034,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     inst.isFinite = true;
     inst.format = bag.format ?? null;
   });
-  function number$1(params) {
+  function number(params) {
     return _number(ZodNumber$1, params);
   }
   const ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
@@ -10083,13 +10051,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   function boolean(params) {
     return _boolean(ZodBoolean$1, params);
   }
-  const ZodNull$1 = /* @__PURE__ */ $constructor("ZodNull", (inst, def) => {
-    $ZodNull.init(inst, def);
-    ZodType$1.init(inst, def);
-  });
-  function _null(params) {
-    return _null$1(ZodNull$1, params);
-  }
   const ZodAny$1 = /* @__PURE__ */ $constructor("ZodAny", (inst, def) => {
     $ZodAny.init(inst, def);
     ZodType$1.init(inst, def);
@@ -10458,47 +10419,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   const ZodIssueCode$1 = {
     custom: "custom"
   };
-  function number(params) {
-    return _coercedNumber(ZodNumber$1, params);
-  }
-  const LATEST_PROTOCOL_VERSION = "2025-11-25";
+  const LATEST_PROTOCOL_VERSION = "2025-06-18";
   const DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
-  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 SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-03-26", "2024-11-05", "2024-10-07"];
   const JSONRPC_VERSION = "2.0";
   const AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
-  const ProgressTokenSchema = union([string(), number$1().int()]);
+  const ProgressTokenSchema = union([string(), number().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 RelatedTaskMetadataSchema = looseObject({
-    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(),
-    /**
-     * If specified, this request is related to the provided task.
-     */
-    [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
+    progressToken: ProgressTokenSchema.optional()
   });
   const BaseRequestParamsSchema = looseObject({
-    /**
-     * If specified, the caller is requesting that the receiver create a task to represent the request.
-     * Task creation parameters are now at the top level instead of in _meta.
-     */
-    task: TaskCreationParamsSchema.optional(),
     /**
      * See [General fields: `_meta`](/specification/draft/basic/index#meta) for notes on `_meta` usage.
      */
@@ -10513,12 +10447,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: object$1({
-      /**
-       * If specified, this notification is related to the provided task.
-       */
-      [RELATED_TASK_META_KEY]: optional(RelatedTaskMetadataSchema)
-    }).passthrough().optional()
+    _meta: record(string(), unknown()).optional()
   });
   const NotificationSchema = object$1({
     method: string(),
@@ -10529,14 +10458,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
      */
-    _meta: looseObject({
-      /**
-       * If specified, this result is related to the provided task.
-       */
-      [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
-    }).optional()
+    _meta: record(string(), unknown()).optional()
   });
-  const RequestIdSchema = union([string(), number$1().int()]);
+  const RequestIdSchema = union([string(), number().int()]);
   const JSONRPCRequestSchema = object$1({
     jsonrpc: literal(JSONRPC_VERSION),
     id: RequestIdSchema,
@@ -10572,7 +10496,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       /**
        * The error type that occurred.
        */
-      code: number$1().int(),
+      code: number().int(),
       /**
        * A short description of the error. The message SHOULD be limited to a concise single sentence.
        */
@@ -10669,54 +10593,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     form: FormElicitationCapabilitySchema.optional(),
     url: AssertObjectSchema.optional()
   }), record(string(), unknown()).optional()));
-  const ClientTasksCapabilitySchema = object$1({
-    /**
-     * Present if the client supports listing tasks.
-     */
-    list: optional(object$1({}).passthrough()),
-    /**
-     * Present if the client supports cancelling tasks.
-     */
-    cancel: optional(object$1({}).passthrough()),
-    /**
-     * Capabilities for task creation on specific request types.
-     */
-    requests: optional(object$1({
-      /**
-       * Task support for sampling requests.
-       */
-      sampling: optional(object$1({
-        createMessage: optional(object$1({}).passthrough())
-      }).passthrough()),
-      /**
-       * Task support for elicitation requests.
-       */
-      elicitation: optional(object$1({
-        create: optional(object$1({}).passthrough())
-      }).passthrough())
-    }).passthrough())
-  }).passthrough();
-  const ServerTasksCapabilitySchema = object$1({
-    /**
-     * Present if the server supports listing tasks.
-     */
-    list: optional(object$1({}).passthrough()),
-    /**
-     * Present if the server supports cancelling tasks.
-     */
-    cancel: optional(object$1({}).passthrough()),
-    /**
-     * Capabilities for task creation on specific request types.
-     */
-    requests: optional(object$1({
-      /**
-       * Task support for tool requests.
-       */
-      tools: optional(object$1({
-        call: optional(object$1({}).passthrough())
-      }).passthrough())
-    }).passthrough())
-  }).passthrough();
   const ClientCapabilitiesSchema = object$1({
     /**
      * Experimental, non-standard capabilities that the client supports.
@@ -10748,11 +10624,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
        * Whether the client supports issuing notifications for changes to the roots list.
        */
       listChanged: boolean().optional()
-    }).optional(),
-    /**
-     * Present if the client supports task creation.
-     */
-    tasks: optional(ClientTasksCapabilitySchema)
+    }).optional()
   });
   const InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
     /**
@@ -10810,12 +10682,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
        * Whether this server supports issuing notifications for changes to the tool list.
        */
       listChanged: boolean().optional()
-    }).optional(),
-    /**
-     * Present if the server supports task creation.
-     */
-    tasks: optional(ServerTasksCapabilitySchema)
-  }).passthrough();
+    }).optional()
+  });
   const InitializeResultSchema = ResultSchema.extend({
     /**
      * The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect.
@@ -10841,11 +10709,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     /**
      * The progress thus far. This should increase every time progress is made, even if the total is unknown.
      */
-    progress: number$1(),
+    progress: number(),
     /**
      * Total number of items to process (or total progress required), if known.
      */
-    total: optional(number$1()),
+    total: optional(number()),
     /**
      * An optional message describing the current progress.
      */
@@ -10880,62 +10748,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      */
     nextCursor: optional(CursorSchema)
   });
-  const TaskSchema = object$1({
-    taskId: string(),
-    status: _enum(["working", "input_required", "completed", "failed", "cancelled"]),
-    /**
-     * 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 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.
@@ -10971,20 +10783,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      */
     blob: Base64Schema
   });
-  const AnnotationsSchema = object$1({
-    /**
-     * Intended audience(s) for the resource.
-     */
-    audience: array(_enum(["user", "assistant"])).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,
@@ -11002,10 +10800,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * The MIME type of this resource, if known.
      */
     mimeType: optional(string()),
-    /**
-     * Optional annotations for the client.
-     */
-    annotations: AnnotationsSchema.optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -11029,10 +10823,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type.
      */
     mimeType: optional(string()),
-    /**
-     * Optional annotations for the client.
-     */
-    annotations: AnnotationsSchema.optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -11147,10 +10937,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * The text content of the message.
      */
     text: string(),
-    /**
-     * Optional annotations for the client.
-     */
-    annotations: AnnotationsSchema.optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -11167,10 +10953,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * The MIME type of the image. Different providers may support different image types.
      */
     mimeType: string(),
-    /**
-     * Optional annotations for the client.
-     */
-    annotations: AnnotationsSchema.optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -11187,10 +10969,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * The MIME type of the audio. Different providers may support different audio types.
      */
     mimeType: string(),
-    /**
-     * Optional annotations for the client.
-     */
-    annotations: AnnotationsSchema.optional(),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -11223,10 +11001,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   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.
@@ -11296,17 +11070,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      */
     openWorldHint: boolean().optional()
   });
-  const ToolExecutionSchema = object$1({
-    /**
-     * Indicates the tool's preference for task-augmented execution.
-     * - "required": Clients MUST invoke the tool as a task
-     * - "optional": Clients MAY invoke the tool as a task or normal request
-     * - "forbidden": Clients MUST NOT attempt to invoke the tool as a task
-     *
-     * If not present, defaults to "forbidden".
-     */
-    taskSupport: _enum(["required", "optional", "forbidden"]).optional()
-  });
   const ToolSchema = object$1({
     ...BaseMetadataSchema.shape,
     ...IconsSchema.shape,
@@ -11337,10 +11100,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * Optional additional tool information.
      */
     annotations: optional(ToolAnnotationsSchema),
-    /**
-     * Execution-related properties for this tool.
-     */
-    execution: optional(ToolExecutionSchema),
     /**
      * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
      * for notes on _meta usage.
@@ -11446,15 +11205,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     /**
      * How much to prioritize cost when selecting a model.
      */
-    costPriority: optional(number$1().min(0).max(1)),
+    costPriority: optional(number().min(0).max(1)),
     /**
      * How much to prioritize sampling speed (latency) when selecting a model.
      */
-    speedPriority: optional(number$1().min(0).max(1)),
+    speedPriority: optional(number().min(0).max(1)),
     /**
      * How much to prioritize intelligence and capabilities when selecting a model.
      */
-    intelligencePriority: optional(number$1().min(0).max(1))
+    intelligencePriority: optional(number().min(0).max(1))
   });
   const ToolChoiceSchema = object$1({
     /**
@@ -11477,7 +11236,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      */
     _meta: optional(object$1({}).passthrough())
   }).passthrough();
-  const SamplingContentSchema = discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]);
   const SamplingMessageContentBlockSchema = discriminatedUnion("type", [
     TextContentSchema,
     ImageContentSchema,
@@ -11512,13 +11270,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * declares ClientCapabilities.sampling.context. These values may be removed in future spec releases.
      */
     includeContext: _enum(["none", "thisServer", "allServers"]).optional(),
-    temperature: number$1().optional(),
+    temperature: number().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$1().int(),
+    maxTokens: number().int(),
     stopSequences: array(string()).optional(),
     /**
      * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.
@@ -11541,28 +11299,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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: _enum(["user", "assistant"]),
-    /**
-     * Response content. Single content block (text, image, or audio).
-     */
-    content: SamplingContentSchema
-  });
-  const CreateMessageResultWithToolsSchema = ResultSchema.extend({
     /**
      * The name of the model that generated the message.
      */
@@ -11581,7 +11317,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(string())),
     role: _enum(["user", "assistant"]),
     /**
-     * Response content. May be a single block or array. May include ToolUseContent if stopReason is "toolUse".
+     * Response content. May be ToolUseContent if stopReason is "toolUse".
      */
     content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)])
   });
@@ -11595,8 +11331,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     type: literal("string"),
     title: string().optional(),
     description: string().optional(),
-    minLength: number$1().optional(),
-    maxLength: number$1().optional(),
+    minLength: number().optional(),
+    maxLength: number().optional(),
     format: _enum(["email", "uri", "date", "date-time"]).optional(),
     default: string().optional()
   });
@@ -11604,9 +11340,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     type: _enum(["number", "integer"]),
     title: string().optional(),
     description: string().optional(),
-    minimum: number$1().optional(),
-    maximum: number$1().optional(),
-    default: number$1().optional()
+    minimum: number().optional(),
+    maximum: number().optional(),
+    default: number().optional()
   });
   const UntitledSingleSelectEnumSchemaSchema = object$1({
     type: literal("string"),
@@ -11638,8 +11374,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     type: literal("array"),
     title: string().optional(),
     description: string().optional(),
-    minItems: number$1().optional(),
-    maxItems: number$1().optional(),
+    minItems: number().optional(),
+    maxItems: number().optional(),
     items: object$1({
       type: literal("string"),
       enum: array(string())
@@ -11650,8 +11386,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     type: literal("array"),
     title: string().optional(),
     description: string().optional(),
-    minItems: number$1().optional(),
-    maxItems: number$1().optional(),
+    minItems: number().optional(),
+    maxItems: number().optional(),
     items: object$1({
       anyOf: array(object$1({
         const: string(),
@@ -11729,10 +11465,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     /**
      * The submitted form data, only present when action is "accept".
      * Contains values matching the requested schema.
-     * Per MCP spec, content is "typically omitted" for decline/cancel actions.
-     * We normalize null to undefined for leniency while maintaining type compatibility.
      */
-    content: preprocess((val) => val === null ? void 0 : val, record(string(), union([string(), number$1(), boolean(), array(string())])).optional())
+    content: record(string(), union([string(), number(), boolean(), array(string())])).optional()
   });
   const ResourceTemplateReferenceSchema = object$1({
     type: literal("ref/resource"),
@@ -11794,7 +11528,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       /**
        * The total number of completion options available. This can exceed the number of values actually sent in the response.
        */
-      total: optional(number$1().int()),
+      total: optional(number().int()),
       /**
        * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
        */
@@ -11838,37 +11572,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     SubscribeRequestSchema,
     UnsubscribeRequestSchema,
     CallToolRequestSchema,
-    ListToolsRequestSchema,
-    GetTaskRequestSchema,
-    GetTaskPayloadRequestSchema,
-    ListTasksRequestSchema
+    ListToolsRequestSchema
   ]);
   const ClientNotificationSchema = union([
     CancelledNotificationSchema,
     ProgressNotificationSchema,
     InitializedNotificationSchema,
-    RootsListChangedNotificationSchema,
-    TaskStatusNotificationSchema
-  ]);
-  const ClientResultSchema = union([
-    EmptyResultSchema,
-    CreateMessageResultSchema,
-    CreateMessageResultWithToolsSchema,
-    ElicitResultSchema,
-    ListRootsResultSchema,
-    GetTaskResultSchema,
-    ListTasksResultSchema,
-    CreateTaskResultSchema
-  ]);
-  const ServerRequestSchema = union([
-    PingRequestSchema,
-    CreateMessageRequestSchema,
-    ElicitRequestSchema,
-    ListRootsRequestSchema,
-    GetTaskRequestSchema,
-    GetTaskPayloadRequestSchema,
-    ListTasksRequestSchema
+    RootsListChangedNotificationSchema
   ]);
+  const ClientResultSchema = union([EmptyResultSchema, CreateMessageResultSchema, ElicitResultSchema, ListRootsResultSchema]);
+  const ServerRequestSchema = union([PingRequestSchema, CreateMessageRequestSchema, ElicitRequestSchema, ListRootsRequestSchema]);
   const ServerNotificationSchema = union([
     CancelledNotificationSchema,
     ProgressNotificationSchema,
@@ -11877,7 +11590,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     ResourceListChangedNotificationSchema,
     ToolListChangedNotificationSchema,
     PromptListChangedNotificationSchema,
-    TaskStatusNotificationSchema,
     ElicitationCompleteNotificationSchema
   ]);
   const ServerResultSchema = union([
@@ -11890,10 +11602,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     ListResourceTemplatesResultSchema,
     ReadResourceResultSchema,
     CallToolResultSchema,
-    ListToolsResultSchema,
-    GetTaskResultSchema,
-    ListTasksResultSchema,
-    CreateTaskResultSchema
+    ListToolsResultSchema
   ]);
   class McpError extends Error {
     constructor(code2, message, data) {
@@ -12175,7 +11884,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     if (metadata2.title !== void 0 && metadata2.title !== "") {
       return metadata2.title;
     }
-    if ("annotations" in metadata2 && ((_a = metadata2.annotations) === null || _a === void 0 ? void 0 : _a.title)) {
+    if ((_a = metadata2.annotations) === null || _a === void 0 ? void 0 : _a.title) {
       return metadata2.annotations.title;
     }
     return metadata2.name;
@@ -15867,7 +15576,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     if (isZ4Schema(schema)) {
       const v4Schema = schema;
       const def = (_a = v4Schema._zod) === null || _a === void 0 ? void 0 : _a.def;
-      if (def && (def.type === "object" || def.shape !== void 0)) {
+      if (def && (def.typeName === "object" || def.shape !== void 0)) {
         return schema;
       }
     } else {
@@ -15910,7 +15619,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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.type) === "optional";
+      return ((_b = (_a = v4Schema._zod) === null || _a === void 0 ? void 0 : _a.def) === null || _b === void 0 ? void 0 : _b.typeName) === "ZodOptional";
     }
     const v3Schema = schema;
     if (typeof schema.isOptional === "function") {
@@ -15945,9 +15654,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       return directValue;
     return void 0;
   }
-  function isTerminal(status) {
-    return status === "completed" || status === "failed" || status === "cancelled";
-  }
   const ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
   const defaultOptions = {
     name: void 0,
@@ -17204,10 +16910,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this._progressHandlers = /* @__PURE__ */ new Map();
       this._timeoutInfo = /* @__PURE__ */ new Map();
       this._pendingDebouncedNotifications = /* @__PURE__ */ new Set();
-      this._taskProgressTokens = /* @__PURE__ */ new Map();
-      this._requestResolvers = /* @__PURE__ */ new Map();
       this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
-        this._oncancel(notification);
+        const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
+        controller === null || controller === void 0 ? void 0 : controller.abort(notification.params.reason);
       });
       this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
         this._onprogress(notification);
@@ -17217,116 +16922,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         // Automatic pong by default.
         (_request) => ({})
       );
-      this._taskStore = _options === null || _options === void 0 ? void 0 : _options.taskStore;
-      this._taskMessageQueue = _options === null || _options === void 0 ? void 0 : _options.taskMessageQueue;
-      if (this._taskStore) {
-        this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
-          const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
-          if (!task) {
-            throw new McpError(exports2.ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
-          }
-          return {
-            ...task
-          };
-        });
-        this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
-          const handleTaskResult = async () => {
-            var _a;
-            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 ((_a = this._transport) === null || _a === void 0 ? void 0 : _a.send(queuedMessage.message, { relatedRequestId: extra.requestId }));
-              }
-            }
-            const task = await this._taskStore.getTask(taskId, extra.sessionId);
-            if (!task) {
-              throw new McpError(exports2.ErrorCode.InvalidParams, `Task not found: ${taskId}`);
-            }
-            if (!isTerminal(task.status)) {
-              await this._waitForTaskUpdate(taskId, extra.signal);
-              return await handleTaskResult();
-            }
-            if (isTerminal(task.status)) {
-              const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
-              this._clearTaskQueue(taskId);
-              return {
-                ...result,
-                _meta: {
-                  ...result._meta,
-                  [RELATED_TASK_META_KEY]: {
-                    taskId
-                  }
-                }
-              };
-            }
-            return await handleTaskResult();
-          };
-          return await handleTaskResult();
-        });
-        this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
-          var _a;
-          try {
-            const { tasks, nextCursor } = await this._taskStore.listTasks((_a = request.params) === null || _a === void 0 ? void 0 : _a.cursor, extra.sessionId);
-            return {
-              tasks,
-              nextCursor,
-              _meta: {}
-            };
-          } catch (error) {
-            throw new McpError(exports2.ErrorCode.InvalidParams, `Failed to list tasks: ${error instanceof Error ? error.message : String(error)}`);
-          }
-        });
-        this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => {
-          try {
-            const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
-            if (!task) {
-              throw new McpError(exports2.ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
-            }
-            if (isTerminal(task.status)) {
-              throw new McpError(exports2.ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
-            }
-            await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
-            this._clearTaskQueue(request.params.taskId);
-            const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
-            if (!cancelledTask) {
-              throw new McpError(exports2.ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
-            }
-            return {
-              _meta: {},
-              ...cancelledTask
-            };
-          } catch (error) {
-            if (error instanceof McpError) {
-              throw error;
-            }
-            throw new McpError(exports2.ErrorCode.InvalidRequest, `Failed to cancel task: ${error instanceof Error ? error.message : String(error)}`);
-          }
-        });
-      }
-    }
-    async _oncancel(notification) {
-      const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
-      controller === null || controller === void 0 ? void 0 : controller.abort(notification.params.reason);
     }
     _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
       this._timeoutInfo.set(messageId, {
@@ -17399,11 +16994,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const responseHandlers = this._responseHandlers;
       this._responseHandlers = /* @__PURE__ */ new Map();
       this._progressHandlers.clear();
-      this._taskProgressTokens.clear();
       this._pendingDebouncedNotifications.clear();
-      const error = McpError.fromError(exports2.ErrorCode.ConnectionClosed, "Connection closed");
       this._transport = void 0;
       (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
+      const error = McpError.fromError(exports2.ErrorCode.ConnectionClosed, "Connection closed");
       for (const handler of responseHandlers.values()) {
         handler(error);
       }
@@ -17421,94 +17015,47 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       Promise.resolve().then(() => handler(notification)).catch((error) => this._onerror(new Error(`Uncaught error in notification handler: ${error}`)));
     }
     _onrequest(request, extra) {
-      var _a, _b, _c, _d, _e, _f;
+      var _a, _b;
       const handler = (_a = this._requestHandlers.get(request.method)) !== null && _a !== void 0 ? _a : this.fallbackRequestHandler;
       const capturedTransport = this._transport;
-      const relatedTaskId = (_d = (_c = (_b = request.params) === null || _b === void 0 ? void 0 : _b._meta) === null || _c === void 0 ? void 0 : _c[RELATED_TASK_META_KEY]) === null || _d === void 0 ? void 0 : _d.taskId;
       if (handler === void 0) {
-        const errorResponse = {
+        capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
           jsonrpc: "2.0",
           id: request.id,
           error: {
             code: exports2.ErrorCode.MethodNotFound,
             message: "Method not found"
           }
-        };
-        if (relatedTaskId && this._taskMessageQueue) {
-          this._enqueueTaskMessage(relatedTaskId, {
-            type: "error",
-            message: errorResponse,
-            timestamp: Date.now()
-          }, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId).catch((error) => this._onerror(new Error(`Failed to enqueue error response: ${error}`)));
-        } else {
-          capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send(errorResponse).catch((error) => this._onerror(new Error(`Failed to send an error response: ${error}`)));
-        }
+        }).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 = (_e = request.params) === null || _e === void 0 ? void 0 : _e.task;
-      const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId) : void 0;
       const fullExtra = {
         signal: abortController.signal,
         sessionId: capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId,
-        _meta: (_f = request.params) === null || _f === void 0 ? void 0 : _f._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) => {
-          var _a2, _b2;
-          const requestOptions = { ...options, relatedRequestId: request.id };
-          if (relatedTaskId && !requestOptions.relatedTask) {
-            requestOptions.relatedTask = { taskId: relatedTaskId };
-          }
-          const effectiveTaskId = (_b2 = (_a2 = requestOptions.relatedTask) === null || _a2 === void 0 ? void 0 : _a2.taskId) !== null && _b2 !== void 0 ? _b2 : relatedTaskId;
-          if (effectiveTaskId && taskStore) {
-            await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
-          }
-          return await this.request(r, resultSchema, requestOptions);
-        },
+        _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,
         requestId: request.id,
-        requestInfo: extra === null || extra === void 0 ? void 0 : extra.requestInfo,
-        taskId: relatedTaskId,
-        taskStore,
-        taskRequestedTtl: taskCreationParams === null || taskCreationParams === void 0 ? void 0 : taskCreationParams.ttl,
-        closeSSEStream: extra === null || extra === void 0 ? void 0 : extra.closeSSEStream,
-        closeStandaloneSSEStream: extra === null || extra === void 0 ? void 0 : extra.closeStandaloneSSEStream
+        requestInfo: extra === null || extra === void 0 ? void 0 : extra.requestInfo
       };
-      Promise.resolve().then(() => {
-        if (taskCreationParams) {
-          this.assertTaskHandlerCapability(request.method);
-        }
-      }).then(() => handler(request, fullExtra)).then(async (result) => {
+      Promise.resolve().then(() => handler(request, fullExtra)).then((result) => {
         if (abortController.signal.aborted) {
           return;
         }
-        const response = {
+        return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
           result,
           jsonrpc: "2.0",
           id: request.id
-        };
-        if (relatedTaskId && this._taskMessageQueue) {
-          await this._enqueueTaskMessage(relatedTaskId, {
-            type: "response",
-            message: response,
-            timestamp: Date.now()
-          }, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId);
-        } else {
-          await (capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send(response));
-        }
-      }, async (error) => {
+        });
+      }, (error) => {
         var _a2;
         if (abortController.signal.aborted) {
           return;
         }
-        const errorResponse = {
+        return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
           jsonrpc: "2.0",
           id: request.id,
           error: {
@@ -17516,16 +17063,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             message: (_a2 = error.message) !== null && _a2 !== void 0 ? _a2 : "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 === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId);
-        } else {
-          await (capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send(errorResponse));
-        }
+        });
       }).catch((error) => this._onerror(new Error(`Failed to send response: ${error}`))).finally(() => {
         this._requestHandlerAbortControllers.delete(request.id);
       });
@@ -17544,9 +17082,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         try {
           this._resetTimeout(messageId);
         } catch (error) {
-          this._responseHandlers.delete(messageId);
-          this._progressHandlers.delete(messageId);
-          this._cleanupTimeout(messageId);
           responseHandler(error);
           return;
         }
@@ -17555,38 +17090,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     _onresponse(response) {
       const messageId = Number(response.id);
-      const resolver = this._requestResolvers.get(messageId);
-      if (resolver) {
-        this._requestResolvers.delete(messageId);
-        if (isJSONRPCResponse(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);
-      let isTaskResponse = false;
-      if (isJSONRPCResponse(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 (isJSONRPCResponse(response)) {
         handler(response);
       } else {
@@ -17605,118 +17116,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       await ((_a = this._transport) === null || _a === void 0 ? void 0 : _a.close());
     }
     /**
-     * Sends a request and returns an AsyncGenerator that yields response messages.
-     * The generator is guaranteed to end with either a 'result' or 'error' message.
-     *
-     * @example
-     * ```typescript
-     * const stream = protocol.requestStream(request, resultSchema, options);
-     * for await (const message of stream) {
-     *   switch (message.type) {
-     *     case 'taskCreated':
-     *       console.log('Task created:', message.task.taskId);
-     *       break;
-     *     case 'taskStatus':
-     *       console.log('Task status:', message.task.status);
-     *       break;
-     *     case 'result':
-     *       console.log('Final result:', message.result);
-     *       break;
-     *     case 'error':
-     *       console.error('Error:', message.error);
-     *       break;
-     *   }
-     * }
-     * ```
-     *
-     * @experimental Use `client.experimental.tasks.requestStream()` to access this method.
-     */
-    async *requestStream(request, resultSchema, options) {
-      var _a, _b, _c, _d;
-      const { task } = options !== null && options !== void 0 ? options : {};
-      if (!task) {
-        try {
-          const result = await this.request(request, resultSchema, options);
-          yield { type: "result", result };
-        } catch (error) {
-          yield {
-            type: "error",
-            error: error instanceof McpError ? error : new McpError(exports2.ErrorCode.InternalError, String(error))
-          };
-        }
-        return;
-      }
-      let taskId;
-      try {
-        const createResult = await this.request(request, CreateTaskResultSchema, options);
-        if (createResult.task) {
-          taskId = createResult.task.taskId;
-          yield { type: "taskCreated", task: createResult.task };
-        } else {
-          throw new McpError(exports2.ErrorCode.InternalError, "Task creation did not return a task");
-        }
-        while (true) {
-          const task2 = await this.getTask({ taskId }, options);
-          yield { type: "taskStatus", task: task2 };
-          if (isTerminal(task2.status)) {
-            if (task2.status === "completed") {
-              const result = await this.getTaskResult({ taskId }, resultSchema, options);
-              yield { type: "result", result };
-            } else if (task2.status === "failed") {
-              yield {
-                type: "error",
-                error: new McpError(exports2.ErrorCode.InternalError, `Task ${taskId} failed`)
-              };
-            } else if (task2.status === "cancelled") {
-              yield {
-                type: "error",
-                error: new McpError(exports2.ErrorCode.InternalError, `Task ${taskId} was cancelled`)
-              };
-            }
-            return;
-          }
-          if (task2.status === "input_required") {
-            const result = await this.getTaskResult({ taskId }, resultSchema, options);
-            yield { type: "result", result };
-            return;
-          }
-          const pollInterval = (_c = (_a = task2.pollInterval) !== null && _a !== void 0 ? _a : (_b = this._options) === null || _b === void 0 ? void 0 : _b.defaultTaskPollInterval) !== null && _c !== void 0 ? _c : 1e3;
-          await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
-          (_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.throwIfAborted();
-        }
-      } catch (error) {
-        yield {
-          type: "error",
-          error: error instanceof McpError ? error : new McpError(exports2.ErrorCode.InternalError, String(error))
-        };
-      }
-    }
-    /**
-     * Sends a request and waits for a response.
+     * Sends a request and wait for a response.
      *
      * Do not use this method to emit notifications! Use notification() instead.
      */
     request(request, resultSchema, options) {
-      const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options !== null && options !== void 0 ? options : {};
+      const { relatedRequestId, resumptionToken, onresumptiontoken } = options !== null && options !== void 0 ? options : {};
       return new Promise((resolve2, reject) => {
-        var _a, _b, _c, _d, _e, _f, _g;
-        const earlyReject = (error) => {
-          reject(error);
-        };
+        var _a, _b, _c, _d, _e, _f;
         if (!this._transport) {
-          earlyReject(new Error("Not connected"));
+          reject(new Error("Not connected"));
           return;
         }
         if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.enforceStrictCapabilities) === true) {
-          try {
-            this.assertCapabilityForMethod(request.method);
-            if (task) {
-              this.assertTaskCapability(request.method);
-            }
-          } catch (e) {
-            earlyReject(e);
-            return;
-          }
+          this.assertCapabilityForMethod(request.method);
         }
         (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
         const messageId = this._requestMessageId++;
@@ -17735,21 +17148,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             }
           };
         }
-        if (task) {
-          jsonrpcRequest.params = {
-            ...jsonrpcRequest.params,
-            task
-          };
-        }
-        if (relatedTask) {
-          jsonrpcRequest.params = {
-            ...jsonrpcRequest.params,
-            _meta: {
-              ...((_d = jsonrpcRequest.params) === null || _d === void 0 ? void 0 : _d._meta) || {},
-              [RELATED_TASK_META_KEY]: relatedTask
-            }
-          };
-        }
         const cancel = (reason) => {
           var _a2;
           this._responseHandlers.delete(messageId);
@@ -17762,9 +17160,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
               requestId: messageId,
               reason: String(reason)
             }
-          }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error2) => this._onerror(new Error(`Failed to send cancellation: ${error2}`)));
-          const error = reason instanceof McpError ? reason : new McpError(exports2.ErrorCode.RequestTimeout, String(reason));
-          reject(error);
+          }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => this._onerror(new Error(`Failed to send cancellation: ${error}`)));
+          reject(reason);
         };
         this._responseHandlers.set(messageId, (response) => {
           var _a2;
@@ -17785,150 +17182,53 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             reject(error);
           }
         });
-        (_e = options === null || options === void 0 ? void 0 : options.signal) === null || _e === void 0 ? void 0 : _e.addEventListener("abort", () => {
+        (_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);
         });
-        const timeout = (_f = options === null || options === void 0 ? void 0 : options.timeout) !== null && _f !== void 0 ? _f : DEFAULT_REQUEST_TIMEOUT_MSEC;
+        const timeout = (_e = options === null || options === void 0 ? void 0 : options.timeout) !== null && _e !== void 0 ? _e : DEFAULT_REQUEST_TIMEOUT_MSEC;
         const timeoutHandler = () => cancel(McpError.fromError(exports2.ErrorCode.RequestTimeout, "Request timed out", { timeout }));
-        this._setupTimeout(messageId, timeout, options === null || options === void 0 ? void 0 : options.maxTotalTimeout, timeoutHandler, (_g = options === null || options === void 0 ? void 0 : options.resetTimeoutOnProgress) !== null && _g !== void 0 ? _g : false);
-        const relatedTaskId = relatedTask === null || relatedTask === void 0 ? void 0 : 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);
-          });
-        }
+        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);
+        });
       });
     }
-    /**
-     * 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, _c, _d, _e;
+      var _a, _b;
       if (!this._transport) {
         throw new Error("Not connected");
       }
       this.assertNotificationCapability(notification.method);
-      const relatedTaskId = (_a = options === null || options === void 0 ? void 0 : options.relatedTask) === null || _a === void 0 ? void 0 : _a.taskId;
-      if (relatedTaskId) {
-        const jsonrpcNotification2 = {
-          ...notification,
-          jsonrpc: "2.0",
-          params: {
-            ...notification.params,
-            _meta: {
-              ...((_b = notification.params) === null || _b === void 0 ? void 0 : _b._meta) || {},
-              [RELATED_TASK_META_KEY]: options.relatedTask
-            }
-          }
-        };
-        await this._enqueueTaskMessage(relatedTaskId, {
-          type: "notification",
-          message: jsonrpcNotification2,
-          timestamp: Date.now()
-        });
-        return;
-      }
-      const debouncedMethods = (_d = (_c = this._options) === null || _c === void 0 ? void 0 : _c.debouncedNotificationMethods) !== null && _d !== void 0 ? _d : [];
-      const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !(options === null || options === void 0 ? void 0 : options.relatedRequestId) && !(options === null || options === void 0 ? void 0 : options.relatedTask);
+      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);
       if (canDebounce) {
         if (this._pendingDebouncedNotifications.has(notification.method)) {
           return;
         }
         this._pendingDebouncedNotifications.add(notification.method);
         Promise.resolve().then(() => {
-          var _a2, _b2;
+          var _a2;
           this._pendingDebouncedNotifications.delete(notification.method);
           if (!this._transport) {
             return;
           }
-          let jsonrpcNotification2 = {
+          const jsonrpcNotification2 = {
             ...notification,
             jsonrpc: "2.0"
           };
-          if (options === null || options === void 0 ? void 0 : options.relatedTask) {
-            jsonrpcNotification2 = {
-              ...jsonrpcNotification2,
-              params: {
-                ...jsonrpcNotification2.params,
-                _meta: {
-                  ...((_a2 = jsonrpcNotification2.params) === null || _a2 === void 0 ? void 0 : _a2._meta) || {},
-                  [RELATED_TASK_META_KEY]: options.relatedTask
-                }
-              }
-            };
-          }
-          (_b2 = this._transport) === null || _b2 === void 0 ? void 0 : _b2.send(jsonrpcNotification2, options).catch((error) => this._onerror(error));
+          (_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.send(jsonrpcNotification2, options).catch((error) => this._onerror(error));
         });
         return;
       }
-      let jsonrpcNotification = {
+      const jsonrpcNotification = {
         ...notification,
         jsonrpc: "2.0"
       };
-      if (options === null || options === void 0 ? void 0 : options.relatedTask) {
-        jsonrpcNotification = {
-          ...jsonrpcNotification,
-          params: {
-            ...jsonrpcNotification.params,
-            _meta: {
-              ...((_e = jsonrpcNotification.params) === null || _e === void 0 ? void 0 : _e._meta) || {},
-              [RELATED_TASK_META_KEY]: options.relatedTask
-            }
-          }
-        };
-      }
       await this._transport.send(jsonrpcNotification, options);
     }
     /**
@@ -17976,152 +17276,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     removeNotificationHandler(method) {
       this._notificationHandlers.delete(method);
     }
-    /**
-     * Cleans up the progress handler associated with a task.
-     * This should be called when a task reaches a terminal status.
-     */
-    _cleanupTaskProgressHandler(taskId) {
-      const progressToken = this._taskProgressTokens.get(taskId);
-      if (progressToken !== void 0) {
-        this._progressHandlers.delete(progressToken);
-        this._taskProgressTokens.delete(taskId);
-      }
-    }
-    /**
-     * Enqueues a task-related message for side-channel delivery via tasks/result.
-     * @param taskId The task ID to associate the message with
-     * @param message The message to enqueue
-     * @param sessionId Optional session ID for binding the operation to a specific session
-     * @throws Error if taskStore is not configured or if enqueue fails (e.g., queue overflow)
-     *
-     * Note: If enqueue fails, it's the TaskMessageQueue implementation's responsibility to handle
-     * the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer
-     * simply propagates the error.
-     */
-    async _enqueueTaskMessage(taskId, message, sessionId) {
-      var _a;
-      if (!this._taskStore || !this._taskMessageQueue) {
-        throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
-      }
-      const maxQueueSize = (_a = this._options) === null || _a === void 0 ? void 0 : _a.maxTaskQueueSize;
-      await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
-    }
-    /**
-     * Clears the message queue for a task and rejects any pending request resolvers.
-     * @param taskId The task ID whose queue should be cleared
-     * @param sessionId Optional session ID for binding the operation to a specific session
-     */
-    async _clearTaskQueue(taskId, sessionId) {
-      if (this._taskMessageQueue) {
-        const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
-        for (const message of messages) {
-          if (message.type === "request" && isJSONRPCRequest(message.message)) {
-            const requestId = message.message.id;
-            const resolver = this._requestResolvers.get(requestId);
-            if (resolver) {
-              resolver(new McpError(exports2.ErrorCode.InternalError, "Task cancelled or completed"));
-              this._requestResolvers.delete(requestId);
-            } else {
-              this._onerror(new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
-            }
-          }
-        }
-      }
-    }
-    /**
-     * Waits for a task update (new messages or status change) with abort signal support.
-     * Uses polling to check for updates at the task's configured poll interval.
-     * @param taskId The task ID to wait for
-     * @param signal Abort signal to cancel the wait
-     * @returns Promise that resolves when an update occurs or rejects if aborted
-     */
-    async _waitForTaskUpdate(taskId, signal) {
-      var _a, _b, _c;
-      let interval = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.defaultTaskPollInterval) !== null && _b !== void 0 ? _b : 1e3;
-      try {
-        const task = await ((_c = this._taskStore) === null || _c === void 0 ? void 0 : _c.getTask(taskId));
-        if (task === null || task === void 0 ? void 0 : task.pollInterval) {
-          interval = task.pollInterval;
-        }
-      } catch (_d) {
-      }
-      return new Promise((resolve2, reject) => {
-        if (signal.aborted) {
-          reject(new McpError(exports2.ErrorCode.InvalidRequest, "Request cancelled"));
-          return;
-        }
-        const timeoutId = setTimeout(resolve2, interval);
-        signal.addEventListener("abort", () => {
-          clearTimeout(timeoutId);
-          reject(new McpError(exports2.ErrorCode.InvalidRequest, "Request cancelled"));
-        }, { once: true });
-      });
-    }
-    requestTaskStore(request, sessionId) {
-      const taskStore = this._taskStore;
-      if (!taskStore) {
-        throw new Error("No task store configured");
-      }
-      return {
-        createTask: async (taskParams) => {
-          if (!request) {
-            throw new Error("No request provided");
-          }
-          return await taskStore.createTask(taskParams, request.id, {
-            method: request.method,
-            params: request.params
-          }, sessionId);
-        },
-        getTask: async (taskId) => {
-          const task = await taskStore.getTask(taskId, sessionId);
-          if (!task) {
-            throw new McpError(exports2.ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
-          }
-          return task;
-        },
-        storeTaskResult: async (taskId, status, result) => {
-          await taskStore.storeTaskResult(taskId, status, result, sessionId);
-          const task = await taskStore.getTask(taskId, sessionId);
-          if (task) {
-            const notification = TaskStatusNotificationSchema.parse({
-              method: "notifications/tasks/status",
-              params: task
-            });
-            await this.notification(notification);
-            if (isTerminal(task.status)) {
-              this._cleanupTaskProgressHandler(taskId);
-            }
-          }
-        },
-        getTaskResult: (taskId) => {
-          return taskStore.getTaskResult(taskId, sessionId);
-        },
-        updateTaskStatus: async (taskId, status, statusMessage) => {
-          const task = await taskStore.getTask(taskId, sessionId);
-          if (!task) {
-            throw new McpError(exports2.ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
-          }
-          if (isTerminal(task.status)) {
-            throw new McpError(exports2.ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
-          }
-          await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
-          const updatedTask = await taskStore.getTask(taskId, sessionId);
-          if (updatedTask) {
-            const notification = TaskStatusNotificationSchema.parse({
-              method: "notifications/tasks/status",
-              params: updatedTask
-            });
-            await this.notification(notification);
-            if (isTerminal(updatedTask.status)) {
-              this._cleanupTaskProgressHandler(taskId);
-            }
-          }
-        },
-        listTasks: (cursor) => {
-          return taskStore.listTasks(cursor, sessionId);
-        }
-      };
-    }
   }
   function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -18532,190 +17686,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       };
     }
   }
-  class ExperimentalClientTasks {
-    constructor(_client) {
-      this._client = _client;
-    }
-    /**
-     * Calls a tool and returns an AsyncGenerator that yields response messages.
-     * The generator is guaranteed to end with either a 'result' or 'error' message.
-     *
-     * This method provides streaming access to tool execution, allowing you to
-     * observe intermediate task status updates for long-running tool calls.
-     * Automatically validates structured output if the tool has an outputSchema.
-     *
-     * @example
-     * ```typescript
-     * const stream = client.experimental.tasks.callToolStream({ name: 'myTool', arguments: {} });
-     * for await (const message of stream) {
-     *   switch (message.type) {
-     *     case 'taskCreated':
-     *       console.log('Tool execution started:', message.task.taskId);
-     *       break;
-     *     case 'taskStatus':
-     *       console.log('Tool status:', message.task.status);
-     *       break;
-     *     case 'result':
-     *       console.log('Tool result:', message.result);
-     *       break;
-     *     case 'error':
-     *       console.error('Tool error:', message.error);
-     *       break;
-     *   }
-     * }
-     * ```
-     *
-     * @param params - Tool call parameters (name and arguments)
-     * @param resultSchema - Zod schema for validating the result (defaults to CallToolResultSchema)
-     * @param options - Optional request options (timeout, signal, task creation params, etc.)
-     * @returns AsyncGenerator that yields ResponseMessage objects
-     *
-     * @experimental
-     */
-    async *callToolStream(params, resultSchema = CallToolResultSchema, options) {
-      var _a;
-      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: (_a = options === null || options === void 0 ? void 0 : options.task) !== null && _a !== void 0 ? _a : clientInternal.isToolTask(params.name) ? {} : void 0
-      };
-      const stream = clientInternal.requestStream({ method: "tools/call", params }, resultSchema, optionsWithTask);
-      const validator = clientInternal.getToolOutputValidator(params.name);
-      for await (const message of stream) {
-        if (message.type === "result" && validator) {
-          const result = message.result;
-          if (!result.structuredContent && !result.isError) {
-            yield {
-              type: "error",
-              error: new McpError(exports2.ErrorCode.InvalidRequest, `Tool ${params.name} has an output schema but did not return structured content`)
-            };
-            return;
-          }
-          if (result.structuredContent) {
-            try {
-              const validationResult = validator(result.structuredContent);
-              if (!validationResult.valid) {
-                yield {
-                  type: "error",
-                  error: new McpError(exports2.ErrorCode.InvalidParams, `Structured content does not match the tool's output schema: ${validationResult.errorMessage}`)
-                };
-                return;
-              }
-            } catch (error) {
-              if (error instanceof McpError) {
-                yield { type: "error", error };
-                return;
-              }
-              yield {
-                type: "error",
-                error: new McpError(exports2.ErrorCode.InvalidParams, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`)
-              };
-              return;
-            }
-          }
-        }
-        yield message;
-      }
-    }
-    /**
-     * Gets the current status of a task.
-     *
-     * @param taskId - The task identifier
-     * @param options - Optional request options
-     * @returns The task status
-     *
-     * @experimental
-     */
-    async getTask(taskId, options) {
-      return this._client.getTask({ taskId }, options);
-    }
-    /**
-     * Retrieves the result of a completed task.
-     *
-     * @param taskId - The task identifier
-     * @param resultSchema - Zod schema for validating the result
-     * @param options - Optional request options
-     * @returns The task result
-     *
-     * @experimental
-     */
-    async getTaskResult(taskId, resultSchema, options) {
-      return this._client.getTaskResult({ taskId }, resultSchema, options);
-    }
-    /**
-     * Lists tasks with optional pagination.
-     *
-     * @param cursor - Optional pagination cursor
-     * @param options - Optional request options
-     * @returns List of tasks with optional next cursor
-     *
-     * @experimental
-     */
-    async listTasks(cursor, options) {
-      return this._client.listTasks(cursor ? { cursor } : void 0, options);
-    }
-    /**
-     * Cancels a running task.
-     *
-     * @param taskId - The task identifier
-     * @param options - Optional request options
-     *
-     * @experimental
-     */
-    async cancelTask(taskId, options) {
-      return this._client.cancelTask({ taskId }, options);
-    }
-    /**
-     * Sends a request and returns an AsyncGenerator that yields response messages.
-     * The generator is guaranteed to end with either a 'result' or 'error' message.
-     *
-     * This method provides streaming access to request processing, allowing you to
-     * observe intermediate task status updates for task-augmented requests.
-     *
-     * @param request - The request to send
-     * @param resultSchema - Zod schema for validating the result
-     * @param options - Optional request options (timeout, signal, task creation params, etc.)
-     * @returns AsyncGenerator that yields ResponseMessage objects
-     *
-     * @experimental
-     */
-    requestStream(request, resultSchema, options) {
-      return this._client.requestStream(request, resultSchema, options);
-    }
-  }
-  function assertToolsCallTaskCapability(requests, method, entityName) {
-    var _a;
-    if (!requests) {
-      throw new Error(`${entityName} does not support task creation (required for ${method})`);
-    }
-    switch (method) {
-      case "tools/call":
-        if (!((_a = requests.tools) === null || _a === void 0 ? void 0 : _a.call)) {
-          throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
-        }
-        break;
-    }
-  }
-  function assertClientRequestTaskCapability(requests, method, entityName) {
-    var _a, _b;
-    if (!requests) {
-      throw new Error(`${entityName} does not support task creation (required for ${method})`);
-    }
-    switch (method) {
-      case "sampling/createMessage":
-        if (!((_a = requests.sampling) === null || _a === void 0 ? void 0 : _a.createMessage)) {
-          throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
-        }
-        break;
-      case "elicitation/create":
-        if (!((_b = requests.elicitation) === null || _b === void 0 ? void 0 : _b.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;
@@ -18762,26 +17732,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       super(options);
       this._clientInfo = _clientInfo;
       this._cachedToolOutputValidators = /* @__PURE__ */ new Map();
-      this._cachedKnownTaskTools = /* @__PURE__ */ new Set();
-      this._cachedRequiredTaskTools = /* @__PURE__ */ new Set();
       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();
     }
-    /**
-     * 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.
      *
@@ -18835,14 +17788,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             throw new McpError(exports2.ErrorCode.InvalidParams, "Client does not support URL-mode elicitation requests");
           }
           const result = await Promise.resolve(handler(request, extra));
-          if (params.task) {
-            const taskValidationResult = safeParse(CreateTaskResultSchema, result);
-            if (!taskValidationResult.success) {
-              const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-              throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
-            }
-            return taskValidationResult.data;
-          }
           const validationResult = safeParse(ElicitResultSchema, result);
           if (!validationResult.success) {
             const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
@@ -18862,32 +17807,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         };
         return super.setRequestHandler(requestSchema, wrappedHandler);
       }
-      if (method === "sampling/createMessage") {
-        const wrappedHandler = async (request, extra) => {
-          const validatedRequest = safeParse(CreateMessageRequestSchema, request);
-          if (!validatedRequest.success) {
-            const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-            throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid sampling request: ${errorMessage}`);
-          }
-          const { params } = validatedRequest.data;
-          const result = await Promise.resolve(handler(request, extra));
-          if (params.task) {
-            const taskValidationResult = safeParse(CreateTaskResultSchema, result);
-            if (!taskValidationResult.success) {
-              const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-              throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
-            }
-            return taskValidationResult.data;
-          }
-          const validationResult = safeParse(CreateMessageResultSchema, result);
-          if (!validationResult.success) {
-            const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-            throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid sampling result: ${errorMessage}`);
-          }
-          return validationResult.data;
-        };
-        return super.setRequestHandler(requestSchema, wrappedHandler);
-      }
       return super.setRequestHandler(requestSchema, handler);
     }
     assertCapability(capability, method) {
@@ -18998,9 +17917,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     }
     assertRequestHandlerCapability(method) {
-      if (!this._capabilities) {
-        return;
-      }
       switch (method) {
         case "sampling/createMessage":
           if (!this._capabilities.sampling) {
@@ -19017,26 +17933,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             throw new Error(`Client does not support roots capability (required for ${method})`);
           }
           break;
-        case "tasks/get":
-        case "tasks/list":
-        case "tasks/result":
-        case "tasks/cancel":
-          if (!this._capabilities.tasks) {
-            throw new Error(`Client does not support tasks capability (required for ${method})`);
-          }
-          break;
-      }
-    }
-    assertTaskCapability(method) {
-      var _a, _b;
-      assertToolsCallTaskCapability((_b = (_a = this._serverCapabilities) === null || _a === void 0 ? void 0 : _a.tasks) === null || _b === void 0 ? void 0 : _b.requests, method, "Server");
-    }
-    assertTaskHandlerCapability(method) {
-      var _a;
-      if (!this._capabilities) {
-        return;
       }
-      assertClientRequestTaskCapability((_a = this._capabilities.tasks) === null || _a === void 0 ? void 0 : _a.requests, method, "Client");
     }
     async ping(options) {
       return this.request({ method: "ping" }, EmptyResultSchema, options);
@@ -19068,15 +17965,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     async unsubscribeResource(params, options) {
       return this.request({ method: "resources/unsubscribe", params }, EmptyResultSchema, options);
     }
-    /**
-     * Calls a tool and waits for the result. Automatically validates structured output if the tool has an outputSchema.
-     *
-     * For task-based execution with streaming behavior, use client.experimental.tasks.callToolStream() instead.
-     */
     async callTool(params, resultSchema = CallToolResultSchema, options) {
-      if (this.isToolTaskRequired(params.name)) {
-        throw new McpError(exports2.ErrorCode.InvalidRequest, `Tool "${params.name}" requires task-based execution. Use client.experimental.tasks.callToolStream() instead.`);
-      }
       const result = await this.request({ method: "tools/call", params }, resultSchema, options);
       const validator = this.getToolOutputValidator(params.name);
       if (validator) {
@@ -19099,41 +17988,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       return result;
     }
-    isToolTask(toolName) {
-      var _a, _b, _c, _d;
-      if (!((_d = (_c = (_b = (_a = this._serverCapabilities) === null || _a === void 0 ? void 0 : _a.tasks) === null || _b === void 0 ? void 0 : _b.requests) === null || _c === void 0 ? void 0 : _c.tools) === null || _d === void 0 ? void 0 : _d.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.
      */
-    cacheToolMetadata(tools) {
-      var _a;
+    cacheToolOutputSchemas(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 = (_a = tool.execution) === null || _a === void 0 ? void 0 : _a.taskSupport;
-        if (taskSupport === "required" || taskSupport === "optional") {
-          this._cachedKnownTaskTools.add(tool.name);
-        }
-        if (taskSupport === "required") {
-          this._cachedRequiredTaskTools.add(tool.name);
-        }
       }
     }
     /**
@@ -19144,7 +18009,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     async listTools(params, options) {
       const result = await this.request({ method: "tools/list", params }, ListToolsResultSchema, options);
-      this.cacheToolMetadata(result.tools);
+      this.cacheToolOutputSchemas(result.tools);
       return result;
     }
     async sendRootsListChanged() {
@@ -19320,8 +18185,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   const OAuthClientInformationSchema = object$1({
     client_id: string(),
     client_secret: string().optional(),
-    client_id_issued_at: number$1().optional(),
-    client_secret_expires_at: number$1().optional()
+    client_id_issued_at: number().optional(),
+    client_secret_expires_at: number().optional()
   }).strip();
   const OAuthClientInformationFullSchema = OAuthClientMetadataSchema.merge(OAuthClientInformationSchema);
   object$1({
@@ -19421,9 +18286,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   class InsufficientScopeError extends OAuthError {
   }
   InsufficientScopeError.errorCode = "insufficient_scope";
-  class InvalidTargetError extends OAuthError {
-  }
-  InvalidTargetError.errorCode = "invalid_target";
   const OAUTH_ERRORS = {
     [InvalidRequestError.errorCode]: InvalidRequestError,
     [InvalidClientError.errorCode]: InvalidClientError,
@@ -19440,8 +18302,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     [MethodNotAllowedError.errorCode]: MethodNotAllowedError,
     [TooManyRequestsError.errorCode]: TooManyRequestsError,
     [InvalidClientMetadataError.errorCode]: InvalidClientMetadataError,
-    [InsufficientScopeError.errorCode]: InsufficientScopeError,
-    [InvalidTargetError.errorCode]: InvalidTargetError
+    [InsufficientScopeError.errorCode]: InsufficientScopeError
   };
   class UnauthorizedError extends Error {
     constructor(message) {
@@ -19579,12 +18440,16 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         clientInformation = fullInformation;
       }
     }
-    const nonInteractiveFlow = !provider.redirectUrl;
-    if (authorizationCode !== void 0 || nonInteractiveFlow) {
-      const tokens2 = await fetchToken(provider, authorizationServerUrl, {
+    if (authorizationCode !== void 0) {
+      const codeVerifier2 = await provider.codeVerifier();
+      const tokens2 = await exchangeAuthorization(authorizationServerUrl, {
         metadata: metadata2,
-        resource,
+        clientInformation,
         authorizationCode,
+        codeVerifier: codeVerifier2,
+        redirectUri: provider.redirectUrl,
+        resource,
+        addClientAuthentication: provider.addClientAuthentication,
         fetchFn
       });
       await provider.saveTokens(tokens2);
@@ -19704,17 +18569,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   }
   async function discoverOAuthProtectedResourceMetadata(serverUrl, opts, fetchFn = fetch) {
-    var _a, _b;
     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
     });
     if (!response || response.status === 404) {
-      await ((_a = response === null || response === void 0 ? void 0 : response.body) === null || _a === void 0 ? void 0 : _a.cancel());
       throw new Error(`Resource server does not implement OAuth 2.0 Protected Resource Metadata.`);
     }
     if (!response.ok) {
-      await ((_b = response.body) === null || _b === void 0 ? void 0 : _b.cancel());
       throw new Error(`HTTP ${response.status} trying to load well-known OAuth protected resource metadata.`);
     }
     return OAuthProtectedResourceMetadataSchema.parse(await response.json());
@@ -19768,7 +18630,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return response;
   }
   async function discoverOAuthMetadata(issuer, { authorizationServerUrl, protocolVersion } = {}, fetchFn = fetch) {
-    var _a, _b;
     if (typeof issuer === "string") {
       issuer = new URL(issuer);
     }
@@ -19784,11 +18645,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       metadataServerUrl: authorizationServerUrl
     });
     if (!response || response.status === 404) {
-      await ((_a = response === null || response === void 0 ? void 0 : response.body) === null || _a === void 0 ? void 0 : _a.cancel());
       return void 0;
     }
     if (!response.ok) {
-      await ((_b = response.body) === null || _b === void 0 ? void 0 : _b.cancel());
       throw new Error(`HTTP ${response.status} trying to load well-known OAuth metadata`);
     }
     return OAuthMetadataSchema.parse(await response.json());
@@ -19827,7 +18686,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     return urlsToTry;
   }
   async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn = fetch, protocolVersion = LATEST_PROTOCOL_VERSION } = {}) {
-    var _a;
     const headers = {
       "MCP-Protocol-Version": protocolVersion,
       Accept: "application/json"
@@ -19839,7 +18697,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         continue;
       }
       if (!response.ok) {
-        await ((_a = response.body) === null || _a === void 0 ? void 0 : _a.cancel());
         if (response.status >= 400 && response.status < 500) {
           continue;
         }
@@ -19888,92 +18745,81 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     return { authorizationUrl, codeVerifier };
   }
-  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 }) {
+  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"
     });
-    if (resource) {
-      tokenRequestParams.set("resource", resource.href);
-    }
+    const params = new URLSearchParams({
+      grant_type: grantType,
+      code: authorizationCode,
+      code_verifier: codeVerifier,
+      redirect_uri: String(redirectUri)
+    });
     if (addClientAuthentication) {
-      await addClientAuthentication(headers, tokenRequestParams, tokenUrl, metadata2);
-    } else if (clientInformation) {
+      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, tokenRequestParams);
+      applyClientAuthentication(authMethod, clientInformation, headers, params);
+    }
+    if (resource) {
+      params.set("resource", resource.href);
     }
     const response = await (fetchFn !== null && fetchFn !== void 0 ? fetchFn : fetch)(tokenUrl, {
       method: "POST",
       headers,
-      body: tokenRequestParams
+      body: params
     });
     if (!response.ok) {
       throw await parseErrorResponse(response);
     }
     return OAuthTokensSchema.parse(await response.json());
   }
-  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
-    });
-  }
   async function refreshAuthorization(authorizationServerUrl, { metadata: metadata2, clientInformation, refreshToken, resource, addClientAuthentication, fetchFn }) {
-    const tokenRequestParams = new URLSearchParams({
-      grant_type: "refresh_token",
-      refresh_token: refreshToken
+    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"
     });
-    const tokens = await executeTokenRequest(authorizationServerUrl, {
-      metadata: metadata2,
-      tokenRequestParams,
-      clientInformation,
-      addClientAuthentication,
-      resource,
-      fetchFn
+    const params = new URLSearchParams({
+      grant_type: grantType,
+      refresh_token: refreshToken
     });
-    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 (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);
     }
-    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);
+    if (resource) {
+      params.set("resource", resource.href);
     }
-    const clientInformation = await provider.clientInformation();
-    return executeTokenRequest(authorizationServerUrl, {
-      metadata: metadata2,
-      tokenRequestParams,
-      clientInformation: clientInformation !== null && clientInformation !== void 0 ? clientInformation : void 0,
-      addClientAuthentication: provider.addClientAuthentication,
-      resource,
-      fetchFn
+    const response = await (fetchFn !== null && fetchFn !== void 0 ? fetchFn : fetch)(tokenUrl, {
+      method: "POST",
+      headers,
+      body: params
     });
+    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;
@@ -20442,11 +19288,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (this._protocolVersion) {
         headers["mcp-protocol-version"] = this._protocolVersion;
       }
-      const extraHeaders = normalizeHeaders((_a = this._requestInit) === null || _a === void 0 ? void 0 : _a.headers);
-      return new Headers({
-        ...headers,
-        ...extraHeaders
-      });
+      return new Headers({ ...headers, ...(_a = this._requestInit) === null || _a === void 0 ? void 0 : _a.headers });
     }
     _startOrAuth() {
       var _a, _b, _c;
@@ -20543,7 +19385,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       (_c = this.onclose) === null || _c === void 0 ? void 0 : _c.call(this);
     }
     async send(message) {
-      var _a, _b, _c, _d;
+      var _a, _b, _c;
       if (!this._endpoint) {
         throw new Error("Not connected");
       }
@@ -20559,7 +19401,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         };
         const response = await ((_b = this._fetch) !== null && _b !== void 0 ? _b : 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;
@@ -20575,11 +19416,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             }
             return this.send(message);
           }
+          const text = await response.text().catch(() => null);
           throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${text}`);
         }
-        await ((_c = response.body) === null || _c === void 0 ? void 0 : _c.cancel());
       } catch (error) {
-        (_d = this.onerror) === null || _d === void 0 ? void 0 : _d.call(this, error);
+        (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, error);
         throw error;
       }
     }
@@ -20679,7 +19520,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       });
     }
     async _startOrAuthSse(options) {
-      var _a, _b, _c, _d;
+      var _a, _b, _c;
       const { resumptionToken } = options;
       try {
         const headers = await this._commonHeaders();
@@ -20693,7 +19534,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           signal: (_b = this._abortController) === null || _b === void 0 ? void 0 : _b.signal
         });
         if (!response.ok) {
-          await ((_c = response.body) === null || _c === void 0 ? void 0 : _c.cancel());
           if (response.status === 401 && this._authProvider) {
             return await this._authThenStart();
           }
@@ -20704,7 +19544,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         }
         this._handleSseStream(response.body, options, true);
       } catch (error) {
-        (_d = this.onerror) === null || _d === void 0 ? void 0 : _d.call(this, error);
+        (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, error);
         throw error;
       }
     }
@@ -20732,12 +19572,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     _scheduleReconnection(options, attemptCount = 0) {
       var _a;
       const maxRetries = this._reconnectionOptions.maxRetries;
-      if (attemptCount >= 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.`));
         return;
       }
       const delay = this._getNextReconnectionDelay(attemptCount);
-      this._reconnectionTimeout = setTimeout(() => {
+      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)}`));
@@ -20752,7 +19592,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       const { onresumptiontoken, replayMessageId } = options;
       let lastEventId;
       let hasPrimingEvent = false;
-      let receivedResponse = false;
       const processStream = async () => {
         var _a, _b, _c, _d;
         try {
@@ -20771,17 +19610,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
               hasPrimingEvent = true;
               onresumptiontoken === null || onresumptiontoken === void 0 ? void 0 : onresumptiontoken(event.id);
             }
-            if (!event.data) {
-              continue;
-            }
             if (!event.event || event.event === "message") {
               try {
                 const message = JSONRPCMessageSchema.parse(JSON.parse(event.data));
-                if (isJSONRPCResponse(message)) {
-                  receivedResponse = true;
-                  if (replayMessageId !== void 0) {
-                    message.id = replayMessageId;
-                  }
+                if (replayMessageId !== void 0 && isJSONRPCResponse(message)) {
+                  message.id = replayMessageId;
                 }
                 (_a = this.onmessage) === null || _a === void 0 ? void 0 : _a.call(this, message);
               } catch (error) {
@@ -20790,8 +19623,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             }
           }
           const canResume = isReconnectable || hasPrimingEvent;
-          const needsReconnect = canResume && !receivedResponse;
-          if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
+          if (canResume && this._abortController && !this._abortController.signal.aborted) {
             this._scheduleReconnection({
               resumptionToken: lastEventId,
               onresumptiontoken,
@@ -20801,8 +19633,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         } catch (error) {
           (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, new Error(`SSE stream disconnected: ${error}`));
           const canResume = isReconnectable || hasPrimingEvent;
-          const needsReconnect = canResume && !receivedResponse;
-          if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
+          if (canResume && this._abortController && !this._abortController.signal.aborted) {
             try {
               this._scheduleReconnection({
                 resumptionToken: lastEventId,
@@ -20843,15 +19674,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
     async close() {
       var _a, _b;
-      if (this._reconnectionTimeout) {
-        clearTimeout(this._reconnectionTimeout);
-        this._reconnectionTimeout = void 0;
-      }
       (_a = this._abortController) === null || _a === void 0 ? void 0 : _a.abort();
       (_b = this.onclose) === null || _b === void 0 ? void 0 : _b.call(this);
     }
     async send(message, options) {
-      var _a, _b, _c, _d, _e, _f, _g;
+      var _a, _b, _c, _d;
       try {
         const { resumptionToken, onresumptiontoken } = options || {};
         if (resumptionToken) {
@@ -20877,7 +19704,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           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");
@@ -20923,12 +19749,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
               return this.send(message);
             }
           }
-          throw new StreamableHTTPError(response.status, `Error POSTing to endpoint: ${text}`);
+          const text = await response.text().catch(() => null);
+          throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${text}`);
         }
         this._hasCompletedAuthFlow = false;
         this._lastUpscopingHeader = void 0;
         if (response.status === 202) {
-          await ((_c = response.body) === null || _c === void 0 ? void 0 : _c.cancel());
           if (isInitializedNotification(message)) {
             this._startOrAuthSse({ resumptionToken: void 0 }).catch((err) => {
               var _a2;
@@ -20947,17 +19773,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             const data = await response.json();
             const responseMessages = Array.isArray(data) ? data.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(data)];
             for (const msg of responseMessages) {
-              (_d = this.onmessage) === null || _d === void 0 ? void 0 : _d.call(this, msg);
+              (_c = this.onmessage) === null || _c === void 0 ? void 0 : _c.call(this, msg);
             }
           } else {
-            await ((_e = response.body) === null || _e === void 0 ? void 0 : _e.cancel());
             throw new StreamableHTTPError(-1, `Unexpected content type: ${contentType}`);
           }
-        } else {
-          await ((_f = response.body) === null || _f === void 0 ? void 0 : _f.cancel());
         }
       } catch (error) {
-        (_g = this.onerror) === null || _g === void 0 ? void 0 : _g.call(this, error);
+        (_d = this.onerror) === null || _d === void 0 ? void 0 : _d.call(this, error);
         throw error;
       }
     }
@@ -20976,7 +19799,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
      * the server does not allow clients to terminate sessions.
      */
     async terminateSession() {
-      var _a, _b, _c, _d;
+      var _a, _b, _c;
       if (!this._sessionId) {
         return;
       }
@@ -20989,13 +19812,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           signal: (_a = this._abortController) === null || _a === void 0 ? void 0 : _a.signal
         };
         const response = await ((_b = this._fetch) !== null && _b !== void 0 ? _b : fetch)(this._url, init);
-        await ((_c = response.body) === null || _c === void 0 ? void 0 : _c.cancel());
         if (!response.ok && response.status !== 405) {
           throw new StreamableHTTPError(response.status, `Failed to terminate session: ${response.statusText}`);
         }
         this._sessionId = void 0;
       } catch (error) {
-        (_d = this.onerror) === null || _d === void 0 ? void 0 : _d.call(this, error);
+        (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, error);
         throw error;
       }
     }
@@ -21019,76 +19841,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       });
     }
   }
-  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.
@@ -21124,21 +19876,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         });
       }
     }
-    /**
-     * Access experimental features.
-     *
-     * WARNING: These APIs are experimental and may change without notice.
-     *
-     * @experimental
-     */
-    get experimental() {
-      if (!this._experimental) {
-        this._experimental = {
-          tasks: new ExperimentalServerTasks(this)
-        };
-      }
-      return this._experimental;
-    }
     /**
      * Registers new capabilities. This can only be called before connecting to a transport.
      *
@@ -21150,58 +19887,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       this._capabilities = mergeCapabilities(this._capabilities, capabilities);
     }
-    /**
-     * Override request handler registration to enforce server-side validation for tools/call.
-     */
-    setRequestHandler(requestSchema, handler) {
-      var _a, _b, _c;
-      const shape = getObjectShape(requestSchema);
-      const methodSchema = shape === null || shape === void 0 ? void 0 : 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;
-      } 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;
-      }
-      if (typeof methodValue !== "string") {
-        throw new Error("Schema method literal must be a string");
-      }
-      const method = methodValue;
-      if (method === "tools/call") {
-        const wrappedHandler = async (request, extra) => {
-          const validatedRequest = safeParse(CallToolRequestSchema, request);
-          if (!validatedRequest.success) {
-            const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-            throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
-          }
-          const { params } = validatedRequest.data;
-          const result = await Promise.resolve(handler(request, extra));
-          if (params.task) {
-            const taskValidationResult = safeParse(CreateTaskResultSchema, result);
-            if (!taskValidationResult.success) {
-              const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-              throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
-            }
-            return taskValidationResult.data;
-          }
-          const validationResult = safeParse(CallToolResultSchema, result);
-          if (!validationResult.success) {
-            const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-            throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
-          }
-          return validationResult.data;
-        };
-        return super.setRequestHandler(requestSchema, wrappedHandler);
-      }
-      return super.setRequestHandler(requestSchema, handler);
-    }
     assertCapabilityForMethod(method) {
       var _a, _b, _c;
       switch (method) {
@@ -21254,9 +19939,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
     }
     assertRequestHandlerCapability(method) {
-      if (!this._capabilities) {
-        return;
-      }
       switch (method) {
         case "completion/complete":
           if (!this._capabilities.completions) {
@@ -21287,26 +19969,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             throw new Error(`Server does not support tools (required for ${method})`);
           }
           break;
-        case "tasks/get":
-        case "tasks/list":
-        case "tasks/result":
-        case "tasks/cancel":
-          if (!this._capabilities.tasks) {
-            throw new Error(`Server does not support tasks capability (required for ${method})`);
-          }
-          break;
-      }
-    }
-    assertTaskCapability(method) {
-      var _a, _b;
-      assertClientRequestTaskCapability((_b = (_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.tasks) === null || _b === void 0 ? void 0 : _b.requests, method, "Client");
-    }
-    assertTaskHandlerCapability(method) {
-      var _a;
-      if (!this._capabilities) {
-        return;
       }
-      assertToolsCallTaskCapability((_a = this._capabilities.tasks) === null || _a === void 0 ? void 0 : _a.requests, method, "Server");
     }
     async _oninitialize(request) {
       const requestedVersion = request.params.protocolVersion;
@@ -21338,7 +20001,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     async ping() {
       return this.request({ method: "ping" }, EmptyResultSchema);
     }
-    // Implementation
     async createMessage(params, options) {
       var _a, _b;
       if (params.tools || params.toolChoice) {
@@ -21369,9 +20031,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           }
         }
       }
-      if (params.tools) {
-        return this.request({ method: "sampling/createMessage", params }, CreateMessageResultWithToolsSchema, options);
-      }
       return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
     }
     /**
@@ -21527,19 +20186,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     issueToolNameWarning(name, result.warnings);
     return result.isValid;
   }
-  class ExperimentalMcpServerTasks {
-    constructor(_mcpServer) {
-      this._mcpServer = _mcpServer;
-    }
-    registerToolTask(name, config2, handler) {
-      const execution = { taskSupport: "required", ...config2.execution };
-      if (execution.taskSupport === "forbidden") {
-        throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
-      }
-      const mcpServerInternal = this._mcpServer;
-      return mcpServerInternal._createRegisteredTool(name, config2.title, config2.description, config2.inputSchema, config2.outputSchema, config2.annotations, execution, config2._meta, handler);
-    }
-  }
   class McpServer {
     constructor(serverInfo, options) {
       this._registeredResources = {};
@@ -21552,21 +20198,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this._promptHandlersInitialized = false;
       this.server = new Server(serverInfo, options);
     }
-    /**
-     * Access experimental features.
-     *
-     * WARNING: These APIs are experimental and may change without notice.
-     *
-     * @experimental
-     */
-    get experimental() {
-      if (!this._experimental) {
-        this._experimental = {
-          tasks: new ExperimentalMcpServerTasks(this)
-        };
-      }
-      return this._experimental;
-    }
     /**
      * Attaches to the given transport, starts it, and starts listening for messages.
      *
@@ -21606,7 +20237,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
               }) : EMPTY_OBJECT_JSON_SCHEMA;
             })(),
             annotations: tool.annotations,
-            execution: tool.execution,
             _meta: tool._meta
           };
           if (tool.outputSchema) {
@@ -21622,34 +20252,39 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         })
       }));
       this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-        var _a;
+        const tool = this._registeredTools[request.params.name];
+        let result;
         try {
-          const tool = this._registeredTools[request.params.name];
           if (!tool) {
             throw new McpError(exports2.ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
           }
           if (!tool.enabled) {
             throw new McpError(exports2.ErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
           }
-          const isTaskRequest = !!request.params.task;
-          const taskSupport = (_a = tool.execution) === null || _a === void 0 ? void 0 : _a.taskSupport;
-          const isTaskHandler = "createTask" in tool.handler;
-          if ((taskSupport === "required" || taskSupport === "optional") && !isTaskHandler) {
-            throw new McpError(exports2.ErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
-          }
-          if (taskSupport === "required" && !isTaskRequest) {
-            throw new McpError(exports2.ErrorCode.MethodNotFound, `Tool ${request.params.name} requires task augmentation (taskSupport: 'required')`);
-          }
-          if (taskSupport === "optional" && !isTaskRequest && isTaskHandler) {
-            return await this.handleAutomaticTaskPolling(tool, request, extra);
+          if (tool.inputSchema) {
+            const cb = tool.callback;
+            const inputObj = normalizeObjectSchema(tool.inputSchema);
+            const schemaToParse = inputObj !== null && inputObj !== void 0 ? inputObj : tool.inputSchema;
+            const parseResult = await safeParseAsync(schemaToParse, request.params.arguments);
+            if (!parseResult.success) {
+              throw new McpError(exports2.ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`);
+            }
+            const args = parseResult.data;
+            result = await Promise.resolve(cb(args, extra));
+          } else {
+            const cb = tool.callback;
+            result = await Promise.resolve(cb(extra));
           }
-          const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
-          const result = await this.executeToolHandler(tool, args, extra);
-          if (isTaskRequest) {
-            return result;
+          if (tool.outputSchema && !result.isError) {
+            if (!result.structuredContent) {
+              throw new McpError(exports2.ErrorCode.InvalidParams, `Output validation error: Tool ${request.params.name} has an output schema but no structured content was provided`);
+            }
+            const outputObj = normalizeObjectSchema(tool.outputSchema);
+            const parseResult = await safeParseAsync(outputObj, result.structuredContent);
+            if (!parseResult.success) {
+              throw new McpError(exports2.ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`);
+            }
           }
-          await this.validateToolOutput(tool, result, request.params.name);
-          return result;
         } catch (error) {
           if (error instanceof McpError) {
             if (error.code === exports2.ErrorCode.UrlElicitationRequired) {
@@ -21658,6 +20293,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           }
           return this.createToolError(error instanceof Error ? error.message : String(error));
         }
+        return result;
       });
       this._toolHandlersInitialized = true;
     }
@@ -21678,102 +20314,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         isError: true
       };
     }
-    /**
-     * Validates tool input arguments against the tool's input schema.
-     */
-    async validateToolInput(tool, args, toolName) {
-      if (!tool.inputSchema) {
-        return void 0;
-      }
-      const inputObj = normalizeObjectSchema(tool.inputSchema);
-      const schemaToParse = inputObj !== null && inputObj !== void 0 ? inputObj : tool.inputSchema;
-      const parseResult = await safeParseAsync(schemaToParse, args);
-      if (!parseResult.success) {
-        const error = "error" in parseResult ? parseResult.error : "Unknown error";
-        const errorMessage = getParseErrorMessage(error);
-        throw new McpError(exports2.ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
-      }
-      return parseResult.data;
-    }
-    /**
-     * Validates tool output against the tool's output schema.
-     */
-    async validateToolOutput(tool, result, toolName) {
-      if (!tool.outputSchema) {
-        return;
-      }
-      if (!("content" in result)) {
-        return;
-      }
-      if (result.isError) {
-        return;
-      }
-      if (!result.structuredContent) {
-        throw new McpError(exports2.ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
-      }
-      const outputObj = normalizeObjectSchema(tool.outputSchema);
-      const parseResult = await safeParseAsync(outputObj, result.structuredContent);
-      if (!parseResult.success) {
-        const error = "error" in parseResult ? parseResult.error : "Unknown error";
-        const errorMessage = getParseErrorMessage(error);
-        throw new McpError(exports2.ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
-      }
-    }
-    /**
-     * Executes a tool handler (either regular or task-based).
-     */
-    async executeToolHandler(tool, args, extra) {
-      const handler = tool.handler;
-      const isTaskHandler = "createTask" in handler;
-      if (isTaskHandler) {
-        if (!extra.taskStore) {
-          throw new Error("No task store provided.");
-        }
-        const taskExtra = { ...extra, taskStore: extra.taskStore };
-        if (tool.inputSchema) {
-          const typedHandler = handler;
-          return await Promise.resolve(typedHandler.createTask(args, taskExtra));
-        } else {
-          const typedHandler = handler;
-          return await Promise.resolve(typedHandler.createTask(taskExtra));
-        }
-      }
-      if (tool.inputSchema) {
-        const typedHandler = handler;
-        return await Promise.resolve(typedHandler(args, extra));
-      } else {
-        const typedHandler = handler;
-        return await Promise.resolve(typedHandler(extra));
-      }
-    }
-    /**
-     * Handles automatic task polling for tools with taskSupport 'optional'.
-     */
-    async handleAutomaticTaskPolling(tool, request, extra) {
-      var _a;
-      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 = (_a = task.pollInterval) !== null && _a !== void 0 ? _a : 5e3;
-      while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
-        const updatedTask = await extra.taskStore.getTask(taskId);
-        if (!updatedTask) {
-          throw new McpError(exports2.ErrorCode.InternalError, `Task ${taskId} not found during polling`);
-        }
-        task = updatedTask;
-      }
-      return await extra.taskStore.getTaskResult(taskId);
-    }
     setCompletionRequestHandler() {
       if (this._completionHandlerInitialized) {
         return;
@@ -21929,9 +20469,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           const argsObj = normalizeObjectSchema(prompt.argsSchema);
           const parseResult = await safeParseAsync(argsObj, request.params.arguments);
           if (!parseResult.success) {
-            const error = "error" in parseResult ? parseResult.error : "Unknown error";
-            const errorMessage = getParseErrorMessage(error);
-            throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
+            throw new McpError(exports2.ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`);
           }
           const args = parseResult.data;
           const cb = prompt.callback;
@@ -22083,7 +20621,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       this._registeredPrompts[name] = registeredPrompt;
       return registeredPrompt;
     }
-    _createRegisteredTool(name, title2, description2, inputSchema, outputSchema, annotations, execution, _meta, handler) {
+    _createRegisteredTool(name, title2, description2, inputSchema, outputSchema, annotations, _meta, callback) {
       validateAndWarnToolName(name);
       const registeredTool = {
         title: title2,
@@ -22091,9 +20629,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         inputSchema: getZodSchemaObject(inputSchema),
         outputSchema: getZodSchemaObject(outputSchema),
         annotations,
-        execution,
         _meta,
-        handler,
+        callback,
         enabled: true,
         disable: () => registeredTool.update({ enabled: false }),
         enable: () => registeredTool.update({ enabled: true }),
@@ -22114,7 +20651,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           if (typeof updates.paramsSchema !== "undefined")
             registeredTool.inputSchema = objectFromShape(updates.paramsSchema);
           if (typeof updates.callback !== "undefined")
-            registeredTool.handler = updates.callback;
+            registeredTool.callback = updates.callback;
           if (typeof updates.annotations !== "undefined")
             registeredTool.annotations = updates.annotations;
           if (typeof updates._meta !== "undefined")
@@ -22145,9 +20682,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       }
       if (rest.length > 1) {
         const firstArg = rest[0];
-        if (isZodRawShapeCompat(firstArg)) {
+        if (isZodRawShape(firstArg)) {
           inputSchema = rest.shift();
-          if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShapeCompat(rest[0])) {
+          if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShape(rest[0])) {
             annotations = rest.shift();
           }
         } else if (typeof firstArg === "object" && firstArg !== null) {
@@ -22155,7 +20692,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         }
       }
       const callback = rest[0];
-      return this._createRegisteredTool(name, void 0, description2, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, void 0, callback);
+      return this._createRegisteredTool(name, void 0, description2, inputSchema, outputSchema, annotations, void 0, callback);
     }
     /**
      * Registers a tool with a config object and callback.
@@ -22165,7 +20702,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         throw new Error(`Tool ${name} is already registered`);
       }
       const { title: title2, description: description2, inputSchema, outputSchema, annotations, _meta } = config2;
-      return this._createRegisteredTool(name, title2, description2, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
+      return this._createRegisteredTool(name, title2, description2, inputSchema, outputSchema, annotations, _meta, cb);
     }
     prompt(name, ...rest) {
       if (this._registeredPrompts[name]) {
@@ -22269,29 +20806,20 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     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 (isZodRawShapeCompat(schema)) {
+    if (isZodRawShape(schema)) {
       return objectFromShape(schema);
     }
     return schema;
@@ -22338,7 +20866,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     }
   };
   exports2.Ajv = ajv;
-  exports2.AnnotationsSchema = AnnotationsSchema;
   exports2.AudioContentSchema = AudioContentSchema;
   exports2.BaseMetadataSchema = BaseMetadataSchema;
   exports2.BlobResourceContentsSchema = BlobResourceContentsSchema;
@@ -22347,8 +20874,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.CallToolRequestParamsSchema = CallToolRequestParamsSchema;
   exports2.CallToolRequestSchema = CallToolRequestSchema;
   exports2.CallToolResultSchema = CallToolResultSchema;
-  exports2.CancelTaskRequestSchema = CancelTaskRequestSchema;
-  exports2.CancelTaskResultSchema = CancelTaskResultSchema;
   exports2.CancelledNotificationParamsSchema = CancelledNotificationParamsSchema;
   exports2.CancelledNotificationSchema = CancelledNotificationSchema;
   exports2.Client = Client;
@@ -22356,7 +20881,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.ClientNotificationSchema = ClientNotificationSchema;
   exports2.ClientRequestSchema = ClientRequestSchema;
   exports2.ClientResultSchema = ClientResultSchema;
-  exports2.ClientTasksCapabilitySchema = ClientTasksCapabilitySchema;
   exports2.CompatibilityCallToolResultSchema = CompatibilityCallToolResultSchema;
   exports2.CompleteRequestParamsSchema = CompleteRequestParamsSchema;
   exports2.CompleteRequestSchema = CompleteRequestSchema;
@@ -22365,8 +20889,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.CreateMessageRequestParamsSchema = CreateMessageRequestParamsSchema;
   exports2.CreateMessageRequestSchema = CreateMessageRequestSchema;
   exports2.CreateMessageResultSchema = CreateMessageResultSchema;
-  exports2.CreateMessageResultWithToolsSchema = CreateMessageResultWithToolsSchema;
-  exports2.CreateTaskResultSchema = CreateTaskResultSchema;
   exports2.CursorSchema = CursorSchema;
   exports2.DEFAULT_NEGOTIATED_PROTOCOL_VERSION = DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
   exports2.DEFAULT_REQUEST_TIMEOUT_MSEC = DEFAULT_REQUEST_TIMEOUT_MSEC;
@@ -22383,9 +20905,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.GetPromptRequestParamsSchema = GetPromptRequestParamsSchema;
   exports2.GetPromptRequestSchema = GetPromptRequestSchema;
   exports2.GetPromptResultSchema = GetPromptResultSchema;
-  exports2.GetTaskPayloadRequestSchema = GetTaskPayloadRequestSchema;
-  exports2.GetTaskRequestSchema = GetTaskRequestSchema;
-  exports2.GetTaskResultSchema = GetTaskResultSchema;
   exports2.IconSchema = IconSchema;
   exports2.IconsSchema = IconsSchema;
   exports2.ImageContentSchema = ImageContentSchema;
@@ -22410,8 +20929,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.ListResourcesResultSchema = ListResourcesResultSchema;
   exports2.ListRootsRequestSchema = ListRootsRequestSchema;
   exports2.ListRootsResultSchema = ListRootsResultSchema;
-  exports2.ListTasksRequestSchema = ListTasksRequestSchema;
-  exports2.ListTasksResultSchema = ListTasksResultSchema;
   exports2.ListToolsRequestSchema = ListToolsRequestSchema;
   exports2.ListToolsResultSchema = ListToolsResultSchema;
   exports2.LoggingLevelSchema = LoggingLevelSchema;
@@ -22439,11 +20956,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.PromptReferenceSchema = PromptReferenceSchema;
   exports2.PromptSchema = PromptSchema;
   exports2.Protocol = Protocol;
-  exports2.RELATED_TASK_META_KEY = RELATED_TASK_META_KEY;
   exports2.ReadResourceRequestParamsSchema = ReadResourceRequestParamsSchema;
   exports2.ReadResourceRequestSchema = ReadResourceRequestSchema;
   exports2.ReadResourceResultSchema = ReadResourceResultSchema;
-  exports2.RelatedTaskMetadataSchema = RelatedTaskMetadataSchema;
   exports2.RequestIdSchema = RequestIdSchema;
   exports2.RequestSchema = RequestSchema;
   exports2.ResourceContentsSchema = ResourceContentsSchema;
@@ -22462,14 +20977,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.RootsListChangedNotificationSchema = RootsListChangedNotificationSchema;
   exports2.SSEClientTransport = SSEClientTransport;
   exports2.SUPPORTED_PROTOCOL_VERSIONS = SUPPORTED_PROTOCOL_VERSIONS;
-  exports2.SamplingContentSchema = SamplingContentSchema;
   exports2.SamplingMessageContentBlockSchema = SamplingMessageContentBlockSchema;
   exports2.SamplingMessageSchema = SamplingMessageSchema;
   exports2.ServerCapabilitiesSchema = ServerCapabilitiesSchema;
   exports2.ServerNotificationSchema = ServerNotificationSchema;
   exports2.ServerRequestSchema = ServerRequestSchema;
   exports2.ServerResultSchema = ServerResultSchema;
-  exports2.ServerTasksCapabilitySchema = ServerTasksCapabilitySchema;
   exports2.SetLevelRequestParamsSchema = SetLevelRequestParamsSchema;
   exports2.SetLevelRequestSchema = SetLevelRequestSchema;
   exports2.SingleSelectEnumSchemaSchema = SingleSelectEnumSchemaSchema;
@@ -22479,17 +20992,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.StringSchemaSchema = StringSchemaSchema;
   exports2.SubscribeRequestParamsSchema = SubscribeRequestParamsSchema;
   exports2.SubscribeRequestSchema = SubscribeRequestSchema;
-  exports2.TaskCreationParamsSchema = TaskCreationParamsSchema;
-  exports2.TaskSchema = TaskSchema;
-  exports2.TaskStatusNotificationParamsSchema = TaskStatusNotificationParamsSchema;
-  exports2.TaskStatusNotificationSchema = TaskStatusNotificationSchema;
   exports2.TextContentSchema = TextContentSchema;
   exports2.TextResourceContentsSchema = TextResourceContentsSchema;
   exports2.TitledMultiSelectEnumSchemaSchema = TitledMultiSelectEnumSchemaSchema;
   exports2.TitledSingleSelectEnumSchemaSchema = TitledSingleSelectEnumSchemaSchema;
   exports2.ToolAnnotationsSchema = ToolAnnotationsSchema;
   exports2.ToolChoiceSchema = ToolChoiceSchema;
-  exports2.ToolExecutionSchema = ToolExecutionSchema;
   exports2.ToolListChangedNotificationSchema = ToolListChangedNotificationSchema;
   exports2.ToolResultContentSchema = ToolResultContentSchema;
   exports2.ToolSchema = ToolSchema;
@@ -22513,7 +21021,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.exchangeAuthorization = exchangeAuthorization;
   exports2.extractResourceMetadataUrl = extractResourceMetadataUrl;
   exports2.extractWWWAuthenticateParams = extractWWWAuthenticateParams;
-  exports2.fetchToken = fetchToken;
   exports2.getCompleter = getCompleter;
   exports2.getDisplayName = getDisplayName;
   exports2.getSupportedElicitationModes = getSupportedElicitationModes;
@@ -22528,7 +21035,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   exports2.mergeCapabilities = mergeCapabilities;
   exports2.normalizeHeaders = normalizeHeaders;
   exports2.parseErrorResponse = parseErrorResponse;
-  exports2.prepareAuthorizationCodeRequest = prepareAuthorizationCodeRequest;
   exports2.refreshAuthorization = refreshAuthorization;
   exports2.registerClient = registerClient;
   exports2.selectClientAuthMethod = selectClientAuthMethod;