taskin 1.0.12 → 1.0.13

package/dist/index.js

@@ -38,12 +38,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/.pnpm/tsup@8.5.0_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var getFilename, getDirname, __dirname;
 var init_esm_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.5.0_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
+  "../../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
     getFilename = () => fileURLToPath(import.meta.url);
     getDirname = () => path.dirname(getFilename());
@@ -106,9 +106,18 @@ async function fixTaskFile(filePath) {
     const content = await readFile(filePath, "utf-8");
     const locale = detectLocale(content);
     const i18n = getI18n(locale);
-    const statusPattern = new RegExp(`##\\s*(?:Status|${i18n.status})\\s*\\n\\s*([^\\n\\r]+)`, "i");
-    const typePattern = new RegExp(`##\\s*(?:Type|${i18n.type})\\s*\\n\\s*([^\\n\\r]+)`, "i");
-    const assigneePattern = new RegExp(`##\\s*(?:Assignee|${i18n.assignee})\\s*\\n\\s*([^\\n\\r]+)`, "i");
+    const statusPattern = new RegExp(
+      `##\\s*(?:Status|${i18n.status})\\s*\\n\\s*([^\\n\\r]+)`,
+      "i"
+    );
+    const typePattern = new RegExp(
+      `##\\s*(?:Type|${i18n.type})\\s*\\n\\s*([^\\n\\r]+)`,
+      "i"
+    );
+    const assigneePattern = new RegExp(
+      `##\\s*(?:Assignee|${i18n.assignee})\\s*\\n\\s*([^\\n\\r]+)`,
+      "i"
+    );
     const hasSectionStatus = statusPattern.test(content);
     const hasSectionType = typePattern.test(content);
     const hasSectionAssignee = assigneePattern.test(content);
@@ -166,9 +175,18 @@ async function fixTaskFile(filePath) {
     }
     if (needsSpaceFix) {
       newContent = newContent.replace(/^(# .+)\n([^#\n])/m, "$1\n\n$2");
-      newContent = newContent.replace(/^(Status|Tipo):\s*(.+?)(\s*)$/im, (_, key, value) => `${key}: ${value.trim()}  `);
-      newContent = newContent.replace(/^(Type|Tipo):\s*(.+?)(\s*)$/im, (_, key, value) => `${key}: ${value.trim()}  `);
-      newContent = newContent.replace(/^(Assignee|Responsável):\s*(.+?)(\s*)$/im, (_, key, value) => `${key}: ${value.trim()}  `);
+      newContent = newContent.replace(
+        /^(Status|Tipo):\s*(.+?)(\s*)$/im,
+        (_, key, value) => `${key}: ${value.trim()}  `
+      );
+      newContent = newContent.replace(
+        /^(Type|Tipo):\s*(.+?)(\s*)$/im,
+        (_, key, value) => `${key}: ${value.trim()}  `
+      );
+      newContent = newContent.replace(
+        /^(Assignee|Responsável):\s*(.+?)(\s*)$/im,
+        (_, key, value) => `${key}: ${value.trim()}  `
+      );
       wasModified = true;
     }
     if (wasModified) {
@@ -190,8 +208,14 @@ async function validateTaskFile(filePath) {
     const locale = detectLocale(content);
     const i18n = getI18n(locale);
     const hasTitleSection = lines.some((line) => line.trim().startsWith("# "));
-    const inlineStatusPattern = new RegExp(`^(?:Status|${i18n.status}):\\s*.+$`, "im");
-    const sectionStatusPattern = new RegExp(`##\\s*(?:Status|${i18n.status})`, "i");
+    const inlineStatusPattern = new RegExp(
+      `^(?:Status|${i18n.status}):\\s*.+$`,
+      "im"
+    );
+    const sectionStatusPattern = new RegExp(
+      `##\\s*(?:Status|${i18n.status})`,
+      "i"
+    );
     const hasInlineStatus = inlineStatusPattern.test(content);
     const hasSectionStatus = sectionStatusPattern.test(content);
     const hasDescriptionSection = content.includes("## Description") || content.includes("## Descri\xE7\xE3o");
@@ -205,7 +229,9 @@ async function validateTaskFile(filePath) {
       });
     }
     if (hasSectionStatus) {
-      const statusLineIdx = lines.findIndex((line) => sectionStatusPattern.test(line.trim()));
+      const statusLineIdx = lines.findIndex(
+        (line) => sectionStatusPattern.test(line.trim())
+      );
       issues.push({
         file: filePath,
         line: statusLineIdx >= 0 ? statusLineIdx + 1 : void 0,
@@ -234,7 +260,9 @@ ${i18n.status}: <todo|in-progress|done>`
         "blocked",
         "canceled"
       ].includes(statusValue)) {
-        const statusLineIdx = lines.findIndex((line) => inlineStatusPattern.test(line.trim()));
+        const statusLineIdx = lines.findIndex(
+          (line) => inlineStatusPattern.test(line.trim())
+        );
         issues.push({
           file: filePath,
           line: statusLineIdx >= 0 ? statusLineIdx + 1 : void 0,
@@ -281,9 +309,15 @@ ${i18n.status}: <todo|in-progress|done>`
   return issues;
 }
 function createLintResult(allIssues) {
-  const errorCount = allIssues.filter((issue) => issue.severity === "error").length;
-  const warningCount = allIssues.filter((issue) => issue.severity === "warning").length;
-  const infoCount = allIssues.filter((issue) => issue.severity === "info").length;
+  const errorCount = allIssues.filter(
+    (issue) => issue.severity === "error"
+  ).length;
+  const warningCount = allIssues.filter(
+    (issue) => issue.severity === "warning"
+  ).length;
+  const infoCount = allIssues.filter(
+    (issue) => issue.severity === "info"
+  ).length;
   return {
     valid: errorCount === 0,
     issues: allIssues,
@@ -7156,7 +7190,9 @@ var FileSystemTaskProvider = class {
   }
   async findTask(taskId) {
     const files = await fs.readdir(this.tasksDirectory);
-    const taskFile = files.find((file) => file.startsWith(`task-${taskId}-`) && file.endsWith(".md"));
+    const taskFile = files.find(
+      (file) => file.startsWith(`task-${taskId}-`) && file.endsWith(".md")
+    );
     if (!taskFile) {
       return void 0;
     }
@@ -7172,8 +7208,7 @@ var FileSystemTaskProvider = class {
         const escapedName = n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
         const rx = new RegExp(`^${escapedName}:\\s*(.+)$`, "im");
         const m = content.match(rx);
-        if (m)
-          return m[1].trim();
+        if (m) return m[1].trim();
       }
       return null;
     };
@@ -7185,7 +7220,9 @@ var FileSystemTaskProvider = class {
       const assigneeValue = assigneeMatch.trim();
       assignee = this.userRegistry.resolveUser(assigneeValue);
       if (!assignee) {
-        console.warn(`[FS Provider] User "${assigneeValue}" not found in registry, creating temporary user`);
+        console.warn(
+          `[FS Provider] User "${assigneeValue}" not found in registry, creating temporary user`
+        );
         assignee = this.userRegistry.createTemporaryUser(assigneeValue);
       }
     }
@@ -7203,7 +7240,9 @@ var FileSystemTaskProvider = class {
   }
   async updateTask(task) {
     const currentContent = await fs.readFile(task.filePath, "utf-8");
-    const hasSectionMetadata = /##\s*(Status|Type|Assignee)/i.test(currentContent);
+    const hasSectionMetadata = /##\s*(Status|Type|Assignee)/i.test(
+      currentContent
+    );
     if (hasSectionMetadata) {
       const { fixTaskFile: fixTaskFile2 } = await Promise.resolve().then(() => (init_task_validator(), task_validator_exports));
       await fixTaskFile2(task.filePath);
@@ -7211,16 +7250,24 @@ var FileSystemTaskProvider = class {
     const content = await fs.readFile(task.filePath, "utf-8");
     let updatedContent;
     if (/^Status:\s*.+$/im.test(content)) {
-      updatedContent = content.replace(/^Status:\s*.+$/im, `Status: ${task.status}  `);
+      updatedContent = content.replace(
+        /^Status:\s*.+$/im,
+        `Status: ${task.status}  `
+      );
     } else {
-      updatedContent = content.replace(/(^#.*\n)/, `$1Status: ${task.status}  
-`);
+      updatedContent = content.replace(
+        /(^#.*\n)/,
+        `$1Status: ${task.status}  
+`
+      );
     }
     await fs.writeFile(task.filePath, updatedContent, "utf-8");
   }
   async getAllTasks() {
     const files = await fs.readdir(this.tasksDirectory);
-    const taskFiles = files.filter((file) => file.startsWith("task-") && file.endsWith(".md"));
+    const taskFiles = files.filter(
+      (file) => file.startsWith("task-") && file.endsWith(".md")
+    );
     const tasks = [];
     for (const file of taskFiles) {
       const filePath = path2.join(this.tasksDirectory, file);
@@ -7237,8 +7284,7 @@ var FileSystemTaskProvider = class {
           const escapedName = n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
           const rx = new RegExp(`^${escapedName}:\\s*(.+)$`, "im");
           const m = content.match(rx);
-          if (m)
-            return m[1].trim();
+          if (m) return m[1].trim();
         }
         return null;
       };
@@ -8350,7 +8396,13 @@ async function finishTask(taskId, options) {
 
 // src/commands/init.ts
 init_esm_shims();
-import { existsSync as existsSync4, mkdirSync, writeFileSync } from "fs";
+import {
+  existsSync as existsSync4,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync
+} from "fs";
 import inquirer from "inquirer";
 import { join } from "path";
 
@@ -8634,7 +8686,7 @@ async function initializeTaskin(options) {
   success(`\u2713 Created ${colors2.highlight(".taskin.json")}`);
   const gitignorePath = join(cwd, ".gitignore");
   if (existsSync4(gitignorePath)) {
-    const gitignoreContent = __require("fs").readFileSync(gitignorePath, "utf-8");
+    const gitignoreContent = readFileSync(gitignorePath, "utf-8");
     if (!gitignoreContent.includes(".taskin.json")) {
       info("Adding .taskin.json to .gitignore...");
       writeFileSync(
@@ -8697,8 +8749,7 @@ async function setupFileSystemProvider(cwd) {
     info(`${colors2.highlight("TASKS/")} directory already exists`);
     success("\u2713 Directory is ready to use");
   }
-  const fs3 = __require("fs");
-  const existingTask001 = fs3.readdirSync(tasksDir).find(
+  const existingTask001 = readdirSync(tasksDir).find(
     (file) => file.startsWith("task-001-") && file.endsWith(".md")
   );
   if (existingTask001) {
@@ -8926,67 +8977,173 @@ init_esm_shims();
 // ../task-server-mcp/dist/task-server-mcp.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.21.1/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.21.1/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
 init_esm_shims();
+import * as z3rt from "zod/v3";
+import * as z4mini from "zod/v4-mini";
+function isZ4Schema(s) {
+  const schema = s;
+  return !!schema._zod;
+}
+function safeParse2(schema, data) {
+  if (isZ4Schema(schema)) {
+    const result2 = z4mini.safeParse(schema, data);
+    return result2;
+  }
+  const v3Schema = schema;
+  const result = v3Schema.safeParse(data);
+  return result;
+}
+function getObjectShape(schema) {
+  if (!schema)
+    return void 0;
+  let rawShape;
+  if (isZ4Schema(schema)) {
+    const v4Schema = schema;
+    rawShape = v4Schema._zod?.def?.shape;
+  } else {
+    const v3Schema = schema;
+    rawShape = v3Schema.shape;
+  }
+  if (!rawShape)
+    return void 0;
+  if (typeof rawShape === "function") {
+    try {
+      return rawShape();
+    } catch {
+      return void 0;
+    }
+  }
+  return rawShape;
+}
+function getLiteralValue(schema) {
+  if (isZ4Schema(schema)) {
+    const v4Schema = schema;
+    const def2 = v4Schema._zod?.def;
+    if (def2) {
+      if (def2.value !== void 0)
+        return def2.value;
+      if (Array.isArray(def2.values) && def2.values.length > 0) {
+        return def2.values[0];
+      }
+    }
+  }
+  const v3Schema = schema;
+  const def = v3Schema._def;
+  if (def) {
+    if (def.value !== void 0)
+      return def.value;
+    if (Array.isArray(def.values) && def.values.length > 0) {
+      return def.values[0];
+    }
+  }
+  const directValue = schema.value;
+  if (directValue !== void 0)
+    return directValue;
+  return void 0;
+}
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.21.1/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
 init_esm_shims();
-import { z as z2 } from "zod";
-var LATEST_PROTOCOL_VERSION = "2025-06-18";
-var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-03-26", "2024-11-05", "2024-10-07"];
+import * as z2 from "zod/v4";
+var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
+var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
 var JSONRPC_VERSION = "2.0";
+var AssertObjectSchema = z2.custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
 var ProgressTokenSchema = z2.union([z2.string(), z2.number().int()]);
 var CursorSchema = z2.string();
-var RequestMetaSchema = z2.object({
+var TaskCreationParamsSchema = z2.looseObject({
+  /**
+   * Time in milliseconds to keep task results available after completion.
+   * If null, the task has unlimited lifetime until manually cleaned up.
+   */
+  ttl: z2.union([z2.number(), z2.null()]).optional(),
+  /**
+   * Time in milliseconds to wait between task status requests.
+   */
+  pollInterval: z2.number().optional()
+});
+var TaskMetadataSchema = z2.object({
+  ttl: z2.number().optional()
+});
+var RelatedTaskMetadataSchema = z2.object({
+  taskId: z2.string()
+});
+var RequestMetaSchema = z2.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: z2.optional(ProgressTokenSchema)
-}).passthrough();
+  progressToken: ProgressTokenSchema.optional(),
+  /**
+   * If specified, this request is related to the provided task.
+   */
+  [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
+});
 var BaseRequestParamsSchema = z2.object({
-  _meta: z2.optional(RequestMetaSchema)
-}).passthrough();
+  /**
+   * See [General fields: `_meta`](/specification/draft/basic/index#meta) for notes on `_meta` usage.
+   */
+  _meta: RequestMetaSchema.optional()
+});
+var TaskAugmentedRequestParamsSchema = BaseRequestParamsSchema.extend({
+  /**
+   * If specified, the caller is requesting task-augmented execution for this request.
+   * The request will return a CreateTaskResult immediately, and the actual result can be
+   * retrieved later via tasks/result.
+   *
+   * Task augmentation is subject to capability negotiation - receivers MUST declare support
+   * for task augmentation of specific request types in their capabilities.
+   */
+  task: TaskMetadataSchema.optional()
+});
+var isTaskAugmentedRequestParams = (value) => TaskAugmentedRequestParamsSchema.safeParse(value).success;
 var RequestSchema = z2.object({
   method: z2.string(),
-  params: z2.optional(BaseRequestParamsSchema)
+  params: BaseRequestParamsSchema.loose().optional()
 });
-var BaseNotificationParamsSchema = z2.object({
+var NotificationsParamsSchema = z2.object({
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z2.optional(z2.object({}).passthrough())
-}).passthrough();
+  _meta: RequestMetaSchema.optional()
+});
 var NotificationSchema = z2.object({
   method: z2.string(),
-  params: z2.optional(BaseNotificationParamsSchema)
+  params: NotificationsParamsSchema.loose().optional()
 });
-var ResultSchema = z2.object({
+var ResultSchema = z2.looseObject({
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z2.optional(z2.object({}).passthrough())
-}).passthrough();
+  _meta: RequestMetaSchema.optional()
+});
 var RequestIdSchema = z2.union([z2.string(), z2.number().int()]);
 var JSONRPCRequestSchema = z2.object({
   jsonrpc: z2.literal(JSONRPC_VERSION),
-  id: RequestIdSchema
-}).merge(RequestSchema).strict();
+  id: RequestIdSchema,
+  ...RequestSchema.shape
+}).strict();
 var isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success;
 var JSONRPCNotificationSchema = z2.object({
-  jsonrpc: z2.literal(JSONRPC_VERSION)
-}).merge(NotificationSchema).strict();
+  jsonrpc: z2.literal(JSONRPC_VERSION),
+  ...NotificationSchema.shape
+}).strict();
 var isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success;
-var JSONRPCResponseSchema = z2.object({
+var JSONRPCResultResponseSchema = z2.object({
   jsonrpc: z2.literal(JSONRPC_VERSION),
   id: RequestIdSchema,
   result: ResultSchema
 }).strict();
-var isJSONRPCResponse = (value) => JSONRPCResponseSchema.safeParse(value).success;
+var isJSONRPCResultResponse = (value) => JSONRPCResultResponseSchema.safeParse(value).success;
 var ErrorCode;
 (function(ErrorCode2) {
   ErrorCode2[ErrorCode2["ConnectionClosed"] = -32e3] = "ConnectionClosed";
@@ -8996,10 +9153,11 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["MethodNotFound"] = -32601] = "MethodNotFound";
   ErrorCode2[ErrorCode2["InvalidParams"] = -32602] = "InvalidParams";
   ErrorCode2[ErrorCode2["InternalError"] = -32603] = "InternalError";
+  ErrorCode2[ErrorCode2["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
 })(ErrorCode || (ErrorCode = {}));
-var JSONRPCErrorSchema = z2.object({
+var JSONRPCErrorResponseSchema = z2.object({
   jsonrpc: z2.literal(JSONRPC_VERSION),
-  id: RequestIdSchema,
+  id: RequestIdSchema.optional(),
   error: z2.object({
     /**
      * The error type that occurred.
@@ -9012,26 +9170,33 @@ var JSONRPCErrorSchema = z2.object({
     /**
      * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.).
      */
-    data: z2.optional(z2.unknown())
+    data: z2.unknown().optional()
   })
 }).strict();
-var isJSONRPCError = (value) => JSONRPCErrorSchema.safeParse(value).success;
-var JSONRPCMessageSchema = z2.union([JSONRPCRequestSchema, JSONRPCNotificationSchema, JSONRPCResponseSchema, JSONRPCErrorSchema]);
+var isJSONRPCErrorResponse = (value) => JSONRPCErrorResponseSchema.safeParse(value).success;
+var JSONRPCMessageSchema = z2.union([
+  JSONRPCRequestSchema,
+  JSONRPCNotificationSchema,
+  JSONRPCResultResponseSchema,
+  JSONRPCErrorResponseSchema
+]);
+var JSONRPCResponseSchema = z2.union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
 var EmptyResultSchema = ResultSchema.strict();
+var CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
+  /**
+   * The ID of the request to cancel.
+   *
+   * This MUST correspond to the ID of a request previously issued in the same direction.
+   */
+  requestId: RequestIdSchema.optional(),
+  /**
+   * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user.
+   */
+  reason: z2.string().optional()
+});
 var CancelledNotificationSchema = NotificationSchema.extend({
   method: z2.literal("notifications/cancelled"),
-  params: BaseNotificationParamsSchema.extend({
-    /**
-     * The ID of the request to cancel.
-     *
-     * This MUST correspond to the ID of a request previously issued in the same direction.
-     */
-    requestId: RequestIdSchema,
-    /**
-     * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user.
-     */
-    reason: z2.string().optional()
-  })
+  params: CancelledNotificationParamsSchema
 });
 var IconSchema = z2.object({
   /**
@@ -9041,15 +9206,23 @@ var IconSchema = z2.object({
   /**
    * Optional MIME type for the icon.
    */
-  mimeType: z2.optional(z2.string()),
+  mimeType: z2.string().optional(),
   /**
    * Optional array of strings that specify sizes at which the icon can be used.
    * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
    *
    * If not provided, the client should assume that the icon can be used at any size.
    */
-  sizes: z2.optional(z2.array(z2.string()))
-}).passthrough();
+  sizes: z2.array(z2.string()).optional(),
+  /**
+   * Optional specifier for the theme this icon is designed for. `light` indicates
+   * the icon is designed to be used with a light background, and `dark` indicates
+   * the icon is designed to be used with a dark background.
+   *
+   * If not provided, the client should assume the icon can be used with any theme.
+   */
+  theme: z2.enum(["light", "dark"]).optional()
+});
 var IconsSchema = z2.object({
   /**
    * Optional set of sized icons that the client can display in a user interface.
@@ -9063,7 +9236,7 @@ var IconsSchema = z2.object({
    * - `image/webp` - WebP images (modern, efficient format)
    */
   icons: z2.array(IconSchema).optional()
-}).passthrough();
+});
 var BaseMetadataSchema = z2.object({
   /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
   name: z2.string(),
@@ -9075,94 +9248,185 @@ var BaseMetadataSchema = z2.object({
    * where `annotations.title` should be given precedence over using `name`,
    * if present).
    */
-  title: z2.optional(z2.string())
-}).passthrough();
+  title: z2.string().optional()
+});
 var ImplementationSchema = BaseMetadataSchema.extend({
+  ...BaseMetadataSchema.shape,
+  ...IconsSchema.shape,
   version: z2.string(),
   /**
    * An optional URL of the website for this implementation.
    */
-  websiteUrl: z2.optional(z2.string())
-}).merge(IconsSchema);
+  websiteUrl: z2.string().optional(),
+  /**
+   * An optional human-readable description of what this implementation does.
+   *
+   * This can be used by clients or servers to provide context about their purpose
+   * and capabilities. For example, a server might describe the types of resources
+   * or tools it provides, while a client might describe its intended use case.
+   */
+  description: z2.string().optional()
+});
+var FormElicitationCapabilitySchema = z2.intersection(z2.object({
+  applyDefaults: z2.boolean().optional()
+}), z2.record(z2.string(), z2.unknown()));
+var ElicitationCapabilitySchema = z2.preprocess((value) => {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    if (Object.keys(value).length === 0) {
+      return { form: {} };
+    }
+  }
+  return value;
+}, z2.intersection(z2.object({
+  form: FormElicitationCapabilitySchema.optional(),
+  url: AssertObjectSchema.optional()
+}), z2.record(z2.string(), z2.unknown()).optional()));
+var ClientTasksCapabilitySchema = z2.looseObject({
+  /**
+   * Present if the client supports listing tasks.
+   */
+  list: AssertObjectSchema.optional(),
+  /**
+   * Present if the client supports cancelling tasks.
+   */
+  cancel: AssertObjectSchema.optional(),
+  /**
+   * Capabilities for task creation on specific request types.
+   */
+  requests: z2.looseObject({
+    /**
+     * Task support for sampling requests.
+     */
+    sampling: z2.looseObject({
+      createMessage: AssertObjectSchema.optional()
+    }).optional(),
+    /**
+     * Task support for elicitation requests.
+     */
+    elicitation: z2.looseObject({
+      create: AssertObjectSchema.optional()
+    }).optional()
+  }).optional()
+});
+var ServerTasksCapabilitySchema = z2.looseObject({
+  /**
+   * Present if the server supports listing tasks.
+   */
+  list: AssertObjectSchema.optional(),
+  /**
+   * Present if the server supports cancelling tasks.
+   */
+  cancel: AssertObjectSchema.optional(),
+  /**
+   * Capabilities for task creation on specific request types.
+   */
+  requests: z2.looseObject({
+    /**
+     * Task support for tool requests.
+     */
+    tools: z2.looseObject({
+      call: AssertObjectSchema.optional()
+    }).optional()
+  }).optional()
+});
 var ClientCapabilitiesSchema = z2.object({
   /**
    * Experimental, non-standard capabilities that the client supports.
    */
-  experimental: z2.optional(z2.object({}).passthrough()),
+  experimental: z2.record(z2.string(), AssertObjectSchema).optional(),
   /**
    * Present if the client supports sampling from an LLM.
    */
-  sampling: z2.optional(z2.object({}).passthrough()),
+  sampling: z2.object({
+    /**
+     * Present if the client supports context inclusion via includeContext parameter.
+     * If not declared, servers SHOULD only use `includeContext: "none"` (or omit it).
+     */
+    context: AssertObjectSchema.optional(),
+    /**
+     * Present if the client supports tool use via tools and toolChoice parameters.
+     */
+    tools: AssertObjectSchema.optional()
+  }).optional(),
   /**
    * Present if the client supports eliciting user input.
    */
-  elicitation: z2.optional(z2.object({}).passthrough()),
+  elicitation: ElicitationCapabilitySchema.optional(),
   /**
    * Present if the client supports listing roots.
    */
-  roots: z2.optional(z2.object({
+  roots: z2.object({
     /**
      * Whether the client supports issuing notifications for changes to the roots list.
      */
-    listChanged: z2.optional(z2.boolean())
-  }).passthrough())
-}).passthrough();
+    listChanged: z2.boolean().optional()
+  }).optional(),
+  /**
+   * Present if the client supports task creation.
+   */
+  tasks: ClientTasksCapabilitySchema.optional()
+});
+var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
+  /**
+   * The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well.
+   */
+  protocolVersion: z2.string(),
+  capabilities: ClientCapabilitiesSchema,
+  clientInfo: ImplementationSchema
+});
 var InitializeRequestSchema = RequestSchema.extend({
   method: z2.literal("initialize"),
-  params: BaseRequestParamsSchema.extend({
-    /**
-     * The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well.
-     */
-    protocolVersion: z2.string(),
-    capabilities: ClientCapabilitiesSchema,
-    clientInfo: ImplementationSchema
-  })
+  params: InitializeRequestParamsSchema
 });
 var ServerCapabilitiesSchema = z2.object({
   /**
    * Experimental, non-standard capabilities that the server supports.
    */
-  experimental: z2.optional(z2.object({}).passthrough()),
+  experimental: z2.record(z2.string(), AssertObjectSchema).optional(),
   /**
    * Present if the server supports sending log messages to the client.
    */
-  logging: z2.optional(z2.object({}).passthrough()),
+  logging: AssertObjectSchema.optional(),
   /**
    * Present if the server supports sending completions to the client.
    */
-  completions: z2.optional(z2.object({}).passthrough()),
+  completions: AssertObjectSchema.optional(),
   /**
    * Present if the server offers any prompt templates.
    */
-  prompts: z2.optional(z2.object({
+  prompts: z2.object({
     /**
      * Whether this server supports issuing notifications for changes to the prompt list.
      */
-    listChanged: z2.optional(z2.boolean())
-  }).passthrough()),
+    listChanged: z2.boolean().optional()
+  }).optional(),
   /**
    * Present if the server offers any resources to read.
    */
-  resources: z2.optional(z2.object({
+  resources: z2.object({
     /**
      * Whether this server supports clients subscribing to resource updates.
      */
-    subscribe: z2.optional(z2.boolean()),
+    subscribe: z2.boolean().optional(),
     /**
      * Whether this server supports issuing notifications for changes to the resource list.
      */
-    listChanged: z2.optional(z2.boolean())
-  }).passthrough()),
+    listChanged: z2.boolean().optional()
+  }).optional(),
   /**
    * Present if the server offers any tools to call.
    */
-  tools: z2.optional(z2.object({
+  tools: z2.object({
     /**
      * Whether this server supports issuing notifications for changes to the tool list.
      */
-    listChanged: z2.optional(z2.boolean())
-  }).passthrough())
-}).passthrough();
+    listChanged: z2.boolean().optional()
+  }).optional(),
+  /**
+   * Present if the server supports task creation.
+   */
+  tasks: ServerTasksCapabilitySchema.optional()
+});
 var 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.
@@ -9175,13 +9439,15 @@ var InitializeResultSchema = ResultSchema.extend({
    *
    * This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt.
    */
-  instructions: z2.optional(z2.string())
+  instructions: z2.string().optional()
 });
 var InitializedNotificationSchema = NotificationSchema.extend({
-  method: z2.literal("notifications/initialized")
+  method: z2.literal("notifications/initialized"),
+  params: NotificationsParamsSchema.optional()
 });
 var PingRequestSchema = RequestSchema.extend({
-  method: z2.literal("ping")
+  method: z2.literal("ping"),
+  params: BaseRequestParamsSchema.optional()
 });
 var ProgressSchema = z2.object({
   /**
@@ -9196,32 +9462,94 @@ var ProgressSchema = z2.object({
    * An optional message describing the current progress.
    */
   message: z2.optional(z2.string())
-}).passthrough();
+});
+var ProgressNotificationParamsSchema = z2.object({
+  ...NotificationsParamsSchema.shape,
+  ...ProgressSchema.shape,
+  /**
+   * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.
+   */
+  progressToken: ProgressTokenSchema
+});
 var ProgressNotificationSchema = NotificationSchema.extend({
   method: z2.literal("notifications/progress"),
-  params: BaseNotificationParamsSchema.merge(ProgressSchema).extend({
-    /**
-     * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.
-     */
-    progressToken: ProgressTokenSchema
-  })
+  params: ProgressNotificationParamsSchema
+});
+var PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({
+  /**
+   * An opaque token representing the current pagination position.
+   * If provided, the server should return results starting after this cursor.
+   */
+  cursor: CursorSchema.optional()
 });
 var PaginatedRequestSchema = RequestSchema.extend({
-  params: BaseRequestParamsSchema.extend({
-    /**
-     * An opaque token representing the current pagination position.
-     * If provided, the server should return results starting after this cursor.
-     */
-    cursor: z2.optional(CursorSchema)
-  }).optional()
+  params: PaginatedRequestParamsSchema.optional()
 });
 var PaginatedResultSchema = ResultSchema.extend({
   /**
    * An opaque token representing the pagination position after the last returned result.
    * If present, there may be more results available.
    */
-  nextCursor: z2.optional(CursorSchema)
+  nextCursor: CursorSchema.optional()
+});
+var TaskStatusSchema = z2.enum(["working", "input_required", "completed", "failed", "cancelled"]);
+var TaskSchema = z2.object({
+  taskId: z2.string(),
+  status: TaskStatusSchema,
+  /**
+   * Time in milliseconds to keep task results available after completion.
+   * If null, the task has unlimited lifetime until manually cleaned up.
+   */
+  ttl: z2.union([z2.number(), z2.null()]),
+  /**
+   * ISO 8601 timestamp when the task was created.
+   */
+  createdAt: z2.string(),
+  /**
+   * ISO 8601 timestamp when the task was last updated.
+   */
+  lastUpdatedAt: z2.string(),
+  pollInterval: z2.optional(z2.number()),
+  /**
+   * Optional diagnostic message for failed tasks or other status information.
+   */
+  statusMessage: z2.optional(z2.string())
+});
+var CreateTaskResultSchema = ResultSchema.extend({
+  task: TaskSchema
+});
+var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema);
+var TaskStatusNotificationSchema = NotificationSchema.extend({
+  method: z2.literal("notifications/tasks/status"),
+  params: TaskStatusNotificationParamsSchema
+});
+var GetTaskRequestSchema = RequestSchema.extend({
+  method: z2.literal("tasks/get"),
+  params: BaseRequestParamsSchema.extend({
+    taskId: z2.string()
+  })
+});
+var GetTaskResultSchema = ResultSchema.merge(TaskSchema);
+var GetTaskPayloadRequestSchema = RequestSchema.extend({
+  method: z2.literal("tasks/result"),
+  params: BaseRequestParamsSchema.extend({
+    taskId: z2.string()
+  })
+});
+var GetTaskPayloadResultSchema = ResultSchema.loose();
+var ListTasksRequestSchema = PaginatedRequestSchema.extend({
+  method: z2.literal("tasks/list")
+});
+var ListTasksResultSchema = PaginatedResultSchema.extend({
+  tasks: z2.array(TaskSchema)
 });
+var CancelTaskRequestSchema = RequestSchema.extend({
+  method: z2.literal("tasks/cancel"),
+  params: BaseRequestParamsSchema.extend({
+    taskId: z2.string()
+  })
+});
+var CancelTaskResultSchema = ResultSchema.merge(TaskSchema);
 var ResourceContentsSchema = z2.object({
   /**
    * The URI of this resource.
@@ -9235,8 +9563,8 @@ var ResourceContentsSchema = z2.object({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z2.optional(z2.object({}).passthrough())
-}).passthrough();
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+});
 var TextResourceContentsSchema = ResourceContentsSchema.extend({
   /**
    * The text of the item. This must only be set if the item can actually be represented as text (not binary data).
@@ -9247,7 +9575,7 @@ var Base64Schema = z2.string().refine((val) => {
   try {
     atob(val);
     return true;
-  } catch (_a) {
+  } catch {
     return false;
   }
 }, { message: "Invalid Base64 string" });
@@ -9257,7 +9585,24 @@ var BlobResourceContentsSchema = ResourceContentsSchema.extend({
    */
   blob: Base64Schema
 });
-var ResourceSchema = BaseMetadataSchema.extend({
+var RoleSchema = z2.enum(["user", "assistant"]);
+var AnnotationsSchema = z2.object({
+  /**
+   * Intended audience(s) for the resource.
+   */
+  audience: z2.array(RoleSchema).optional(),
+  /**
+   * Importance hint for the resource, from 0 (least) to 1 (most).
+   */
+  priority: z2.number().min(0).max(1).optional(),
+  /**
+   * ISO 8601 timestamp for the most recent modification.
+   */
+  lastModified: z2.iso.datetime({ offset: true }).optional()
+});
+var ResourceSchema = z2.object({
+  ...BaseMetadataSchema.shape,
+  ...IconsSchema.shape,
   /**
    * The URI of this resource.
    */
@@ -9272,13 +9617,19 @@ var ResourceSchema = BaseMetadataSchema.extend({
    * The MIME type of this resource, if known.
    */
   mimeType: z2.optional(z2.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.
    */
-  _meta: z2.optional(z2.object({}).passthrough())
-}).merge(IconsSchema);
-var ResourceTemplateSchema = BaseMetadataSchema.extend({
+  _meta: z2.optional(z2.looseObject({}))
+});
+var ResourceTemplateSchema = z2.object({
+  ...BaseMetadataSchema.shape,
+  ...IconsSchema.shape,
   /**
    * A URI template (according to RFC 6570) that can be used to construct resource URIs.
    */
@@ -9293,12 +9644,16 @@ var ResourceTemplateSchema = BaseMetadataSchema.extend({
    * 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: z2.optional(z2.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.
    */
-  _meta: z2.optional(z2.object({}).passthrough())
-}).merge(IconsSchema);
+  _meta: z2.optional(z2.looseObject({}))
+});
 var ListResourcesRequestSchema = PaginatedRequestSchema.extend({
   method: z2.literal("resources/list")
 });
@@ -9311,47 +9666,45 @@ var ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({
 var ListResourceTemplatesResultSchema = PaginatedResultSchema.extend({
   resourceTemplates: z2.array(ResourceTemplateSchema)
 });
+var ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({
+  /**
+   * The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it.
+   *
+   * @format uri
+   */
+  uri: z2.string()
+});
+var ReadResourceRequestParamsSchema = ResourceRequestParamsSchema;
 var ReadResourceRequestSchema = RequestSchema.extend({
   method: z2.literal("resources/read"),
-  params: BaseRequestParamsSchema.extend({
-    /**
-     * The URI of the resource to read. The URI can use any protocol; it is up to the server how to interpret it.
-     */
-    uri: z2.string()
-  })
+  params: ReadResourceRequestParamsSchema
 });
 var ReadResourceResultSchema = ResultSchema.extend({
   contents: z2.array(z2.union([TextResourceContentsSchema, BlobResourceContentsSchema]))
 });
 var ResourceListChangedNotificationSchema = NotificationSchema.extend({
-  method: z2.literal("notifications/resources/list_changed")
+  method: z2.literal("notifications/resources/list_changed"),
+  params: NotificationsParamsSchema.optional()
 });
+var SubscribeRequestParamsSchema = ResourceRequestParamsSchema;
 var SubscribeRequestSchema = RequestSchema.extend({
   method: z2.literal("resources/subscribe"),
-  params: BaseRequestParamsSchema.extend({
-    /**
-     * The URI of the resource to subscribe to. The URI can use any protocol; it is up to the server how to interpret it.
-     */
-    uri: z2.string()
-  })
+  params: SubscribeRequestParamsSchema
 });
+var UnsubscribeRequestParamsSchema = ResourceRequestParamsSchema;
 var UnsubscribeRequestSchema = RequestSchema.extend({
   method: z2.literal("resources/unsubscribe"),
-  params: BaseRequestParamsSchema.extend({
-    /**
-     * The URI of the resource to unsubscribe from.
-     */
-    uri: z2.string()
-  })
+  params: UnsubscribeRequestParamsSchema
+});
+var ResourceUpdatedNotificationParamsSchema = NotificationsParamsSchema.extend({
+  /**
+   * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to.
+   */
+  uri: z2.string()
 });
 var ResourceUpdatedNotificationSchema = NotificationSchema.extend({
   method: z2.literal("notifications/resources/updated"),
-  params: BaseNotificationParamsSchema.extend({
-    /**
-     * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to.
-     */
-    uri: z2.string()
-  })
+  params: ResourceUpdatedNotificationParamsSchema
 });
 var PromptArgumentSchema = z2.object({
   /**
@@ -9366,8 +9719,10 @@ var PromptArgumentSchema = z2.object({
    * Whether this argument must be provided.
    */
   required: z2.optional(z2.boolean())
-}).passthrough();
-var PromptSchema = BaseMetadataSchema.extend({
+});
+var PromptSchema = z2.object({
+  ...BaseMetadataSchema.shape,
+  ...IconsSchema.shape,
   /**
    * An optional description of what this prompt provides
    */
@@ -9380,26 +9735,27 @@ var PromptSchema = BaseMetadataSchema.extend({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z2.optional(z2.object({}).passthrough())
-}).merge(IconsSchema);
+  _meta: z2.optional(z2.looseObject({}))
+});
 var ListPromptsRequestSchema = PaginatedRequestSchema.extend({
   method: z2.literal("prompts/list")
 });
 var ListPromptsResultSchema = PaginatedResultSchema.extend({
   prompts: z2.array(PromptSchema)
 });
+var GetPromptRequestParamsSchema = BaseRequestParamsSchema.extend({
+  /**
+   * The name of the prompt or prompt template.
+   */
+  name: z2.string(),
+  /**
+   * Arguments to use for templating the prompt.
+   */
+  arguments: z2.record(z2.string(), z2.string()).optional()
+});
 var GetPromptRequestSchema = RequestSchema.extend({
   method: z2.literal("prompts/get"),
-  params: BaseRequestParamsSchema.extend({
-    /**
-     * The name of the prompt or prompt template.
-     */
-    name: z2.string(),
-    /**
-     * Arguments to use for templating the prompt.
-     */
-    arguments: z2.optional(z2.record(z2.string()))
-  })
+  params: GetPromptRequestParamsSchema
 });
 var TextContentSchema = z2.object({
   type: z2.literal("text"),
@@ -9407,12 +9763,16 @@ var TextContentSchema = z2.object({
    * The text content of the message.
    */
   text: z2.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.
    */
-  _meta: z2.optional(z2.object({}).passthrough())
-}).passthrough();
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+});
 var ImageContentSchema = z2.object({
   type: z2.literal("image"),
   /**
@@ -9423,12 +9783,16 @@ var ImageContentSchema = z2.object({
    * The MIME type of the image. Different providers may support different image types.
    */
   mimeType: z2.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.
    */
-  _meta: z2.optional(z2.object({}).passthrough())
-}).passthrough();
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+});
 var AudioContentSchema = z2.object({
   type: z2.literal("audio"),
   /**
@@ -9439,21 +9803,52 @@ var AudioContentSchema = z2.object({
    * The MIME type of the audio. Different providers may support different audio types.
    */
   mimeType: z2.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.
+   */
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+});
+var ToolUseContentSchema = z2.object({
+  type: z2.literal("tool_use"),
+  /**
+   * The name of the tool to invoke.
+   * Must match a tool name from the request's tools array.
+   */
+  name: z2.string(),
+  /**
+   * Unique identifier for this tool call.
+   * Used to correlate with ToolResultContent in subsequent messages.
+   */
+  id: z2.string(),
+  /**
+   * Arguments to pass to the tool.
+   * Must conform to the tool's inputSchema.
+   */
+  input: z2.record(z2.string(), z2.unknown()),
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z2.optional(z2.object({}).passthrough())
-}).passthrough();
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+});
 var EmbeddedResourceSchema = z2.object({
   type: z2.literal("resource"),
   resource: z2.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.
    */
-  _meta: z2.optional(z2.object({}).passthrough())
-}).passthrough();
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+});
 var ResourceLinkSchema = ResourceSchema.extend({
   type: z2.literal("resource_link")
 });
@@ -9465,30 +9860,31 @@ var ContentBlockSchema = z2.union([
   EmbeddedResourceSchema
 ]);
 var PromptMessageSchema = z2.object({
-  role: z2.enum(["user", "assistant"]),
+  role: RoleSchema,
   content: ContentBlockSchema
-}).passthrough();
+});
 var GetPromptResultSchema = ResultSchema.extend({
   /**
    * An optional description for the prompt.
    */
-  description: z2.optional(z2.string()),
+  description: z2.string().optional(),
   messages: z2.array(PromptMessageSchema)
 });
 var PromptListChangedNotificationSchema = NotificationSchema.extend({
-  method: z2.literal("notifications/prompts/list_changed")
+  method: z2.literal("notifications/prompts/list_changed"),
+  params: NotificationsParamsSchema.optional()
 });
 var ToolAnnotationsSchema = z2.object({
   /**
    * A human-readable title for the tool.
    */
-  title: z2.optional(z2.string()),
+  title: z2.string().optional(),
   /**
    * If true, the tool does not modify its environment.
    *
    * Default: false
    */
-  readOnlyHint: z2.optional(z2.boolean()),
+  readOnlyHint: z2.boolean().optional(),
   /**
    * If true, the tool may perform destructive updates to its environment.
    * If false, the tool performs only additive updates.
@@ -9497,7 +9893,7 @@ var ToolAnnotationsSchema = z2.object({
    *
    * Default: true
    */
-  destructiveHint: z2.optional(z2.boolean()),
+  destructiveHint: z2.boolean().optional(),
   /**
    * If true, calling the tool repeatedly with the same arguments
    * will have no additional effect on the its environment.
@@ -9506,7 +9902,7 @@ var ToolAnnotationsSchema = z2.object({
    *
    * Default: false
    */
-  idempotentHint: z2.optional(z2.boolean()),
+  idempotentHint: z2.boolean().optional(),
   /**
    * If true, this tool may interact with an "open world" of external
    * entities. If false, the tool's domain of interaction is closed.
@@ -9515,40 +9911,59 @@ var ToolAnnotationsSchema = z2.object({
    *
    * Default: true
    */
-  openWorldHint: z2.optional(z2.boolean())
-}).passthrough();
-var ToolSchema = BaseMetadataSchema.extend({
+  openWorldHint: z2.boolean().optional()
+});
+var ToolExecutionSchema = z2.object({
+  /**
+   * 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: z2.enum(["required", "optional", "forbidden"]).optional()
+});
+var ToolSchema = z2.object({
+  ...BaseMetadataSchema.shape,
+  ...IconsSchema.shape,
   /**
    * A human-readable description of the tool.
    */
-  description: z2.optional(z2.string()),
+  description: z2.string().optional(),
   /**
-   * A JSON Schema object defining the expected parameters for the tool.
+   * A JSON Schema 2020-12 object defining the expected parameters for the tool.
+   * Must have type: 'object' at the root level per MCP spec.
    */
   inputSchema: z2.object({
     type: z2.literal("object"),
-    properties: z2.optional(z2.object({}).passthrough()),
-    required: z2.optional(z2.array(z2.string()))
-  }).passthrough(),
+    properties: z2.record(z2.string(), AssertObjectSchema).optional(),
+    required: z2.array(z2.string()).optional()
+  }).catchall(z2.unknown()),
   /**
-   * An optional JSON Schema object defining the structure of the tool's output returned in
-   * the structuredContent field of a CallToolResult.
+   * An optional JSON Schema 2020-12 object defining the structure of the tool's output
+   * returned in the structuredContent field of a CallToolResult.
+   * Must have type: 'object' at the root level per MCP spec.
    */
-  outputSchema: z2.optional(z2.object({
+  outputSchema: z2.object({
     type: z2.literal("object"),
-    properties: z2.optional(z2.object({}).passthrough()),
-    required: z2.optional(z2.array(z2.string()))
-  }).passthrough()),
+    properties: z2.record(z2.string(), AssertObjectSchema).optional(),
+    required: z2.array(z2.string()).optional()
+  }).catchall(z2.unknown()).optional(),
   /**
    * Optional additional tool information.
    */
-  annotations: z2.optional(ToolAnnotationsSchema),
+  annotations: ToolAnnotationsSchema.optional(),
+  /**
+   * Execution-related properties for this tool.
+   */
+  execution: ToolExecutionSchema.optional(),
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z2.optional(z2.object({}).passthrough())
-}).merge(IconsSchema);
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+});
 var ListToolsRequestSchema = PaginatedRequestSchema.extend({
   method: z2.literal("tools/list")
 });
@@ -9568,7 +9983,7 @@ var CallToolResultSchema = ResultSchema.extend({
    *
    * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
    */
-  structuredContent: z2.object({}).passthrough().optional(),
+  structuredContent: z2.record(z2.string(), z2.unknown()).optional(),
   /**
    * Whether the tool call ended in an error.
    *
@@ -9583,103 +9998,185 @@ var CallToolResultSchema = ResultSchema.extend({
    * server does not support tool calls, or any other exceptional conditions,
    * should be reported as an MCP error response.
    */
-  isError: z2.optional(z2.boolean())
+  isError: z2.boolean().optional()
 });
 var CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({
   toolResult: z2.unknown()
 }));
+var CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
+  /**
+   * The name of the tool to call.
+   */
+  name: z2.string(),
+  /**
+   * Arguments to pass to the tool.
+   */
+  arguments: z2.record(z2.string(), z2.unknown()).optional()
+});
 var CallToolRequestSchema = RequestSchema.extend({
   method: z2.literal("tools/call"),
-  params: BaseRequestParamsSchema.extend({
-    name: z2.string(),
-    arguments: z2.optional(z2.record(z2.unknown()))
-  })
+  params: CallToolRequestParamsSchema
 });
 var ToolListChangedNotificationSchema = NotificationSchema.extend({
-  method: z2.literal("notifications/tools/list_changed")
+  method: z2.literal("notifications/tools/list_changed"),
+  params: NotificationsParamsSchema.optional()
+});
+var ListChangedOptionsBaseSchema = z2.object({
+  /**
+   * If true, the list will be refreshed automatically when a list changed notification is received.
+   * The callback will be called with the updated list.
+   *
+   * If false, the callback will be called with null items, allowing manual refresh.
+   *
+   * @default true
+   */
+  autoRefresh: z2.boolean().default(true),
+  /**
+   * Debounce time in milliseconds for list changed notification processing.
+   *
+   * Multiple notifications received within this timeframe will only trigger one refresh.
+   * Set to 0 to disable debouncing.
+   *
+   * @default 300
+   */
+  debounceMs: z2.number().int().nonnegative().default(300)
 });
 var LoggingLevelSchema = z2.enum(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
+var SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({
+  /**
+   * The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/logging/message.
+   */
+  level: LoggingLevelSchema
+});
 var SetLevelRequestSchema = RequestSchema.extend({
   method: z2.literal("logging/setLevel"),
-  params: BaseRequestParamsSchema.extend({
-    /**
-     * The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/logging/message.
-     */
-    level: LoggingLevelSchema
-  })
+  params: SetLevelRequestParamsSchema
+});
+var LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({
+  /**
+   * The severity of this log message.
+   */
+  level: LoggingLevelSchema,
+  /**
+   * An optional name of the logger issuing this message.
+   */
+  logger: z2.string().optional(),
+  /**
+   * The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here.
+   */
+  data: z2.unknown()
 });
 var LoggingMessageNotificationSchema = NotificationSchema.extend({
   method: z2.literal("notifications/message"),
-  params: BaseNotificationParamsSchema.extend({
-    /**
-     * The severity of this log message.
-     */
-    level: LoggingLevelSchema,
-    /**
-     * An optional name of the logger issuing this message.
-     */
-    logger: z2.optional(z2.string()),
-    /**
-     * The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here.
-     */
-    data: z2.unknown()
-  })
+  params: LoggingMessageNotificationParamsSchema
 });
 var ModelHintSchema = z2.object({
   /**
    * A hint for a model name.
    */
   name: z2.string().optional()
-}).passthrough();
+});
 var ModelPreferencesSchema = z2.object({
   /**
    * Optional hints to use for model selection.
    */
-  hints: z2.optional(z2.array(ModelHintSchema)),
+  hints: z2.array(ModelHintSchema).optional(),
   /**
    * How much to prioritize cost when selecting a model.
    */
-  costPriority: z2.optional(z2.number().min(0).max(1)),
+  costPriority: z2.number().min(0).max(1).optional(),
   /**
    * How much to prioritize sampling speed (latency) when selecting a model.
    */
-  speedPriority: z2.optional(z2.number().min(0).max(1)),
+  speedPriority: z2.number().min(0).max(1).optional(),
   /**
    * How much to prioritize intelligence and capabilities when selecting a model.
    */
-  intelligencePriority: z2.optional(z2.number().min(0).max(1))
-}).passthrough();
+  intelligencePriority: z2.number().min(0).max(1).optional()
+});
+var ToolChoiceSchema = z2.object({
+  /**
+   * Controls when tools are used:
+   * - "auto": Model decides whether to use tools (default)
+   * - "required": Model MUST use at least one tool before completing
+   * - "none": Model MUST NOT use any tools
+   */
+  mode: z2.enum(["auto", "required", "none"]).optional()
+});
+var ToolResultContentSchema = z2.object({
+  type: z2.literal("tool_result"),
+  toolUseId: z2.string().describe("The unique identifier for the corresponding tool call."),
+  content: z2.array(ContentBlockSchema).default([]),
+  structuredContent: z2.object({}).loose().optional(),
+  isError: z2.boolean().optional(),
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+});
+var SamplingContentSchema = z2.discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]);
+var SamplingMessageContentBlockSchema = z2.discriminatedUnion("type", [
+  TextContentSchema,
+  ImageContentSchema,
+  AudioContentSchema,
+  ToolUseContentSchema,
+  ToolResultContentSchema
+]);
 var SamplingMessageSchema = z2.object({
-  role: z2.enum(["user", "assistant"]),
-  content: z2.union([TextContentSchema, ImageContentSchema, AudioContentSchema])
-}).passthrough();
+  role: RoleSchema,
+  content: z2.union([SamplingMessageContentBlockSchema, z2.array(SamplingMessageContentBlockSchema)]),
+  /**
+   * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
+   * for notes on _meta usage.
+   */
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+});
+var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
+  messages: z2.array(SamplingMessageSchema),
+  /**
+   * The server's preferences for which model to select. The client MAY modify or omit this request.
+   */
+  modelPreferences: ModelPreferencesSchema.optional(),
+  /**
+   * An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt.
+   */
+  systemPrompt: z2.string().optional(),
+  /**
+   * A request to include context from one or more MCP servers (including the caller), to be attached to the prompt.
+   * The client MAY ignore this request.
+   *
+   * Default is "none". Values "thisServer" and "allServers" are soft-deprecated. Servers SHOULD only use these values if the client
+   * declares ClientCapabilities.sampling.context. These values may be removed in future spec releases.
+   */
+  includeContext: z2.enum(["none", "thisServer", "allServers"]).optional(),
+  temperature: z2.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: z2.number().int(),
+  stopSequences: z2.array(z2.string()).optional(),
+  /**
+   * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.
+   */
+  metadata: AssertObjectSchema.optional(),
+  /**
+   * Tools that the model may use during generation.
+   * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared.
+   */
+  tools: z2.array(ToolSchema).optional(),
+  /**
+   * Controls how the model uses tools.
+   * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared.
+   * Default is `{ mode: "auto" }`.
+   */
+  toolChoice: ToolChoiceSchema.optional()
+});
 var CreateMessageRequestSchema = RequestSchema.extend({
   method: z2.literal("sampling/createMessage"),
-  params: BaseRequestParamsSchema.extend({
-    messages: z2.array(SamplingMessageSchema),
-    /**
-     * An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt.
-     */
-    systemPrompt: z2.optional(z2.string()),
-    /**
-     * A request to include context from one or more MCP servers (including the caller), to be attached to the prompt. The client MAY ignore this request.
-     */
-    includeContext: z2.optional(z2.enum(["none", "thisServer", "allServers"])),
-    temperature: z2.optional(z2.number()),
-    /**
-     * The maximum number of tokens to sample, as requested by the server. The client MAY choose to sample fewer tokens than requested.
-     */
-    maxTokens: z2.number().int(),
-    stopSequences: z2.optional(z2.array(z2.string())),
-    /**
-     * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.
-     */
-    metadata: z2.optional(z2.object({}).passthrough()),
-    /**
-     * The server's preferences for which model to select.
-     */
-    modelPreferences: z2.optional(ModelPreferencesSchema)
-  })
+  params: CreateMessageRequestParamsSchema
 });
 var CreateMessageResultSchema = ResultSchema.extend({
   /**
@@ -9687,67 +10184,193 @@ var CreateMessageResultSchema = ResultSchema.extend({
    */
   model: z2.string(),
   /**
-   * The reason why sampling stopped.
+   * 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: z2.optional(z2.enum(["endTurn", "stopSequence", "maxTokens"]).or(z2.string())),
-  role: z2.enum(["user", "assistant"]),
-  content: z2.discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema])
+  role: RoleSchema,
+  /**
+   * Response content. Single content block (text, image, or audio).
+   */
+  content: SamplingContentSchema
+});
+var CreateMessageResultWithToolsSchema = ResultSchema.extend({
+  /**
+   * The name of the model that generated the message.
+   */
+  model: z2.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
+   * - "toolUse": The model wants to use one or more tools
+   *
+   * This field is an open string to allow for provider-specific stop reasons.
+   */
+  stopReason: z2.optional(z2.enum(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(z2.string())),
+  role: RoleSchema,
+  /**
+   * Response content. May be a single block or array. May include ToolUseContent if stopReason is "toolUse".
+   */
+  content: z2.union([SamplingMessageContentBlockSchema, z2.array(SamplingMessageContentBlockSchema)])
 });
 var BooleanSchemaSchema = z2.object({
   type: z2.literal("boolean"),
-  title: z2.optional(z2.string()),
-  description: z2.optional(z2.string()),
-  default: z2.optional(z2.boolean())
-}).passthrough();
+  title: z2.string().optional(),
+  description: z2.string().optional(),
+  default: z2.boolean().optional()
+});
 var StringSchemaSchema = z2.object({
   type: z2.literal("string"),
-  title: z2.optional(z2.string()),
-  description: z2.optional(z2.string()),
-  minLength: z2.optional(z2.number()),
-  maxLength: z2.optional(z2.number()),
-  format: z2.optional(z2.enum(["email", "uri", "date", "date-time"]))
-}).passthrough();
+  title: z2.string().optional(),
+  description: z2.string().optional(),
+  minLength: z2.number().optional(),
+  maxLength: z2.number().optional(),
+  format: z2.enum(["email", "uri", "date", "date-time"]).optional(),
+  default: z2.string().optional()
+});
 var NumberSchemaSchema = z2.object({
   type: z2.enum(["number", "integer"]),
-  title: z2.optional(z2.string()),
-  description: z2.optional(z2.string()),
-  minimum: z2.optional(z2.number()),
-  maximum: z2.optional(z2.number())
-}).passthrough();
-var EnumSchemaSchema = z2.object({
+  title: z2.string().optional(),
+  description: z2.string().optional(),
+  minimum: z2.number().optional(),
+  maximum: z2.number().optional(),
+  default: z2.number().optional()
+});
+var UntitledSingleSelectEnumSchemaSchema = z2.object({
   type: z2.literal("string"),
-  title: z2.optional(z2.string()),
-  description: z2.optional(z2.string()),
+  title: z2.string().optional(),
+  description: z2.string().optional(),
+  enum: z2.array(z2.string()),
+  default: z2.string().optional()
+});
+var TitledSingleSelectEnumSchemaSchema = z2.object({
+  type: z2.literal("string"),
+  title: z2.string().optional(),
+  description: z2.string().optional(),
+  oneOf: z2.array(z2.object({
+    const: z2.string(),
+    title: z2.string()
+  })),
+  default: z2.string().optional()
+});
+var LegacyTitledEnumSchemaSchema = z2.object({
+  type: z2.literal("string"),
+  title: z2.string().optional(),
+  description: z2.string().optional(),
   enum: z2.array(z2.string()),
-  enumNames: z2.optional(z2.array(z2.string()))
-}).passthrough();
-var PrimitiveSchemaDefinitionSchema = z2.union([BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema, EnumSchemaSchema]);
+  enumNames: z2.array(z2.string()).optional(),
+  default: z2.string().optional()
+});
+var SingleSelectEnumSchemaSchema = z2.union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]);
+var UntitledMultiSelectEnumSchemaSchema = z2.object({
+  type: z2.literal("array"),
+  title: z2.string().optional(),
+  description: z2.string().optional(),
+  minItems: z2.number().optional(),
+  maxItems: z2.number().optional(),
+  items: z2.object({
+    type: z2.literal("string"),
+    enum: z2.array(z2.string())
+  }),
+  default: z2.array(z2.string()).optional()
+});
+var TitledMultiSelectEnumSchemaSchema = z2.object({
+  type: z2.literal("array"),
+  title: z2.string().optional(),
+  description: z2.string().optional(),
+  minItems: z2.number().optional(),
+  maxItems: z2.number().optional(),
+  items: z2.object({
+    anyOf: z2.array(z2.object({
+      const: z2.string(),
+      title: z2.string()
+    }))
+  }),
+  default: z2.array(z2.string()).optional()
+});
+var MultiSelectEnumSchemaSchema = z2.union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]);
+var EnumSchemaSchema = z2.union([LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema]);
+var PrimitiveSchemaDefinitionSchema = z2.union([EnumSchemaSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema]);
+var ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({
+  /**
+   * The elicitation mode.
+   *
+   * Optional for backward compatibility. Clients MUST treat missing mode as "form".
+   */
+  mode: z2.literal("form").optional(),
+  /**
+   * The message to present to the user describing what information is being requested.
+   */
+  message: z2.string(),
+  /**
+   * A restricted subset of JSON Schema.
+   * Only top-level properties are allowed, without nesting.
+   */
+  requestedSchema: z2.object({
+    type: z2.literal("object"),
+    properties: z2.record(z2.string(), PrimitiveSchemaDefinitionSchema),
+    required: z2.array(z2.string()).optional()
+  })
+});
+var ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({
+  /**
+   * The elicitation mode.
+   */
+  mode: z2.literal("url"),
+  /**
+   * The message to present to the user explaining why the interaction is needed.
+   */
+  message: z2.string(),
+  /**
+   * The ID of the elicitation, which must be unique within the context of the server.
+   * The client MUST treat this ID as an opaque value.
+   */
+  elicitationId: z2.string(),
+  /**
+   * The URL that the user should navigate to.
+   */
+  url: z2.string().url()
+});
+var ElicitRequestParamsSchema = z2.union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]);
 var ElicitRequestSchema = RequestSchema.extend({
   method: z2.literal("elicitation/create"),
-  params: BaseRequestParamsSchema.extend({
-    /**
-     * The message to present to the user.
-     */
-    message: z2.string(),
-    /**
-     * The schema for the requested user input.
-     */
-    requestedSchema: z2.object({
-      type: z2.literal("object"),
-      properties: z2.record(z2.string(), PrimitiveSchemaDefinitionSchema),
-      required: z2.optional(z2.array(z2.string()))
-    }).passthrough()
-  })
+  params: ElicitRequestParamsSchema
+});
+var ElicitationCompleteNotificationParamsSchema = NotificationsParamsSchema.extend({
+  /**
+   * The ID of the elicitation that completed.
+   */
+  elicitationId: z2.string()
+});
+var ElicitationCompleteNotificationSchema = NotificationSchema.extend({
+  method: z2.literal("notifications/elicitation/complete"),
+  params: ElicitationCompleteNotificationParamsSchema
 });
 var ElicitResultSchema = ResultSchema.extend({
   /**
-   * The user's response action.
+   * The user action in response to the elicitation.
+   * - "accept": User submitted the form/confirmed the action
+   * - "decline": User explicitly decline the action
+   * - "cancel": User dismissed without making an explicit choice
    */
   action: z2.enum(["accept", "decline", "cancel"]),
   /**
-   * The collected user input content (only present if action is "accept").
+   * 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: z2.optional(z2.record(z2.string(), z2.unknown()))
+  content: z2.preprocess((val) => val === null ? void 0 : val, z2.record(z2.string(), z2.union([z2.string(), z2.number(), z2.boolean(), z2.array(z2.string())])).optional())
 });
 var ResourceTemplateReferenceSchema = z2.object({
   type: z2.literal("ref/resource"),
@@ -9755,41 +10378,42 @@ var ResourceTemplateReferenceSchema = z2.object({
    * The URI or URI template of the resource.
    */
   uri: z2.string()
-}).passthrough();
+});
 var PromptReferenceSchema = z2.object({
   type: z2.literal("ref/prompt"),
   /**
    * The name of the prompt or prompt template
    */
   name: z2.string()
-}).passthrough();
-var CompleteRequestSchema = RequestSchema.extend({
-  method: z2.literal("completion/complete"),
-  params: BaseRequestParamsSchema.extend({
-    ref: z2.union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
+});
+var CompleteRequestParamsSchema = BaseRequestParamsSchema.extend({
+  ref: z2.union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
+  /**
+   * The argument's information
+   */
+  argument: z2.object({
     /**
-     * The argument's information
+     * The name of the argument
      */
-    argument: z2.object({
-      /**
-       * The name of the argument
-       */
-      name: z2.string(),
-      /**
-       * The value of the argument to use for completion matching.
-       */
-      value: z2.string()
-    }).passthrough(),
-    context: z2.optional(z2.object({
-      /**
-       * Previously-resolved variables in a URI template or prompt.
-       */
-      arguments: z2.optional(z2.record(z2.string(), z2.string()))
-    }))
-  })
+    name: z2.string(),
+    /**
+     * The value of the argument to use for completion matching.
+     */
+    value: z2.string()
+  }),
+  context: z2.object({
+    /**
+     * Previously-resolved variables in a URI template or prompt.
+     */
+    arguments: z2.record(z2.string(), z2.string()).optional()
+  }).optional()
+});
+var CompleteRequestSchema = RequestSchema.extend({
+  method: z2.literal("completion/complete"),
+  params: CompleteRequestParamsSchema
 });
 var CompleteResultSchema = ResultSchema.extend({
-  completion: z2.object({
+  completion: z2.looseObject({
     /**
      * An array of completion values. Must not exceed 100 items.
      */
@@ -9802,7 +10426,7 @@ var CompleteResultSchema = ResultSchema.extend({
      * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
      */
     hasMore: z2.optional(z2.boolean())
-  }).passthrough()
+  })
 });
 var RootSchema = z2.object({
   /**
@@ -9812,21 +10436,23 @@ var RootSchema = z2.object({
   /**
    * An optional name for the root.
    */
-  name: z2.optional(z2.string()),
+  name: z2.string().optional(),
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z2.optional(z2.object({}).passthrough())
-}).passthrough();
+  _meta: z2.record(z2.string(), z2.unknown()).optional()
+});
 var ListRootsRequestSchema = RequestSchema.extend({
-  method: z2.literal("roots/list")
+  method: z2.literal("roots/list"),
+  params: BaseRequestParamsSchema.optional()
 });
 var ListRootsResultSchema = ResultSchema.extend({
   roots: z2.array(RootSchema)
 });
 var RootsListChangedNotificationSchema = NotificationSchema.extend({
-  method: z2.literal("notifications/roots/list_changed")
+  method: z2.literal("notifications/roots/list_changed"),
+  params: NotificationsParamsSchema.optional()
 });
 var ClientRequestSchema = z2.union([
   PingRequestSchema,
@@ -9841,16 +10467,39 @@ var ClientRequestSchema = z2.union([
   SubscribeRequestSchema,
   UnsubscribeRequestSchema,
   CallToolRequestSchema,
-  ListToolsRequestSchema
+  ListToolsRequestSchema,
+  GetTaskRequestSchema,
+  GetTaskPayloadRequestSchema,
+  ListTasksRequestSchema,
+  CancelTaskRequestSchema
 ]);
 var ClientNotificationSchema = z2.union([
   CancelledNotificationSchema,
   ProgressNotificationSchema,
   InitializedNotificationSchema,
-  RootsListChangedNotificationSchema
+  RootsListChangedNotificationSchema,
+  TaskStatusNotificationSchema
+]);
+var ClientResultSchema = z2.union([
+  EmptyResultSchema,
+  CreateMessageResultSchema,
+  CreateMessageResultWithToolsSchema,
+  ElicitResultSchema,
+  ListRootsResultSchema,
+  GetTaskResultSchema,
+  ListTasksResultSchema,
+  CreateTaskResultSchema
+]);
+var ServerRequestSchema = z2.union([
+  PingRequestSchema,
+  CreateMessageRequestSchema,
+  ElicitRequestSchema,
+  ListRootsRequestSchema,
+  GetTaskRequestSchema,
+  GetTaskPayloadRequestSchema,
+  ListTasksRequestSchema,
+  CancelTaskRequestSchema
 ]);
-var ClientResultSchema = z2.union([EmptyResultSchema, CreateMessageResultSchema, ElicitResultSchema, ListRootsResultSchema]);
-var ServerRequestSchema = z2.union([PingRequestSchema, CreateMessageRequestSchema, ElicitRequestSchema, ListRootsRequestSchema]);
 var ServerNotificationSchema = z2.union([
   CancelledNotificationSchema,
   ProgressNotificationSchema,
@@ -9858,7 +10507,9 @@ var ServerNotificationSchema = z2.union([
   ResourceUpdatedNotificationSchema,
   ResourceListChangedNotificationSchema,
   ToolListChangedNotificationSchema,
-  PromptListChangedNotificationSchema
+  PromptListChangedNotificationSchema,
+  TaskStatusNotificationSchema,
+  ElicitationCompleteNotificationSchema
 ]);
 var ServerResultSchema = z2.union([
   EmptyResultSchema,
@@ -9870,18 +10521,195 @@ var ServerResultSchema = z2.union([
   ListResourceTemplatesResultSchema,
   ReadResourceResultSchema,
   CallToolResultSchema,
-  ListToolsResultSchema
+  ListToolsResultSchema,
+  GetTaskResultSchema,
+  ListTasksResultSchema,
+  CreateTaskResultSchema
 ]);
-var McpError = class extends Error {
+var McpError = class _McpError extends Error {
   constructor(code, message, data) {
     super(`MCP error ${code}: ${message}`);
     this.code = code;
     this.data = data;
     this.name = "McpError";
   }
+  /**
+   * Factory method to create the appropriate error type based on the error code and data
+   */
+  static fromError(code, message, data) {
+    if (code === ErrorCode.UrlElicitationRequired && data) {
+      const errorData = data;
+      if (errorData.elicitations) {
+        return new UrlElicitationRequiredError(errorData.elicitations, message);
+      }
+    }
+    return new _McpError(code, message, data);
+  }
+};
+var UrlElicitationRequiredError = class extends McpError {
+  constructor(elicitations, message = `URL elicitation${elicitations.length > 1 ? "s" : ""} required`) {
+    super(ErrorCode.UrlElicitationRequired, message, {
+      elicitations
+    });
+  }
+  get elicitations() {
+    return this.data?.elicitations ?? [];
+  }
 };
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.21.1/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
+init_esm_shims();
+function isTerminal(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
+init_esm_shims();
+import * as z4mini2 from "zod/v4-mini";
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/index.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Options.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Refs.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parseDef.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/selectParser.js
+init_esm_shims();
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
+init_esm_shims();
+import { ZodFirstPartyTypeKind } from "zod/v3";
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+init_esm_shims();
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2 } from "zod/v3";
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+init_esm_shims();
+var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/parseTypes.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
+init_esm_shims();
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
+function getMethodLiteral(schema) {
+  const shape = getObjectShape(schema);
+  const methodSchema = shape?.method;
+  if (!methodSchema) {
+    throw new Error("Schema is missing a method literal");
+  }
+  const value = getLiteralValue(methodSchema);
+  if (typeof value !== "string") {
+    throw new Error("Schema method literal must be a string");
+  }
+  return value;
+}
+function parseWithCompat(schema, data) {
+  const result = safeParse2(schema, data);
+  if (!result.success) {
+    throw result.error;
+  }
+  return result.data;
+}
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
 var DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4;
 var Protocol = class {
   constructor(_options) {
@@ -9894,9 +10722,10 @@ var Protocol = class {
     this._progressHandlers = /* @__PURE__ */ new Map();
     this._timeoutInfo = /* @__PURE__ */ new Map();
     this._pendingDebouncedNotifications = /* @__PURE__ */ new Set();
+    this._taskProgressTokens = /* @__PURE__ */ new Map();
+    this._requestResolvers = /* @__PURE__ */ new Map();
     this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
-      const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
-      controller === null || controller === void 0 ? void 0 : controller.abort(notification.params.reason);
+      this._oncancel(notification);
     });
     this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
       this._onprogress(notification);
@@ -9906,6 +10735,117 @@ var Protocol = class {
       // Automatic pong by default.
       (_request) => ({})
     );
+    this._taskStore = _options?.taskStore;
+    this._taskMessageQueue = _options?.taskMessageQueue;
+    if (this._taskStore) {
+      this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
+        const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+        if (!task) {
+          throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+        }
+        return {
+          ...task
+        };
+      });
+      this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
+        const handleTaskResult = async () => {
+          const taskId = request.params.taskId;
+          if (this._taskMessageQueue) {
+            let queuedMessage;
+            while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
+              if (queuedMessage.type === "response" || queuedMessage.type === "error") {
+                const message = queuedMessage.message;
+                const requestId = message.id;
+                const resolver = this._requestResolvers.get(requestId);
+                if (resolver) {
+                  this._requestResolvers.delete(requestId);
+                  if (queuedMessage.type === "response") {
+                    resolver(message);
+                  } else {
+                    const errorMessage = message;
+                    const error2 = new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data);
+                    resolver(error2);
+                  }
+                } else {
+                  const messageType = queuedMessage.type === "response" ? "Response" : "Error";
+                  this._onerror(new Error(`${messageType} handler missing for request ${requestId}`));
+                }
+                continue;
+              }
+              await this._transport?.send(queuedMessage.message, { relatedRequestId: extra.requestId });
+            }
+          }
+          const task = await this._taskStore.getTask(taskId, extra.sessionId);
+          if (!task) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+          }
+          if (!isTerminal(task.status)) {
+            await this._waitForTaskUpdate(taskId, extra.signal);
+            return await handleTaskResult();
+          }
+          if (isTerminal(task.status)) {
+            const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
+            this._clearTaskQueue(taskId);
+            return {
+              ...result,
+              _meta: {
+                ...result._meta,
+                [RELATED_TASK_META_KEY]: {
+                  taskId
+                }
+              }
+            };
+          }
+          return await handleTaskResult();
+        };
+        return await handleTaskResult();
+      });
+      this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
+        try {
+          const { tasks, nextCursor } = await this._taskStore.listTasks(request.params?.cursor, extra.sessionId);
+          return {
+            tasks,
+            nextCursor,
+            _meta: {}
+          };
+        } catch (error2) {
+          throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        }
+      });
+      this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => {
+        try {
+          const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+          if (!task) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
+          }
+          if (isTerminal(task.status)) {
+            throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
+          }
+          await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
+          this._clearTaskQueue(request.params.taskId);
+          const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+          if (!cancelledTask) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
+          }
+          return {
+            _meta: {},
+            ...cancelledTask
+          };
+        } catch (error2) {
+          if (error2 instanceof McpError) {
+            throw error2;
+          }
+          throw new McpError(ErrorCode.InvalidRequest, `Failed to cancel task: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        }
+      });
+    }
+  }
+  async _oncancel(notification) {
+    if (!notification.params.requestId) {
+      return;
+    }
+    const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
+    controller?.abort(notification.params.reason);
   }
   _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
     this._timeoutInfo.set(messageId, {
@@ -9924,7 +10864,7 @@ var Protocol = class {
     const totalElapsed = Date.now() - info2.startTime;
     if (info2.maxTotalTimeout && totalElapsed >= info2.maxTotalTimeout) {
       this._timeoutInfo.delete(messageId);
-      throw new McpError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
+      throw McpError.fromError(ErrorCode.RequestTimeout, "Maximum total timeout exceeded", {
         maxTotalTimeout: info2.maxTotalTimeout,
         totalElapsed
       });
@@ -9946,22 +10886,21 @@ var Protocol = class {
    * The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
    */
   async connect(transport) {
-    var _a, _b, _c;
     this._transport = transport;
-    const _onclose = (_a = this.transport) === null || _a === void 0 ? void 0 : _a.onclose;
+    const _onclose = this.transport?.onclose;
     this._transport.onclose = () => {
-      _onclose === null || _onclose === void 0 ? void 0 : _onclose();
+      _onclose?.();
       this._onclose();
     };
-    const _onerror = (_b = this.transport) === null || _b === void 0 ? void 0 : _b.onerror;
+    const _onerror = this.transport?.onerror;
     this._transport.onerror = (error2) => {
-      _onerror === null || _onerror === void 0 ? void 0 : _onerror(error2);
+      _onerror?.(error2);
       this._onerror(error2);
     };
-    const _onmessage = (_c = this._transport) === null || _c === void 0 ? void 0 : _c.onmessage;
+    const _onmessage = this._transport?.onmessage;
     this._transport.onmessage = (message, extra) => {
-      _onmessage === null || _onmessage === void 0 ? void 0 : _onmessage(message, extra);
-      if (isJSONRPCResponse(message) || isJSONRPCError(message)) {
+      _onmessage?.(message, extra);
+      if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
         this._onresponse(message);
       } else if (isJSONRPCRequest(message)) {
         this._onrequest(message, extra);
@@ -9974,79 +10913,131 @@ var Protocol = class {
     await this._transport.start();
   }
   _onclose() {
-    var _a;
     const responseHandlers = this._responseHandlers;
     this._responseHandlers = /* @__PURE__ */ new Map();
     this._progressHandlers.clear();
+    this._taskProgressTokens.clear();
     this._pendingDebouncedNotifications.clear();
+    const error2 = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
     this._transport = void 0;
-    (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
-    const error2 = new McpError(ErrorCode.ConnectionClosed, "Connection closed");
+    this.onclose?.();
     for (const handler of responseHandlers.values()) {
       handler(error2);
     }
   }
   _onerror(error2) {
-    var _a;
-    (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error2);
+    this.onerror?.(error2);
   }
   _onnotification(notification) {
-    var _a;
-    const handler = (_a = this._notificationHandlers.get(notification.method)) !== null && _a !== void 0 ? _a : this.fallbackNotificationHandler;
+    const handler = this._notificationHandlers.get(notification.method) ?? this.fallbackNotificationHandler;
     if (handler === void 0) {
       return;
     }
     Promise.resolve().then(() => handler(notification)).catch((error2) => this._onerror(new Error(`Uncaught error in notification handler: ${error2}`)));
   }
   _onrequest(request, extra) {
-    var _a, _b;
-    const handler = (_a = this._requestHandlers.get(request.method)) !== null && _a !== void 0 ? _a : this.fallbackRequestHandler;
+    const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
     const capturedTransport = this._transport;
+    const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
     if (handler === void 0) {
-      capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
+      const errorResponse = {
         jsonrpc: "2.0",
         id: request.id,
         error: {
           code: ErrorCode.MethodNotFound,
           message: "Method not found"
         }
-      }).catch((error2) => this._onerror(new Error(`Failed to send an error response: ${error2}`)));
+      };
+      if (relatedTaskId && this._taskMessageQueue) {
+        this._enqueueTaskMessage(relatedTaskId, {
+          type: "error",
+          message: errorResponse,
+          timestamp: Date.now()
+        }, capturedTransport?.sessionId).catch((error2) => this._onerror(new Error(`Failed to enqueue error response: ${error2}`)));
+      } else {
+        capturedTransport?.send(errorResponse).catch((error2) => this._onerror(new Error(`Failed to send an error response: ${error2}`)));
+      }
       return;
     }
     const abortController = new AbortController();
     this._requestHandlerAbortControllers.set(request.id, abortController);
+    const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : void 0;
+    const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : void 0;
     const fullExtra = {
       signal: abortController.signal,
-      sessionId: capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId,
-      _meta: (_b = request.params) === null || _b === void 0 ? void 0 : _b._meta,
-      sendNotification: (notification) => this.notification(notification, { relatedRequestId: request.id }),
-      sendRequest: (r, resultSchema, options) => this.request(r, resultSchema, { ...options, relatedRequestId: request.id }),
-      authInfo: extra === null || extra === void 0 ? void 0 : extra.authInfo,
+      sessionId: capturedTransport?.sessionId,
+      _meta: request.params?._meta,
+      sendNotification: async (notification) => {
+        const notificationOptions = { relatedRequestId: request.id };
+        if (relatedTaskId) {
+          notificationOptions.relatedTask = { taskId: relatedTaskId };
+        }
+        await this.notification(notification, notificationOptions);
+      },
+      sendRequest: async (r, resultSchema, options) => {
+        const requestOptions = { ...options, relatedRequestId: request.id };
+        if (relatedTaskId && !requestOptions.relatedTask) {
+          requestOptions.relatedTask = { taskId: relatedTaskId };
+        }
+        const effectiveTaskId = requestOptions.relatedTask?.taskId ?? relatedTaskId;
+        if (effectiveTaskId && taskStore) {
+          await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
+        }
+        return await this.request(r, resultSchema, requestOptions);
+      },
+      authInfo: extra?.authInfo,
       requestId: request.id,
-      requestInfo: extra === null || extra === void 0 ? void 0 : extra.requestInfo
-    };
-    Promise.resolve().then(() => handler(request, fullExtra)).then((result) => {
+      requestInfo: extra?.requestInfo,
+      taskId: relatedTaskId,
+      taskStore,
+      taskRequestedTtl: taskCreationParams?.ttl,
+      closeSSEStream: extra?.closeSSEStream,
+      closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
+    };
+    Promise.resolve().then(() => {
+      if (taskCreationParams) {
+        this.assertTaskHandlerCapability(request.method);
+      }
+    }).then(() => handler(request, fullExtra)).then(async (result) => {
       if (abortController.signal.aborted) {
         return;
       }
-      return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
+      const response = {
         result,
         jsonrpc: "2.0",
         id: request.id
-      });
-    }, (error2) => {
-      var _a2;
+      };
+      if (relatedTaskId && this._taskMessageQueue) {
+        await this._enqueueTaskMessage(relatedTaskId, {
+          type: "response",
+          message: response,
+          timestamp: Date.now()
+        }, capturedTransport?.sessionId);
+      } else {
+        await capturedTransport?.send(response);
+      }
+    }, async (error2) => {
       if (abortController.signal.aborted) {
         return;
       }
-      return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
+      const errorResponse = {
         jsonrpc: "2.0",
         id: request.id,
         error: {
           code: Number.isSafeInteger(error2["code"]) ? error2["code"] : ErrorCode.InternalError,
-          message: (_a2 = error2.message) !== null && _a2 !== void 0 ? _a2 : "Internal error"
+          message: error2.message ?? "Internal error",
+          ...error2["data"] !== void 0 && { data: error2["data"] }
         }
-      });
+      };
+      if (relatedTaskId && this._taskMessageQueue) {
+        await this._enqueueTaskMessage(relatedTaskId, {
+          type: "error",
+          message: errorResponse,
+          timestamp: Date.now()
+        }, capturedTransport?.sessionId);
+      } else {
+        await capturedTransport?.send(errorResponse);
+      }
     }).catch((error2) => this._onerror(new Error(`Failed to send response: ${error2}`))).finally(() => {
       this._requestHandlerAbortControllers.delete(request.id);
     });
@@ -10065,6 +11056,9 @@ var Protocol = class {
       try {
         this._resetTimeout(messageId);
       } catch (error2) {
+        this._responseHandlers.delete(messageId);
+        this._progressHandlers.delete(messageId);
+        this._cleanupTimeout(messageId);
         responseHandler(error2);
         return;
       }
@@ -10073,18 +11067,42 @@ var Protocol = class {
   }
   _onresponse(response) {
     const messageId = Number(response.id);
+    const resolver = this._requestResolvers.get(messageId);
+    if (resolver) {
+      this._requestResolvers.delete(messageId);
+      if (isJSONRPCResultResponse(response)) {
+        resolver(response);
+      } else {
+        const error2 = new McpError(response.error.code, response.error.message, response.error.data);
+        resolver(error2);
+      }
+      return;
+    }
     const handler = this._responseHandlers.get(messageId);
     if (handler === void 0) {
       this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
       return;
     }
     this._responseHandlers.delete(messageId);
-    this._progressHandlers.delete(messageId);
     this._cleanupTimeout(messageId);
-    if (isJSONRPCResponse(response)) {
+    let isTaskResponse = false;
+    if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") {
+      const result = response.result;
+      if (result.task && typeof result.task === "object") {
+        const task = result.task;
+        if (typeof task.taskId === "string") {
+          isTaskResponse = true;
+          this._taskProgressTokens.set(task.taskId, messageId);
+        }
+      }
+    }
+    if (!isTaskResponse) {
+      this._progressHandlers.delete(messageId);
+    }
+    if (isJSONRPCResultResponse(response)) {
       handler(response);
     } else {
-      const error2 = new McpError(response.error.code, response.error.message, response.error.data);
+      const error2 = McpError.fromError(response.error.code, response.error.message, response.error.data);
       handler(error2);
     }
   }
@@ -10095,119 +11113,326 @@ var Protocol = class {
    * Closes the connection.
    */
   async close() {
-    var _a;
-    await ((_a = this._transport) === null || _a === void 0 ? void 0 : _a.close());
+    await this._transport?.close();
+  }
+  /**
+   * Sends a request and returns an AsyncGenerator that yields response messages.
+   * The generator is guaranteed to end with either a 'result' or 'error' message.
+   *
+   * @example
+   * ```typescript
+   * const stream = protocol.requestStream(request, resultSchema, options);
+   * for await (const message of stream) {
+   *   switch (message.type) {
+   *     case 'taskCreated':
+   *       console.log('Task created:', message.task.taskId);
+   *       break;
+   *     case 'taskStatus':
+   *       console.log('Task status:', message.task.status);
+   *       break;
+   *     case 'result':
+   *       console.log('Final result:', message.result);
+   *       break;
+   *     case 'error':
+   *       console.error('Error:', message.error);
+   *       break;
+   *   }
+   * }
+   * ```
+   *
+   * @experimental Use `client.experimental.tasks.requestStream()` to access this method.
+   */
+  async *requestStream(request, resultSchema, options) {
+    const { task } = options ?? {};
+    if (!task) {
+      try {
+        const result = await this.request(request, resultSchema, options);
+        yield { type: "result", result };
+      } catch (error2) {
+        yield {
+          type: "error",
+          error: error2 instanceof McpError ? error2 : new McpError(ErrorCode.InternalError, String(error2))
+        };
+      }
+      return;
+    }
+    let taskId;
+    try {
+      const createResult = await this.request(request, CreateTaskResultSchema, options);
+      if (createResult.task) {
+        taskId = createResult.task.taskId;
+        yield { type: "taskCreated", task: createResult.task };
+      } else {
+        throw new McpError(ErrorCode.InternalError, "Task creation did not return a task");
+      }
+      while (true) {
+        const task2 = await this.getTask({ taskId }, options);
+        yield { type: "taskStatus", task: task2 };
+        if (isTerminal(task2.status)) {
+          if (task2.status === "completed") {
+            const result = await this.getTaskResult({ taskId }, resultSchema, options);
+            yield { type: "result", result };
+          } else if (task2.status === "failed") {
+            yield {
+              type: "error",
+              error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
+            };
+          } else if (task2.status === "cancelled") {
+            yield {
+              type: "error",
+              error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
+            };
+          }
+          return;
+        }
+        if (task2.status === "input_required") {
+          const result = await this.getTaskResult({ taskId }, resultSchema, options);
+          yield { type: "result", result };
+          return;
+        }
+        const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        options?.signal?.throwIfAborted();
+      }
+    } catch (error2) {
+      yield {
+        type: "error",
+        error: error2 instanceof McpError ? error2 : new McpError(ErrorCode.InternalError, String(error2))
+      };
+    }
   }
   /**
-   * Sends a request and wait for a response.
+   * Sends a request and waits for a response.
    *
    * Do not use this method to emit notifications! Use notification() instead.
    */
   request(request, resultSchema, options) {
-    const { relatedRequestId, resumptionToken, onresumptiontoken } = options !== null && options !== void 0 ? options : {};
+    const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
     return new Promise((resolve, reject) => {
-      var _a, _b, _c, _d, _e, _f;
+      const earlyReject = (error2) => {
+        reject(error2);
+      };
       if (!this._transport) {
-        reject(new Error("Not connected"));
+        earlyReject(new Error("Not connected"));
         return;
       }
-      if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.enforceStrictCapabilities) === true) {
-        this.assertCapabilityForMethod(request.method);
+      if (this._options?.enforceStrictCapabilities === true) {
+        try {
+          this.assertCapabilityForMethod(request.method);
+          if (task) {
+            this.assertTaskCapability(request.method);
+          }
+        } catch (e) {
+          earlyReject(e);
+          return;
+        }
       }
-      (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
+      options?.signal?.throwIfAborted();
       const messageId = this._requestMessageId++;
       const jsonrpcRequest = {
         ...request,
         jsonrpc: "2.0",
         id: messageId
       };
-      if (options === null || options === void 0 ? void 0 : options.onprogress) {
+      if (options?.onprogress) {
         this._progressHandlers.set(messageId, options.onprogress);
         jsonrpcRequest.params = {
           ...request.params,
           _meta: {
-            ...((_c = request.params) === null || _c === void 0 ? void 0 : _c._meta) || {},
+            ...request.params?._meta || {},
             progressToken: messageId
           }
         };
       }
+      if (task) {
+        jsonrpcRequest.params = {
+          ...jsonrpcRequest.params,
+          task
+        };
+      }
+      if (relatedTask) {
+        jsonrpcRequest.params = {
+          ...jsonrpcRequest.params,
+          _meta: {
+            ...jsonrpcRequest.params?._meta || {},
+            [RELATED_TASK_META_KEY]: relatedTask
+          }
+        };
+      }
       const cancel = (reason) => {
-        var _a2;
         this._responseHandlers.delete(messageId);
         this._progressHandlers.delete(messageId);
         this._cleanupTimeout(messageId);
-        (_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.send({
+        this._transport?.send({
           jsonrpc: "2.0",
           method: "notifications/cancelled",
           params: {
             requestId: messageId,
             reason: String(reason)
           }
-        }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error2) => this._onerror(new Error(`Failed to send cancellation: ${error2}`)));
-        reject(reason);
+        }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error3) => this._onerror(new Error(`Failed to send cancellation: ${error3}`)));
+        const error2 = reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason));
+        reject(error2);
       };
       this._responseHandlers.set(messageId, (response) => {
-        var _a2;
-        if ((_a2 = options === null || options === void 0 ? void 0 : options.signal) === null || _a2 === void 0 ? void 0 : _a2.aborted) {
+        if (options?.signal?.aborted) {
           return;
         }
         if (response instanceof Error) {
           return reject(response);
         }
         try {
-          const result = resultSchema.parse(response.result);
-          resolve(result);
+          const parseResult = safeParse2(resultSchema, response.result);
+          if (!parseResult.success) {
+            reject(parseResult.error);
+          } else {
+            resolve(parseResult.data);
+          }
         } catch (error2) {
           reject(error2);
         }
       });
-      (_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 = (_e = options === null || options === void 0 ? void 0 : options.timeout) !== null && _e !== void 0 ? _e : DEFAULT_REQUEST_TIMEOUT_MSEC;
-      const timeoutHandler = () => cancel(new McpError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
-      this._setupTimeout(messageId, timeout, options === null || options === void 0 ? void 0 : options.maxTotalTimeout, timeoutHandler, (_f = options === null || options === void 0 ? void 0 : options.resetTimeoutOnProgress) !== null && _f !== void 0 ? _f : false);
-      this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error2) => {
-        this._cleanupTimeout(messageId);
-        reject(error2);
+      options?.signal?.addEventListener("abort", () => {
+        cancel(options?.signal?.reason);
       });
+      const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+      const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
+      this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
+      const relatedTaskId = relatedTask?.taskId;
+      if (relatedTaskId) {
+        const responseResolver = (response) => {
+          const handler = this._responseHandlers.get(messageId);
+          if (handler) {
+            handler(response);
+          } else {
+            this._onerror(new Error(`Response handler missing for side-channeled request ${messageId}`));
+          }
+        };
+        this._requestResolvers.set(messageId, responseResolver);
+        this._enqueueTaskMessage(relatedTaskId, {
+          type: "request",
+          message: jsonrpcRequest,
+          timestamp: Date.now()
+        }).catch((error2) => {
+          this._cleanupTimeout(messageId);
+          reject(error2);
+        });
+      } else {
+        this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error2) => {
+          this._cleanupTimeout(messageId);
+          reject(error2);
+        });
+      }
     });
   }
+  /**
+   * Gets the current status of a task.
+   *
+   * @experimental Use `client.experimental.tasks.getTask()` to access this method.
+   */
+  async getTask(params, options) {
+    return this.request({ method: "tasks/get", params }, GetTaskResultSchema, options);
+  }
+  /**
+   * Retrieves the result of a completed task.
+   *
+   * @experimental Use `client.experimental.tasks.getTaskResult()` to access this method.
+   */
+  async getTaskResult(params, resultSchema, options) {
+    return this.request({ method: "tasks/result", params }, resultSchema, options);
+  }
+  /**
+   * Lists tasks, optionally starting from a pagination cursor.
+   *
+   * @experimental Use `client.experimental.tasks.listTasks()` to access this method.
+   */
+  async listTasks(params, options) {
+    return this.request({ method: "tasks/list", params }, ListTasksResultSchema, options);
+  }
+  /**
+   * Cancels a specific task.
+   *
+   * @experimental Use `client.experimental.tasks.cancelTask()` to access this method.
+   */
+  async cancelTask(params, options) {
+    return this.request({ method: "tasks/cancel", params }, CancelTaskResultSchema, options);
+  }
   /**
    * Emits a notification, which is a one-way message that does not expect a response.
    */
   async notification(notification, options) {
-    var _a, _b;
     if (!this._transport) {
       throw new Error("Not connected");
     }
     this.assertNotificationCapability(notification.method);
-    const debouncedMethods = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.debouncedNotificationMethods) !== null && _b !== void 0 ? _b : [];
-    const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !(options === null || options === void 0 ? void 0 : options.relatedRequestId);
+    const relatedTaskId = options?.relatedTask?.taskId;
+    if (relatedTaskId) {
+      const jsonrpcNotification2 = {
+        ...notification,
+        jsonrpc: "2.0",
+        params: {
+          ...notification.params,
+          _meta: {
+            ...notification.params?._meta || {},
+            [RELATED_TASK_META_KEY]: options.relatedTask
+          }
+        }
+      };
+      await this._enqueueTaskMessage(relatedTaskId, {
+        type: "notification",
+        message: jsonrpcNotification2,
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const debouncedMethods = this._options?.debouncedNotificationMethods ?? [];
+    const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !options?.relatedRequestId && !options?.relatedTask;
     if (canDebounce) {
       if (this._pendingDebouncedNotifications.has(notification.method)) {
         return;
       }
       this._pendingDebouncedNotifications.add(notification.method);
       Promise.resolve().then(() => {
-        var _a2;
         this._pendingDebouncedNotifications.delete(notification.method);
         if (!this._transport) {
           return;
         }
-        const jsonrpcNotification2 = {
+        let jsonrpcNotification2 = {
           ...notification,
           jsonrpc: "2.0"
         };
-        (_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.send(jsonrpcNotification2, options).catch((error2) => this._onerror(error2));
+        if (options?.relatedTask) {
+          jsonrpcNotification2 = {
+            ...jsonrpcNotification2,
+            params: {
+              ...jsonrpcNotification2.params,
+              _meta: {
+                ...jsonrpcNotification2.params?._meta || {},
+                [RELATED_TASK_META_KEY]: options.relatedTask
+              }
+            }
+          };
+        }
+        this._transport?.send(jsonrpcNotification2, options).catch((error2) => this._onerror(error2));
       });
       return;
     }
-    const jsonrpcNotification = {
+    let jsonrpcNotification = {
       ...notification,
       jsonrpc: "2.0"
     };
+    if (options?.relatedTask) {
+      jsonrpcNotification = {
+        ...jsonrpcNotification,
+        params: {
+          ...jsonrpcNotification.params,
+          _meta: {
+            ...jsonrpcNotification.params?._meta || {},
+            [RELATED_TASK_META_KEY]: options.relatedTask
+          }
+        }
+      };
+    }
     await this._transport.send(jsonrpcNotification, options);
   }
   /**
@@ -10216,10 +11441,11 @@ var Protocol = class {
    * Note that this will replace any previous request handler for the same method.
    */
   setRequestHandler(requestSchema, handler) {
-    const method = requestSchema.shape.method.value;
+    const method = getMethodLiteral(requestSchema);
     this.assertRequestHandlerCapability(method);
     this._requestHandlers.set(method, (request, extra) => {
-      return Promise.resolve(handler(requestSchema.parse(request), extra));
+      const parsed = parseWithCompat(requestSchema, request);
+      return Promise.resolve(handler(parsed, extra));
     });
   }
   /**
@@ -10242,7 +11468,11 @@ var Protocol = class {
    * Note that this will replace any previous notification handler for the same method.
    */
   setNotificationHandler(notificationSchema, handler) {
-    this._notificationHandlers.set(notificationSchema.shape.method.value, (notification) => Promise.resolve(handler(notificationSchema.parse(notification))));
+    const method = getMethodLiteral(notificationSchema);
+    this._notificationHandlers.set(method, (notification) => {
+      const parsed = parseWithCompat(notificationSchema, notification);
+      return Promise.resolve(handler(parsed));
+    });
   }
   /**
    * Removes the notification handler for the given method.
@@ -10250,24 +11480,177 @@ var Protocol = class {
   removeNotificationHandler(method) {
     this._notificationHandlers.delete(method);
   }
+  /**
+   * Cleans up the progress handler associated with a task.
+   * This should be called when a task reaches a terminal status.
+   */
+  _cleanupTaskProgressHandler(taskId) {
+    const progressToken = this._taskProgressTokens.get(taskId);
+    if (progressToken !== void 0) {
+      this._progressHandlers.delete(progressToken);
+      this._taskProgressTokens.delete(taskId);
+    }
+  }
+  /**
+   * Enqueues a task-related message for side-channel delivery via tasks/result.
+   * @param taskId The task ID to associate the message with
+   * @param message The message to enqueue
+   * @param sessionId Optional session ID for binding the operation to a specific session
+   * @throws Error if taskStore is not configured or if enqueue fails (e.g., queue overflow)
+   *
+   * Note: If enqueue fails, it's the TaskMessageQueue implementation's responsibility to handle
+   * the error appropriately (e.g., by failing the task, logging, etc.). The Protocol layer
+   * simply propagates the error.
+   */
+  async _enqueueTaskMessage(taskId, message, sessionId) {
+    if (!this._taskStore || !this._taskMessageQueue) {
+      throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
+    }
+    const maxQueueSize = this._options?.maxTaskQueueSize;
+    await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+  }
+  /**
+   * Clears the message queue for a task and rejects any pending request resolvers.
+   * @param taskId The task ID whose queue should be cleared
+   * @param sessionId Optional session ID for binding the operation to a specific session
+   */
+  async _clearTaskQueue(taskId, sessionId) {
+    if (this._taskMessageQueue) {
+      const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
+      for (const message of messages) {
+        if (message.type === "request" && isJSONRPCRequest(message.message)) {
+          const requestId = message.message.id;
+          const resolver = this._requestResolvers.get(requestId);
+          if (resolver) {
+            resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed"));
+            this._requestResolvers.delete(requestId);
+          } else {
+            this._onerror(new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Waits for a task update (new messages or status change) with abort signal support.
+   * Uses polling to check for updates at the task's configured poll interval.
+   * @param taskId The task ID to wait for
+   * @param signal Abort signal to cancel the wait
+   * @returns Promise that resolves when an update occurs or rejects if aborted
+   */
+  async _waitForTaskUpdate(taskId, signal) {
+    let interval = this._options?.defaultTaskPollInterval ?? 1e3;
+    try {
+      const task = await this._taskStore?.getTask(taskId);
+      if (task?.pollInterval) {
+        interval = task.pollInterval;
+      }
+    } catch {
+    }
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) {
+        reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+        return;
+      }
+      const timeoutId = setTimeout(resolve, interval);
+      signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+        reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+      }, { once: true });
+    });
+  }
+  requestTaskStore(request, sessionId) {
+    const taskStore = this._taskStore;
+    if (!taskStore) {
+      throw new Error("No task store configured");
+    }
+    return {
+      createTask: async (taskParams) => {
+        if (!request) {
+          throw new Error("No request provided");
+        }
+        return await taskStore.createTask(taskParams, request.id, {
+          method: request.method,
+          params: request.params
+        }, sessionId);
+      },
+      getTask: async (taskId) => {
+        const task = await taskStore.getTask(taskId, sessionId);
+        if (!task) {
+          throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+        }
+        return task;
+      },
+      storeTaskResult: async (taskId, status, result) => {
+        await taskStore.storeTaskResult(taskId, status, result, sessionId);
+        const task = await taskStore.getTask(taskId, sessionId);
+        if (task) {
+          const notification = TaskStatusNotificationSchema.parse({
+            method: "notifications/tasks/status",
+            params: task
+          });
+          await this.notification(notification);
+          if (isTerminal(task.status)) {
+            this._cleanupTaskProgressHandler(taskId);
+          }
+        }
+      },
+      getTaskResult: (taskId) => {
+        return taskStore.getTaskResult(taskId, sessionId);
+      },
+      updateTaskStatus: async (taskId, status, statusMessage) => {
+        const task = await taskStore.getTask(taskId, sessionId);
+        if (!task) {
+          throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
+        }
+        if (isTerminal(task.status)) {
+          throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
+        }
+        await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
+        const updatedTask = await taskStore.getTask(taskId, sessionId);
+        if (updatedTask) {
+          const notification = TaskStatusNotificationSchema.parse({
+            method: "notifications/tasks/status",
+            params: updatedTask
+          });
+          await this.notification(notification);
+          if (isTerminal(updatedTask.status)) {
+            this._cleanupTaskProgressHandler(taskId);
+          }
+        }
+      },
+      listTasks: (cursor) => {
+        return taskStore.listTasks(cursor, sessionId);
+      }
+    };
+  }
 };
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 function mergeCapabilities(base, additional) {
-  return Object.entries(additional).reduce((acc, [key, value]) => {
-    if (value && typeof value === "object") {
-      acc[key] = acc[key] ? { ...acc[key], ...value } : value;
+  const result = { ...base };
+  for (const key in additional) {
+    const k = key;
+    const addValue = additional[k];
+    if (addValue === void 0)
+      continue;
+    const baseValue = result[k];
+    if (isPlainObject(baseValue) && isPlainObject(addValue)) {
+      result[k] = { ...baseValue, ...addValue };
     } else {
-      acc[key] = value;
+      result[k] = addValue;
     }
-    return acc;
-  }, { ...base });
+  }
+  return result;
 }
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.21.1/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
 init_esm_shims();
 var import_ajv = __toESM(require_ajv(), 1);
 var import_ajv_formats = __toESM(require_dist(), 1);
 function createDefaultAjvInstance() {
-  const ajv = new import_ajv.Ajv({
+  const ajv = new import_ajv.default({
     strict: false,
     validateFormats: true,
     validateSchema: false,
@@ -10299,7 +11682,7 @@ var AjvJsonSchemaValidator = class {
    * ```
    */
   constructor(ajv) {
-    this._ajv = ajv !== null && ajv !== void 0 ? ajv : createDefaultAjvInstance();
+    this._ajv = ajv ?? createDefaultAjvInstance();
   }
   /**
    * Create a validator for the given JSON Schema
@@ -10311,8 +11694,7 @@ var AjvJsonSchemaValidator = class {
    * @returns A validator function that validates input data
    */
   getValidator(schema) {
-    var _a;
-    const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? (_a = this._ajv.getSchema(schema.$id)) !== null && _a !== void 0 ? _a : this._ajv.compile(schema) : this._ajv.compile(schema);
+    const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema);
     return (input) => {
       const valid = ajvValidator(input);
       if (valid) {
@@ -10332,13 +11714,121 @@ var AjvJsonSchemaValidator = class {
   }
 };
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.21.1/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
+init_esm_shims();
+var ExperimentalServerTasks = class {
+  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);
+  }
+};
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
+init_esm_shims();
+function assertToolsCallTaskCapability(requests, method, entityName) {
+  if (!requests) {
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  }
+  switch (method) {
+    case "tools/call":
+      if (!requests.tools?.call) {
+        throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+      }
+      break;
+    default:
+      break;
+  }
+}
+function assertClientRequestTaskCapability(requests, method, entityName) {
+  if (!requests) {
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  }
+  switch (method) {
+    case "sampling/createMessage":
+      if (!requests.sampling?.createMessage) {
+        throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+      }
+      break;
+    case "elicitation/create":
+      if (!requests.elicitation?.create) {
+        throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
 var Server = class extends Protocol {
   /**
    * Initializes this server with the given name and version information.
    */
   constructor(_serverInfo, options) {
-    var _a, _b;
     super(options);
     this._serverInfo = _serverInfo;
     this._loggingLevels = /* @__PURE__ */ new Map();
@@ -10347,18 +11837,14 @@ var Server = class extends Protocol {
       const currentLevel = this._loggingLevels.get(sessionId);
       return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
     };
-    this._capabilities = (_a = options === null || options === void 0 ? void 0 : options.capabilities) !== null && _a !== void 0 ? _a : {};
-    this._instructions = options === null || options === void 0 ? void 0 : options.instructions;
-    this._jsonSchemaValidator = (_b = options === null || options === void 0 ? void 0 : options.jsonSchemaValidator) !== null && _b !== void 0 ? _b : new AjvJsonSchemaValidator();
+    this._capabilities = options?.capabilities ?? {};
+    this._instructions = options?.instructions;
+    this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator();
     this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
-    this.setNotificationHandler(InitializedNotificationSchema, () => {
-      var _a2;
-      return (_a2 = this.oninitialized) === null || _a2 === void 0 ? void 0 : _a2.call(this);
-    });
+    this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
     if (this._capabilities.logging) {
       this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
-        var _a2;
-        const transportSessionId = extra.sessionId || ((_a2 = extra.requestInfo) === null || _a2 === void 0 ? void 0 : _a2.headers["mcp-session-id"]) || void 0;
+        const transportSessionId = extra.sessionId || extra.requestInfo?.headers["mcp-session-id"] || void 0;
         const { level } = request.params;
         const parseResult = LoggingLevelSchema.safeParse(level);
         if (parseResult.success) {
@@ -10368,6 +11854,21 @@ var Server = class extends Protocol {
       });
     }
   }
+  /**
+   * Access experimental features.
+   *
+   * WARNING: These APIs are experimental and may change without notice.
+   *
+   * @experimental
+   */
+  get experimental() {
+    if (!this._experimental) {
+      this._experimental = {
+        tasks: new ExperimentalServerTasks(this)
+      };
+    }
+    return this._experimental;
+  }
   /**
    * Registers new capabilities. This can only be called before connecting to a transport.
    *
@@ -10379,21 +11880,71 @@ var Server = class extends Protocol {
     }
     this._capabilities = mergeCapabilities(this._capabilities, capabilities);
   }
+  /**
+   * Override request handler registration to enforce server-side validation for tools/call.
+   */
+  setRequestHandler(requestSchema, handler) {
+    const shape = getObjectShape(requestSchema);
+    const methodSchema = shape?.method;
+    if (!methodSchema) {
+      throw new Error("Schema is missing a method literal");
+    }
+    let methodValue;
+    if (isZ4Schema(methodSchema)) {
+      const v4Schema = methodSchema;
+      const v4Def = v4Schema._zod?.def;
+      methodValue = v4Def?.value ?? v4Schema.value;
+    } else {
+      const v3Schema = methodSchema;
+      const legacyDef = v3Schema._def;
+      methodValue = legacyDef?.value ?? v3Schema.value;
+    }
+    if (typeof methodValue !== "string") {
+      throw new Error("Schema method literal must be a string");
+    }
+    const method = methodValue;
+    if (method === "tools/call") {
+      const wrappedHandler = async (request, extra) => {
+        const validatedRequest = safeParse2(CallToolRequestSchema, request);
+        if (!validatedRequest.success) {
+          const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+        }
+        const { params } = validatedRequest.data;
+        const result = await Promise.resolve(handler(request, extra));
+        if (params.task) {
+          const taskValidationResult = safeParse2(CreateTaskResultSchema, result);
+          if (!taskValidationResult.success) {
+            const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+          }
+          return taskValidationResult.data;
+        }
+        const validationResult = safeParse2(CallToolResultSchema, result);
+        if (!validationResult.success) {
+          const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+        }
+        return validationResult.data;
+      };
+      return super.setRequestHandler(requestSchema, wrappedHandler);
+    }
+    return super.setRequestHandler(requestSchema, handler);
+  }
   assertCapabilityForMethod(method) {
-    var _a, _b, _c;
     switch (method) {
       case "sampling/createMessage":
-        if (!((_a = this._clientCapabilities) === null || _a === void 0 ? void 0 : _a.sampling)) {
+        if (!this._clientCapabilities?.sampling) {
           throw new Error(`Client does not support sampling (required for ${method})`);
         }
         break;
       case "elicitation/create":
-        if (!((_b = this._clientCapabilities) === null || _b === void 0 ? void 0 : _b.elicitation)) {
+        if (!this._clientCapabilities?.elicitation) {
           throw new Error(`Client does not support elicitation (required for ${method})`);
         }
         break;
       case "roots/list":
-        if (!((_c = this._clientCapabilities) === null || _c === void 0 ? void 0 : _c.roots)) {
+        if (!this._clientCapabilities?.roots) {
           throw new Error(`Client does not support listing roots (required for ${method})`);
         }
         break;
@@ -10424,6 +11975,11 @@ var Server = class extends Protocol {
           throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
         }
         break;
+      case "notifications/elicitation/complete":
+        if (!this._clientCapabilities?.elicitation?.url) {
+          throw new Error(`Client does not support URL elicitation (required for ${method})`);
+        }
+        break;
       case "notifications/cancelled":
         break;
       case "notifications/progress":
@@ -10431,10 +11987,13 @@ var Server = class extends Protocol {
     }
   }
   assertRequestHandlerCapability(method) {
+    if (!this._capabilities) {
+      return;
+    }
     switch (method) {
-      case "sampling/createMessage":
-        if (!this._capabilities.sampling) {
-          throw new Error(`Server does not support sampling (required for ${method})`);
+      case "completion/complete":
+        if (!this._capabilities.completions) {
+          throw new Error(`Server does not support completions (required for ${method})`);
         }
         break;
       case "logging/setLevel":
@@ -10461,11 +12020,28 @@ var Server = class extends Protocol {
           throw new Error(`Server does not support tools (required for ${method})`);
         }
         break;
+      case "tasks/get":
+      case "tasks/list":
+      case "tasks/result":
+      case "tasks/cancel":
+        if (!this._capabilities.tasks) {
+          throw new Error(`Server does not support tasks capability (required for ${method})`);
+        }
+        break;
       case "ping":
       case "initialize":
         break;
     }
   }
+  assertTaskCapability(method) {
+    assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
+  }
+  assertTaskHandlerCapability(method) {
+    if (!this._capabilities) {
+      return;
+    }
+    assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server");
+  }
   async _oninitialize(request) {
     const requestedVersion = request.params.protocolVersion;
     this._clientCapabilities = request.params.capabilities;
@@ -10496,26 +12072,100 @@ var Server = class extends Protocol {
   async ping() {
     return this.request({ method: "ping" }, EmptyResultSchema);
   }
+  // Implementation
   async createMessage(params, options) {
+    if (params.tools || params.toolChoice) {
+      if (!this._clientCapabilities?.sampling?.tools) {
+        throw new Error("Client does not support sampling tools capability.");
+      }
+    }
+    if (params.messages.length > 0) {
+      const lastMessage = params.messages[params.messages.length - 1];
+      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+      const hasToolResults = lastContent.some((c) => c.type === "tool_result");
+      const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0;
+      const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
+      const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
+      if (hasToolResults) {
+        if (lastContent.some((c) => c.type !== "tool_result")) {
+          throw new Error("The last message must contain only tool_result content if any is present");
+        }
+        if (!hasPreviousToolUse) {
+          throw new Error("tool_result blocks are not matching any tool_use from the previous message");
+        }
+      }
+      if (hasPreviousToolUse) {
+        const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
+        const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
+        if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
+          throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+        }
+      }
+    }
+    if (params.tools) {
+      return this.request({ method: "sampling/createMessage", params }, CreateMessageResultWithToolsSchema, options);
+    }
     return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
   }
+  /**
+   * Creates an elicitation request for the given parameters.
+   * For backwards compatibility, `mode` may be omitted for form requests and will default to `'form'`.
+   * @param params The parameters for the elicitation request.
+   * @param options Optional request options.
+   * @returns The result of the elicitation request.
+   */
   async elicitInput(params, options) {
-    const result = await this.request({ method: "elicitation/create", params }, ElicitResultSchema, options);
-    if (result.action === "accept" && result.content && params.requestedSchema) {
-      try {
-        const validator = this._jsonSchemaValidator.getValidator(params.requestedSchema);
-        const validationResult = validator(result.content);
-        if (!validationResult.valid) {
-          throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
-        }
-      } catch (error2) {
-        if (error2 instanceof McpError) {
-          throw error2;
+    const mode = params.mode ?? "form";
+    switch (mode) {
+      case "url": {
+        if (!this._clientCapabilities?.elicitation?.url) {
+          throw new Error("Client does not support url elicitation.");
+        }
+        const urlParams = params;
+        return this.request({ method: "elicitation/create", params: urlParams }, ElicitResultSchema, options);
+      }
+      case "form": {
+        if (!this._clientCapabilities?.elicitation?.form) {
+          throw new Error("Client does not support form elicitation.");
+        }
+        const formParams = params.mode === "form" ? params : { ...params, mode: "form" };
+        const result = await this.request({ method: "elicitation/create", params: formParams }, ElicitResultSchema, options);
+        if (result.action === "accept" && result.content && formParams.requestedSchema) {
+          try {
+            const validator = this._jsonSchemaValidator.getValidator(formParams.requestedSchema);
+            const validationResult = validator(result.content);
+            if (!validationResult.valid) {
+              throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
+            }
+          } catch (error2) {
+            if (error2 instanceof McpError) {
+              throw error2;
+            }
+            throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error2 instanceof Error ? error2.message : String(error2)}`);
+          }
         }
-        throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error2 instanceof Error ? error2.message : String(error2)}`);
+        return result;
       }
     }
-    return result;
+  }
+  /**
+   * Creates a reusable callback that, when invoked, will send a `notifications/elicitation/complete`
+   * notification for the specified elicitation ID.
+   *
+   * @param elicitationId The ID of the elicitation to mark as complete.
+   * @param options Optional notification options. Useful when the completion notification should be related to a prior request.
+   * @returns A function that emits the completion notification when awaited.
+   */
+  createElicitationCompletionNotifier(elicitationId, options) {
+    if (!this._clientCapabilities?.elicitation?.url) {
+      throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
+    }
+    return () => this.notification({
+      method: "notifications/elicitation/complete",
+      params: {
+        elicitationId
+      }
+    }, options);
   }
   async listRoots(params, options) {
     return this.request({ method: "roots/list", params }, ListRootsResultSchema, options);
@@ -10553,11 +12203,11 @@ var Server = class extends Protocol {
   }
 };
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.21.1/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 init_esm_shims();
 import process2 from "process";
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.21.1/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
 init_esm_shims();
 var ReadBuffer = class {
   append(chunk) {
@@ -10586,7 +12236,7 @@ function serializeMessage(message) {
   return JSON.stringify(message) + "\n";
 }
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.21.1/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.25.1_hono@4.11.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 var StdioServerTransport = class {
   constructor(_stdin = process2.stdin, _stdout = process2.stdout) {
     this._stdin = _stdin;
@@ -10598,8 +12248,7 @@ var StdioServerTransport = class {
       this.processReadBuffer();
     };
     this._onerror = (error2) => {
-      var _a;
-      (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error2);
+      this.onerror?.(error2);
     };
   }
   /**
@@ -10614,21 +12263,19 @@ var StdioServerTransport = class {
     this._stdin.on("error", this._onerror);
   }
   processReadBuffer() {
-    var _a, _b;
     while (true) {
       try {
         const message = this._readBuffer.readMessage();
         if (message === null) {
           break;
         }
-        (_a = this.onmessage) === null || _a === void 0 ? void 0 : _a.call(this, message);
+        this.onmessage?.(message);
       } catch (error2) {
-        (_b = this.onerror) === null || _b === void 0 ? void 0 : _b.call(this, error2);
+        this.onerror?.(error2);
       }
     }
   }
   async close() {
-    var _a;
     this._stdin.off("data", this._ondata);
     this._stdin.off("error", this._onerror);
     const remainingDataListeners = this._stdin.listenerCount("data");
@@ -10636,7 +12283,7 @@ var StdioServerTransport = class {
       this._stdin.pause();
     }
     this._readBuffer.clear();
-    (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
+    this.onclose?.();
   }
   send(message) {
     return new Promise((resolve) => {
@@ -11593,7 +13240,7 @@ function showCustomHelp() {
 
 // src/version.ts
 init_esm_shims();
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { dirname, join as join3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __filename3 = fileURLToPath3(import.meta.url);
@@ -11601,7 +13248,7 @@ var __dirname3 = dirname(__filename3);
 function getVersion() {
   try {
     const packageJsonPath = join3(__dirname3, "../package.json");
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
     return packageJson.version;
   } catch {
     return "0.0.0";