@aku11i/phantom 3.2.0 → 3.3.1

package/phantom.js

@@ -3318,8 +3318,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path3) {
-      let input = path3;
+    function removeDotSegments(path4) {
+      let input = path4;
       const output2 = [];
       let nextSlash = -1;
       let len = 0;
@@ -3518,8 +3518,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path3, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path3 && path3 !== "/" ? path3 : void 0;
+        const [path4, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path4 && path4 !== "/" ? path4 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -7476,7 +7476,7 @@ function $constructor(name, initializer3, params) {
   Object.defineProperty(_, "name", { value: name });
   return _;
 }
-var $brand = Symbol("zod_brand");
+var $brand = /* @__PURE__ */ Symbol("zod_brand");
 var $ZodAsyncError = class extends Error {
   constructor() {
     super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
@@ -7622,7 +7622,7 @@ function floatSafeRemainder(val, step) {
   const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
   return valInt % stepInt / 10 ** decCount;
 }
-var EVALUATING = Symbol("evaluating");
+var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
 function defineLazy(object3, key, getter) {
   let value = void 0;
   Object.defineProperty(object3, key, {
@@ -7667,10 +7667,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema5) {
   return mergeDefs(schema5._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path4) {
+  if (!path4)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path4.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8036,11 +8036,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path4, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path4);
     return iss;
   });
 }
@@ -8202,7 +8202,7 @@ function formatError(error46, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error46, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error47, path3 = []) => {
+  const processError = (error47, path4 = []) => {
     var _a2, _b;
     for (const issue2 of error47.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -8212,7 +8212,7 @@ function treeifyError(error46, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path4, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8244,8 +8244,8 @@ function treeifyError(error46, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path4) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -16705,8 +16705,8 @@ function yo_default() {
 
 // ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v4/core/registries.js
 var _a;
-var $output = Symbol("ZodOutput");
-var $input = Symbol("ZodInput");
+var $output = /* @__PURE__ */ Symbol("ZodOutput");
+var $input = /* @__PURE__ */ Symbol("ZodInput");
 var $ZodRegistry = class {
   constructor() {
     this._map = /* @__PURE__ */ new WeakMap();
@@ -19601,8 +19601,8 @@ function validateConfig(config2) {
   const result = phantomConfigSchema.safeParse(config2);
   if (!result.success) {
     const firstError = result.error.issues[0];
-    const path3 = firstError.path.join(".");
-    const message = path3 ? `${path3}: ${firstError.message}` : firstError.message;
+    const path4 = firstError.path.join(".");
+    const message = path4 ? `${path4}: ${firstError.message}` : firstError.message;
     return err(new ConfigValidationError(message));
   }
   return ok(result.data);
@@ -19694,8 +19694,8 @@ async function executeGitCommandInDirectory(directory, args2) {
 
 // ../git/src/libs/add-worktree.ts
 async function addWorktree(options) {
-  const { path: path3, branch, base = "HEAD" } = options;
-  await executeGitCommand(["worktree", "add", path3, "-b", branch, base]);
+  const { path: path4, branch, base = "HEAD" } = options;
+  await executeGitCommand(["worktree", "add", path4, "-b", branch, base]);
 }
 
 // ../git/src/libs/attach-worktree.ts
@@ -19848,7 +19848,8 @@ var PreferencesValidationError = class extends Error {
 };
 var preferencesSchema = external_exports.object({
   editor: external_exports.string().optional(),
-  ai: external_exports.string().optional()
+  ai: external_exports.string().optional(),
+  worktreesDirectory: external_exports.string().optional()
 }).passthrough();
 function parsePreferences(output2) {
   if (!output2) {
@@ -19867,11 +19868,13 @@ function parsePreferences(output2) {
     if (!key.startsWith("phantom.")) {
       continue;
     }
-    const strippedKey = key.slice("phantom.".length);
+    const strippedKey = key.slice("phantom.".length).toLowerCase();
     if (strippedKey === "editor") {
       preferences.editor = value;
     } else if (strippedKey === "ai") {
       preferences.ai = value;
+    } else if (strippedKey === "worktreesdirectory") {
+      preferences.worktreesDirectory = value;
     }
   }
   const parsed = preferencesSchema.safeParse(preferences);
@@ -19897,8 +19900,15 @@ async function loadPreferences() {
 async function createContext(gitRoot) {
   const configResult = await loadConfig(gitRoot);
   const config2 = isOk(configResult) ? configResult.value : null;
-  const worktreesDirectory = config2?.worktreesDirectory;
   const preferences = await loadPreferences();
+  const worktreesDirectoryPreference = preferences.worktreesDirectory;
+  const worktreesDirectoryConfig = config2?.worktreesDirectory;
+  if (worktreesDirectoryConfig !== void 0) {
+    console.warn(
+      "The 'worktreesDirectory' option in phantom.config.json is deprecated and will be removed in the next version. Configure 'phantom preferences set worktreesDirectory <path-from-repo-root>' instead."
+    );
+  }
+  const worktreesDirectory = worktreesDirectoryPreference ?? worktreesDirectoryConfig;
   return {
     gitRoot,
     worktreesDirectory: getWorktreesDirectory(gitRoot, worktreesDirectory),
@@ -20002,15 +20012,42 @@ async function selectWithFzf(items, options = {}) {
 import {
   spawn as nodeSpawn
 } from "node:child_process";
+
+// ../process/src/resolve-windows-command-path.ts
+import { execFileSync } from "node:child_process";
+import path2 from "node:path";
+function resolveWindowsCommandPath(commandOrPath) {
+  if (process.platform !== "win32") {
+    throw new Error("resolveWindowsCommandPath is only supported on Windows");
+  }
+  if (path2.dirname(commandOrPath) !== ".") {
+    return commandOrPath;
+  }
+  try {
+    const stdout2 = execFileSync("where.exe", [commandOrPath], {
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const executablePath = stdout2.toString().split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+    if (executablePath) {
+      return executablePath;
+    }
+  } catch {
+  }
+  return commandOrPath;
+}
+
+// ../process/src/spawn.ts
 async function spawnProcess(config2) {
   return new Promise((resolve2) => {
     const { command: command2, args: args2 = [], options = {} } = config2;
-    const childProcess = nodeSpawn(command2, args2, {
+    const file2 = process.platform === "win32" ? resolveWindowsCommandPath(command2) : command2;
+    const childProcess = nodeSpawn(file2, args2, {
       stdio: "inherit",
       ...options
     });
     childProcess.on("error", (error46) => {
-      resolve2(err(new ProcessSpawnError(command2, error46.message)));
+      resolve2(err(new ProcessSpawnError(file2, error46.message)));
     });
     childProcess.on("exit", (code, signal) => {
       if (signal) {
@@ -20020,7 +20057,7 @@ async function spawnProcess(config2) {
         if (exitCode === 0) {
           resolve2(ok({ exitCode }));
         } else {
-          resolve2(err(new ProcessExecutionError(command2, exitCode)));
+          resolve2(err(new ProcessExecutionError(file2, exitCode)));
         }
       }
     });
@@ -20243,7 +20280,7 @@ import { existsSync } from "node:fs";
 
 // ../core/src/worktree/file-copier.ts
 import { copyFile, mkdir, stat } from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
 var FileCopyError = class extends Error {
   file;
   constructor(file2, message) {
@@ -20256,15 +20293,15 @@ async function copyFiles(sourceDir, targetDir, files) {
   const copiedFiles = [];
   const skippedFiles = [];
   for (const file2 of files) {
-    const sourcePath = path2.join(sourceDir, file2);
-    const targetPath = path2.join(targetDir, file2);
+    const sourcePath = path3.join(sourceDir, file2);
+    const targetPath = path3.join(targetDir, file2);
     try {
       const stats = await stat(sourcePath);
       if (!stats.isFile()) {
         skippedFiles.push(file2);
         continue;
       }
-      const targetDirPath = path2.dirname(targetPath);
+      const targetDirPath = path3.dirname(targetPath);
       await mkdir(targetDirPath, { recursive: true });
       await copyFile(sourcePath, targetPath);
       copiedFiles.push(file2);
@@ -21152,19 +21189,19 @@ _phantom_completion() {
                 return 0
             elif [[ \${words[2]} == "get" ]]; then
                 if [[ \${cword} -eq 3 ]]; then
-                    local keys="editor ai"
+                    local keys="editor ai worktreesDirectory"
                     COMPREPLY=( $(compgen -W "\${keys}" -- "\${cur}") )
                     return 0
                 fi
             elif [[ \${words[2]} == "set" ]]; then
                 if [[ \${cword} -eq 3 ]]; then
-                    local keys="editor ai"
+                    local keys="editor ai worktreesDirectory"
                     COMPREPLY=( $(compgen -W "\${keys}" -- "\${cur}") )
                     return 0
                 fi
             elif [[ \${words[2]} == "remove" ]]; then
                 if [[ \${cword} -eq 3 ]]; then
-                    local keys="editor ai"
+                    local keys="editor ai worktreesDirectory"
                     COMPREPLY=( $(compgen -W "\${keys}" -- "\${cur}") )
                     return 0
                 fi
@@ -21308,12 +21345,12 @@ complete -c phantom -n "__phantom_using_command" -a "create" -d "Create a new Gi
 complete -c phantom -n "__phantom_using_command" -a "attach" -d "Attach to an existing branch by creating a new worktree"
 complete -c phantom -n "__phantom_using_command" -a "list" -d "List all Git worktrees (phantoms)"
 complete -c phantom -n "__phantom_using_command" -a "where" -d "Output the filesystem path of a specific worktree"
-complete -c phantom -n "__phantom_using_command" -a "delete" -d "Delete a Git worktree (phantom)"
+complete -c phantom -n "__phantom_using_command" -a "delete" -d "Delete Git worktrees (phantoms)"
 complete -c phantom -n "__phantom_using_command" -a "exec" -d "Execute a command in a worktree directory"
 complete -c phantom -n "__phantom_using_command" -a "edit" -d "Open a worktree in your configured editor"
 complete -c phantom -n "__phantom_using_command" -a "ai" -d "Launch your configured AI coding assistant in a worktree"
 complete -c phantom -n "__phantom_using_command" -a "shell" -d "Open an interactive shell in a worktree directory"
-complete -c phantom -n "__phantom_using_command" -a "preferences" -d "Manage editor/ai preferences (stored in git config --global)"
+complete -c phantom -n "__phantom_using_command" -a "preferences" -d "Manage editor/ai/worktreesDirectory preferences (stored in git config --global)"
 complete -c phantom -n "__phantom_using_command" -a "github" -d "GitHub integration commands"
 complete -c phantom -n "__phantom_using_command" -a "gh" -d "GitHub integration commands (alias)"
 complete -c phantom -n "__phantom_using_command" -a "version" -d "Display phantom version information"
@@ -21379,9 +21416,9 @@ complete -c phantom -n "__phantom_using_command ai" -a "(__phantom_list_worktree
 
 # preferences command
 complete -c phantom -n "__phantom_using_command preferences" -a "get set remove" -d "Manage preferences"
-complete -c phantom -n "__phantom_using_command preferences get" -a "editor ai" -d "Preference key"
-complete -c phantom -n "__phantom_using_command preferences set" -a "editor ai" -d "Preference key"
-complete -c phantom -n "__phantom_using_command preferences remove" -a "editor ai" -d "Preference key"
+complete -c phantom -n "__phantom_using_command preferences get" -a "editor ai worktreesDirectory" -d "Preference key"
+complete -c phantom -n "__phantom_using_command preferences set" -a "editor ai worktreesDirectory" -d "Preference key"
+complete -c phantom -n "__phantom_using_command preferences remove" -a "editor ai worktreesDirectory" -d "Preference key"
 
 # shell command options
 complete -c phantom -n "__phantom_using_command shell" -l fzf -d "Use fzf for interactive selection"
@@ -21430,12 +21467,12 @@ _phantom() {
         'attach:Attach to an existing branch by creating a new worktree'
         'list:List all Git worktrees (phantoms)'
         'where:Output the filesystem path of a specific worktree'
-        'delete:Delete a Git worktree (phantom)'
+        'delete:Delete Git worktrees (phantoms)'
         'exec:Execute a command in a worktree directory'
         'edit:Open a worktree in your configured editor'
         'ai:Launch your configured AI coding assistant in a worktree'
         'shell:Open an interactive shell in a worktree directory'
-        'preferences:Manage editor/ai preferences (git config --global)'
+        'preferences:Manage editor/ai/worktreesDirectory preferences (git config --global)'
         'github:GitHub integration commands'
         'gh:GitHub integration commands (alias)'
         'version:Display phantom version information'
@@ -21468,7 +21505,7 @@ _phantom() {
                     elif [[ \${line[1]} == "shell" ]]; then
                         _arguments                             '--fzf[Use fzf for interactive selection]'                             '--tmux[Open shell in new tmux window (-t)]'                             '--tmux-vertical[Open shell in vertical split pane]'                             '--tmux-horizontal[Open shell in horizontal split pane]'                             '1:worktree:(\${(q)worktrees[@]})'
                     elif [[ \${line[1]} == "delete" ]]; then
-                        _arguments                             '--force[Force deletion even if worktree has uncommitted changes (-f)]'                             '--current[Delete the current worktree]'                             '--fzf[Use fzf for interactive selection]'                             '1:worktree:(\${(q)worktrees[@]})'
+                        _arguments                             '--force[Force deletion even if worktree has uncommitted changes (-f)]'                             '--current[Delete the current worktree]'                             '--fzf[Use fzf for interactive selection]'                             '*:worktree:(\${(q)worktrees[@]})'
                     fi
                     ;;
                 exec)
@@ -21487,7 +21524,7 @@ _phantom() {
                     _arguments                         '1:worktree:(\${(q)worktrees[@]})'
                     ;;
                 preferences)
-                    _arguments                         '1:subcommand:(get set remove)'                         '2:key:(editor ai)'
+                    _arguments                         '1:subcommand:(get set remove)'                         '2:key:(editor ai worktreesDirectory)'
                     ;;
                 completion)
                     _arguments                         '1:shell:(fish zsh bash)'
@@ -21735,7 +21772,7 @@ async function deleteHandler(args2) {
   const useFzf = values.fzf ?? false;
   if (positionals.length === 0 && !deleteCurrent && !useFzf) {
     exitWithError(
-      "Please provide a worktree name to delete, use --current to delete the current worktree, or use --fzf for interactive selection",
+      "Please provide at least one worktree name to delete, use --current to delete the current worktree, or use --fzf for interactive selection",
       exitCodes.validationError
     );
   }
@@ -21755,7 +21792,7 @@ async function deleteHandler(args2) {
   try {
     const gitRoot = await getGitRoot();
     const context = await createContext(gitRoot);
-    let worktreeName;
+    const worktreeNames = [];
     if (deleteCurrent) {
       const currentWorktree = await getCurrentWorktree(gitRoot);
       if (!currentWorktree) {
@@ -21764,7 +21801,7 @@ async function deleteHandler(args2) {
           exitCodes.validationError
         );
       }
-      worktreeName = currentWorktree;
+      worktreeNames.push(currentWorktree);
     } else if (useFzf) {
       const selectResult = await selectWorktreeWithFzf(context.gitRoot);
       if (isErr(selectResult)) {
@@ -21773,24 +21810,26 @@ async function deleteHandler(args2) {
       if (!selectResult.value) {
         exitWithSuccess();
       }
-      worktreeName = selectResult.value.name;
+      worktreeNames.push(selectResult.value.name);
     } else {
-      worktreeName = positionals[0];
+      worktreeNames.push(...positionals);
     }
-    const result = await deleteWorktree(
-      context.gitRoot,
-      context.worktreesDirectory,
-      worktreeName,
-      {
-        force: forceDelete
-      },
-      context.config?.preDelete?.commands
-    );
-    if (isErr(result)) {
-      const exitCode = result.error instanceof WorktreeNotFoundError ? exitCodes.validationError : result.error instanceof WorktreeError && result.error.message.includes("uncommitted changes") ? exitCodes.validationError : exitCodes.generalError;
-      exitWithError(result.error.message, exitCode);
+    for (const worktreeName of worktreeNames) {
+      const result = await deleteWorktree(
+        context.gitRoot,
+        context.worktreesDirectory,
+        worktreeName,
+        {
+          force: forceDelete
+        },
+        context.config?.preDelete?.commands
+      );
+      if (isErr(result)) {
+        const exitCode = result.error instanceof WorktreeNotFoundError ? exitCodes.validationError : result.error instanceof WorktreeError && result.error.message.includes("uncommitted changes") ? exitCodes.validationError : exitCodes.generalError;
+        exitWithError(result.error.message, exitCode);
+      }
+      output.log(result.value.message);
     }
-    output.log(result.value.message);
     exitWithSuccess();
   } catch (error46) {
     exitWithError(
@@ -22341,7 +22380,7 @@ function bindApi(hook2, state, name) {
   });
 }
 function Singular() {
-  const singularHookName = Symbol("Singular");
+  const singularHookName = /* @__PURE__ */ Symbol("Singular");
   const singularHookState = {
     registry: {}
   };
@@ -23190,17 +23229,17 @@ function requestLog(octokit) {
     octokit.log.debug("request", options);
     const start = Date.now();
     const requestOptions = octokit.request.endpoint.parse(options);
-    const path3 = requestOptions.url.replace(options.baseUrl, "");
+    const path4 = requestOptions.url.replace(options.baseUrl, "");
     return request2(options).then((response) => {
       const requestId = response.headers["x-github-request-id"];
       octokit.log.info(
-        `${requestOptions.method} ${path3} - ${response.status} with id ${requestId} in ${Date.now() - start}ms`
+        `${requestOptions.method} ${path4} - ${response.status} with id ${requestId} in ${Date.now() - start}ms`
       );
       return response;
     }).catch((error46) => {
       const requestId = error46.response?.headers["x-github-request-id"] || "UNKNOWN";
       octokit.log.error(
-        `${requestOptions.method} ${path3} - ${error46.status} with id ${requestId} in ${Date.now() - start}ms`
+        `${requestOptions.method} ${path4} - ${error46.status} with id ${requestId} in ${Date.now() - start}ms`
       );
       throw error46;
     });
@@ -26515,8 +26554,8 @@ function getErrorMap2() {
 
 // ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path3, errorMaps, issueData } = params;
-  const fullPath = [...path3, ...issueData.path || []];
+  const { data, path: path4, errorMaps, issueData } = params;
+  const fullPath = [...path4, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -26631,11 +26670,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@4.1.13/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path3, key) {
+  constructor(parent, value, path4, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path3;
+    this._path = path4;
     this._key = key;
   }
   get path() {
@@ -29864,7 +29903,6 @@ ZodNaN2.create = (params) => {
     ...processCreateParams(params)
   });
 };
-var BRAND = Symbol("zod_brand");
 var ZodBranded = class extends ZodType2 {
   _parse(input) {
     const { ctx } = this._processInputParams(input);
@@ -30077,7 +30115,7 @@ function object2(shape, params) {
   return new ZodMiniObject(def);
 }
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.23.0_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
 function isZ4Schema(s) {
   const schema5 = s;
   return !!schema5._zod;
@@ -30152,7 +30190,7 @@ function normalizeObjectSchema(schema5) {
   if (isZ4Schema(schema5)) {
     const v4Schema = schema5;
     const def = (_a2 = v4Schema._zod) === null || _a2 === void 0 ? void 0 : _a2.def;
-    if (def && (def.typeName === "object" || def.shape !== void 0)) {
+    if (def && (def.type === "object" || def.shape !== void 0)) {
       return schema5;
     }
   } else {
@@ -30195,7 +30233,7 @@ function isSchemaOptional(schema5) {
   var _a2, _b, _c;
   if (isZ4Schema(schema5)) {
     const v4Schema = schema5;
-    return ((_b = (_a2 = v4Schema._zod) === null || _a2 === void 0 ? void 0 : _a2.def) === null || _b === void 0 ? void 0 : _b.typeName) === "ZodOptional";
+    return ((_b = (_a2 = v4Schema._zod) === null || _a2 === void 0 ? void 0 : _a2.def) === null || _b === void 0 ? void 0 : _b.type) === "optional";
   }
   const v3Schema = schema5;
   if (typeof schema5.isOptional === "function") {
@@ -30231,20 +30269,44 @@ function getLiteralValue(schema5) {
   return void 0;
 }
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.23.0_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
-var LATEST_PROTOCOL_VERSION = "2025-06-18";
-var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-03-26", "2024-11-05", "2024-10-07"];
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
+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 = custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
 var ProgressTokenSchema = union([string2(), number2().int()]);
 var CursorSchema = string2();
+var TaskCreationParamsSchema = looseObject({
+  /**
+   * Time in milliseconds to keep task results available after completion.
+   * If null, the task has unlimited lifetime until manually cleaned up.
+   */
+  ttl: union([number2(), _null3()]).optional(),
+  /**
+   * Time in milliseconds to wait between task status requests.
+   */
+  pollInterval: number2().optional()
+});
+var RelatedTaskMetadataSchema = looseObject({
+  taskId: string2()
+});
 var RequestMetaSchema = looseObject({
   /**
    * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
    */
-  progressToken: ProgressTokenSchema.optional()
+  progressToken: ProgressTokenSchema.optional(),
+  /**
+   * If specified, this request is related to the provided task.
+   */
+  [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
 });
 var BaseRequestParamsSchema = looseObject({
+  /**
+   * If specified, the caller is requesting that the receiver create a task to represent the request.
+   * Task creation parameters are now at the top level instead of in _meta.
+   */
+  task: TaskCreationParamsSchema.optional(),
   /**
    * See [General fields: `_meta`](/specification/draft/basic/index#meta) for notes on `_meta` usage.
    */
@@ -30259,7 +30321,12 @@ var NotificationsParamsSchema = looseObject({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: record(string2(), unknown()).optional()
+  _meta: object({
+    /**
+     * If specified, this notification is related to the provided task.
+     */
+    [RELATED_TASK_META_KEY]: optional(RelatedTaskMetadataSchema)
+  }).passthrough().optional()
 });
 var NotificationSchema = object({
   method: string2(),
@@ -30270,7 +30337,12 @@ var ResultSchema = looseObject({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: record(string2(), unknown()).optional()
+  _meta: looseObject({
+    /**
+     * If specified, this result is related to the provided task.
+     */
+    [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
+  }).optional()
 });
 var RequestIdSchema = union([string2(), number2().int()]);
 var JSONRPCRequestSchema = object({
@@ -30405,6 +30477,54 @@ var ElicitationCapabilitySchema = preprocess((value) => {
   form: FormElicitationCapabilitySchema.optional(),
   url: AssertObjectSchema.optional()
 }), record(string2(), unknown()).optional()));
+var ClientTasksCapabilitySchema = object({
+  /**
+   * Present if the client supports listing tasks.
+   */
+  list: optional(object({}).passthrough()),
+  /**
+   * Present if the client supports cancelling tasks.
+   */
+  cancel: optional(object({}).passthrough()),
+  /**
+   * Capabilities for task creation on specific request types.
+   */
+  requests: optional(object({
+    /**
+     * Task support for sampling requests.
+     */
+    sampling: optional(object({
+      createMessage: optional(object({}).passthrough())
+    }).passthrough()),
+    /**
+     * Task support for elicitation requests.
+     */
+    elicitation: optional(object({
+      create: optional(object({}).passthrough())
+    }).passthrough())
+  }).passthrough())
+}).passthrough();
+var ServerTasksCapabilitySchema = object({
+  /**
+   * Present if the server supports listing tasks.
+   */
+  list: optional(object({}).passthrough()),
+  /**
+   * Present if the server supports cancelling tasks.
+   */
+  cancel: optional(object({}).passthrough()),
+  /**
+   * Capabilities for task creation on specific request types.
+   */
+  requests: optional(object({
+    /**
+     * Task support for tool requests.
+     */
+    tools: optional(object({
+      call: optional(object({}).passthrough())
+    }).passthrough())
+  }).passthrough())
+}).passthrough();
 var ClientCapabilitiesSchema = object({
   /**
    * Experimental, non-standard capabilities that the client supports.
@@ -30436,7 +30556,11 @@ var ClientCapabilitiesSchema = object({
      * Whether the client supports issuing notifications for changes to the roots list.
      */
     listChanged: boolean2().optional()
-  }).optional()
+  }).optional(),
+  /**
+   * Present if the client supports task creation.
+   */
+  tasks: optional(ClientTasksCapabilitySchema)
 });
 var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
   /**
@@ -30493,8 +30617,12 @@ var ServerCapabilitiesSchema = object({
      * Whether this server supports issuing notifications for changes to the tool list.
      */
     listChanged: boolean2().optional()
-  }).optional()
-});
+  }).optional(),
+  /**
+   * Present if the server supports task creation.
+   */
+  tasks: optional(ServerTasksCapabilitySchema)
+}).passthrough();
 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.
@@ -30558,6 +30686,62 @@ var PaginatedResultSchema = ResultSchema.extend({
    */
   nextCursor: optional(CursorSchema)
 });
+var TaskSchema = object({
+  taskId: string2(),
+  status: _enum2(["working", "input_required", "completed", "failed", "cancelled"]),
+  /**
+   * Time in milliseconds to keep task results available after completion.
+   * If null, the task has unlimited lifetime until manually cleaned up.
+   */
+  ttl: union([number2(), _null3()]),
+  /**
+   * ISO 8601 timestamp when the task was created.
+   */
+  createdAt: string2(),
+  /**
+   * ISO 8601 timestamp when the task was last updated.
+   */
+  lastUpdatedAt: string2(),
+  pollInterval: optional(number2()),
+  /**
+   * Optional diagnostic message for failed tasks or other status information.
+   */
+  statusMessage: optional(string2())
+});
+var CreateTaskResultSchema = ResultSchema.extend({
+  task: TaskSchema
+});
+var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema);
+var TaskStatusNotificationSchema = NotificationSchema.extend({
+  method: literal("notifications/tasks/status"),
+  params: TaskStatusNotificationParamsSchema
+});
+var GetTaskRequestSchema = RequestSchema.extend({
+  method: literal("tasks/get"),
+  params: BaseRequestParamsSchema.extend({
+    taskId: string2()
+  })
+});
+var GetTaskResultSchema = ResultSchema.merge(TaskSchema);
+var GetTaskPayloadRequestSchema = RequestSchema.extend({
+  method: literal("tasks/result"),
+  params: BaseRequestParamsSchema.extend({
+    taskId: string2()
+  })
+});
+var ListTasksRequestSchema = PaginatedRequestSchema.extend({
+  method: literal("tasks/list")
+});
+var ListTasksResultSchema = PaginatedResultSchema.extend({
+  tasks: array(TaskSchema)
+});
+var CancelTaskRequestSchema = RequestSchema.extend({
+  method: literal("tasks/cancel"),
+  params: BaseRequestParamsSchema.extend({
+    taskId: string2()
+  })
+});
+var CancelTaskResultSchema = ResultSchema.merge(TaskSchema);
 var ResourceContentsSchema = object({
   /**
    * The URI of this resource.
@@ -30593,6 +30777,20 @@ var BlobResourceContentsSchema = ResourceContentsSchema.extend({
    */
   blob: Base64Schema
 });
+var AnnotationsSchema = object({
+  /**
+   * Intended audience(s) for the resource.
+   */
+  audience: array(_enum2(["user", "assistant"])).optional(),
+  /**
+   * Importance hint for the resource, from 0 (least) to 1 (most).
+   */
+  priority: number2().min(0).max(1).optional(),
+  /**
+   * ISO 8601 timestamp for the most recent modification.
+   */
+  lastModified: iso_exports.datetime({ offset: true }).optional()
+});
 var ResourceSchema = object({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
@@ -30610,6 +30808,10 @@ var ResourceSchema = object({
    * The MIME type of this resource, if known.
    */
   mimeType: optional(string2()),
+  /**
+   * 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.
@@ -30633,6 +30835,10 @@ var ResourceTemplateSchema = object({
    * The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type.
    */
   mimeType: optional(string2()),
+  /**
+   * 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.
@@ -30747,6 +30953,10 @@ var TextContentSchema = object({
    * The text content of the message.
    */
   text: string2(),
+  /**
+   * 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.
@@ -30763,6 +30973,10 @@ var ImageContentSchema = object({
    * The MIME type of the image. Different providers may support different image types.
    */
   mimeType: string2(),
+  /**
+   * 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.
@@ -30779,6 +30993,10 @@ var AudioContentSchema = object({
    * The MIME type of the audio. Different providers may support different audio types.
    */
   mimeType: string2(),
+  /**
+   * 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.
@@ -30811,6 +31029,10 @@ var ToolUseContentSchema = object({
 var EmbeddedResourceSchema = object({
   type: literal("resource"),
   resource: union([TextResourceContentsSchema, BlobResourceContentsSchema]),
+  /**
+   * Optional annotations for the client.
+   */
+  annotations: AnnotationsSchema.optional(),
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
@@ -30880,6 +31102,17 @@ var ToolAnnotationsSchema = object({
    */
   openWorldHint: boolean2().optional()
 });
+var ToolExecutionSchema = 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: _enum2(["required", "optional", "forbidden"]).optional()
+});
 var ToolSchema = object({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
@@ -30910,6 +31143,10 @@ var ToolSchema = object({
    * Optional additional tool information.
    */
   annotations: optional(ToolAnnotationsSchema),
+  /**
+   * Execution-related properties for this tool.
+   */
+  execution: optional(ToolExecutionSchema),
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
@@ -31046,6 +31283,7 @@ var ToolResultContentSchema = object({
    */
   _meta: optional(object({}).passthrough())
 }).passthrough();
+var SamplingContentSchema = discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]);
 var SamplingMessageContentBlockSchema = discriminatedUnion("type", [
   TextContentSchema,
   ImageContentSchema,
@@ -31109,6 +31347,28 @@ var CreateMessageRequestSchema = RequestSchema.extend({
   params: CreateMessageRequestParamsSchema
 });
 var CreateMessageResultSchema = ResultSchema.extend({
+  /**
+   * The name of the model that generated the message.
+   */
+  model: string2(),
+  /**
+   * The reason why sampling stopped, if known.
+   *
+   * Standard values:
+   * - "endTurn": Natural end of the assistant's turn
+   * - "stopSequence": A stop sequence was encountered
+   * - "maxTokens": Maximum token limit was reached
+   *
+   * This field is an open string to allow for provider-specific stop reasons.
+   */
+  stopReason: optional(_enum2(["endTurn", "stopSequence", "maxTokens"]).or(string2())),
+  role: _enum2(["user", "assistant"]),
+  /**
+   * Response content. Single content block (text, image, or audio).
+   */
+  content: SamplingContentSchema
+});
+var CreateMessageResultWithToolsSchema = ResultSchema.extend({
   /**
    * The name of the model that generated the message.
    */
@@ -31127,7 +31387,7 @@ var CreateMessageResultSchema = ResultSchema.extend({
   stopReason: optional(_enum2(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(string2())),
   role: _enum2(["user", "assistant"]),
   /**
-   * Response content. May be ToolUseContent if stopReason is "toolUse".
+   * Response content. May be a single block or array. May include ToolUseContent if stopReason is "toolUse".
    */
   content: union([SamplingMessageContentBlockSchema, array(SamplingMessageContentBlockSchema)])
 });
@@ -31275,8 +31535,10 @@ var ElicitResultSchema = ResultSchema.extend({
   /**
    * The submitted form data, only present when action is "accept".
    * Contains values matching the requested schema.
+   * Per MCP spec, content is "typically omitted" for decline/cancel actions.
+   * We normalize null to undefined for leniency while maintaining type compatibility.
    */
-  content: record(string2(), union([string2(), number2(), boolean2(), array(string2())])).optional()
+  content: preprocess((val) => val === null ? void 0 : val, record(string2(), union([string2(), number2(), boolean2(), array(string2())])).optional())
 });
 var ResourceTemplateReferenceSchema = object({
   type: literal("ref/resource"),
@@ -31383,16 +31645,37 @@ var ClientRequestSchema = union([
   SubscribeRequestSchema,
   UnsubscribeRequestSchema,
   CallToolRequestSchema,
-  ListToolsRequestSchema
+  ListToolsRequestSchema,
+  GetTaskRequestSchema,
+  GetTaskPayloadRequestSchema,
+  ListTasksRequestSchema
 ]);
 var ClientNotificationSchema = union([
   CancelledNotificationSchema,
   ProgressNotificationSchema,
   InitializedNotificationSchema,
-  RootsListChangedNotificationSchema
+  RootsListChangedNotificationSchema,
+  TaskStatusNotificationSchema
+]);
+var ClientResultSchema = union([
+  EmptyResultSchema,
+  CreateMessageResultSchema,
+  CreateMessageResultWithToolsSchema,
+  ElicitResultSchema,
+  ListRootsResultSchema,
+  GetTaskResultSchema,
+  ListTasksResultSchema,
+  CreateTaskResultSchema
+]);
+var ServerRequestSchema = union([
+  PingRequestSchema,
+  CreateMessageRequestSchema,
+  ElicitRequestSchema,
+  ListRootsRequestSchema,
+  GetTaskRequestSchema,
+  GetTaskPayloadRequestSchema,
+  ListTasksRequestSchema
 ]);
-var ClientResultSchema = union([EmptyResultSchema, CreateMessageResultSchema, ElicitResultSchema, ListRootsResultSchema]);
-var ServerRequestSchema = union([PingRequestSchema, CreateMessageRequestSchema, ElicitRequestSchema, ListRootsRequestSchema]);
 var ServerNotificationSchema = union([
   CancelledNotificationSchema,
   ProgressNotificationSchema,
@@ -31401,6 +31684,7 @@ var ServerNotificationSchema = union([
   ResourceListChangedNotificationSchema,
   ToolListChangedNotificationSchema,
   PromptListChangedNotificationSchema,
+  TaskStatusNotificationSchema,
   ElicitationCompleteNotificationSchema
 ]);
 var ServerResultSchema = union([
@@ -31413,7 +31697,10 @@ var ServerResultSchema = union([
   ListResourceTemplatesResultSchema,
   ReadResourceResultSchema,
   CallToolResultSchema,
-  ListToolsResultSchema
+  ListToolsResultSchema,
+  GetTaskResultSchema,
+  ListTasksResultSchema,
+  CreateTaskResultSchema
 ]);
 var McpError = class _McpError extends Error {
   constructor(code, message, data) {
@@ -31447,8 +31734,13 @@ var UrlElicitationRequiredError = class extends McpError {
   }
 };
 
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
+function isTerminal(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+
 // ../../node_modules/.pnpm/zod-to-json-schema@3.25.0_zod@4.1.13/node_modules/zod-to-json-schema/dist/esm/Options.js
-var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
+var ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
 var defaultOptions = {
   name: void 0,
   $refStrategy: "root",
@@ -32731,7 +33023,7 @@ var zodToJsonSchema = (schema5, options) => {
   return combined;
 };
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.23.0_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
 function mapMiniTarget(t) {
   if (!t)
     return "draft-7";
@@ -32774,7 +33066,7 @@ function parseWithCompat(schema5, data) {
   return result.data;
 }
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.23.0_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
 var DEFAULT_REQUEST_TIMEOUT_MSEC = 6e4;
 var Protocol = class {
   constructor(_options) {
@@ -32787,9 +33079,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);
@@ -32799,6 +33092,116 @@ var Protocol = class {
       // Automatic pong by default.
       (_request) => ({})
     );
+    this._taskStore = _options === null || _options === void 0 ? void 0 : _options.taskStore;
+    this._taskMessageQueue = _options === null || _options === void 0 ? void 0 : _options.taskMessageQueue;
+    if (this._taskStore) {
+      this.setRequestHandler(GetTaskRequestSchema, async (request2, extra) => {
+        const task = await this._taskStore.getTask(request2.params.taskId, extra.sessionId);
+        if (!task) {
+          throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+        }
+        return {
+          ...task
+        };
+      });
+      this.setRequestHandler(GetTaskPayloadRequestSchema, async (request2, extra) => {
+        const handleTaskResult = async () => {
+          var _a2;
+          const taskId = request2.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 error46 = new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data);
+                    resolver(error46);
+                  }
+                } else {
+                  const messageType = queuedMessage.type === "response" ? "Response" : "Error";
+                  this._onerror(new Error(`${messageType} handler missing for request ${requestId}`));
+                }
+                continue;
+              }
+              await ((_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.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 (request2, extra) => {
+        var _a2;
+        try {
+          const { tasks, nextCursor } = await this._taskStore.listTasks((_a2 = request2.params) === null || _a2 === void 0 ? void 0 : _a2.cursor, extra.sessionId);
+          return {
+            tasks,
+            nextCursor,
+            _meta: {}
+          };
+        } catch (error46) {
+          throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error46 instanceof Error ? error46.message : String(error46)}`);
+        }
+      });
+      this.setRequestHandler(CancelTaskRequestSchema, async (request2, extra) => {
+        try {
+          const task = await this._taskStore.getTask(request2.params.taskId, extra.sessionId);
+          if (!task) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request2.params.taskId}`);
+          }
+          if (isTerminal(task.status)) {
+            throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
+          }
+          await this._taskStore.updateTaskStatus(request2.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
+          this._clearTaskQueue(request2.params.taskId);
+          const cancelledTask = await this._taskStore.getTask(request2.params.taskId, extra.sessionId);
+          if (!cancelledTask) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request2.params.taskId}`);
+          }
+          return {
+            _meta: {},
+            ...cancelledTask
+          };
+        } catch (error46) {
+          if (error46 instanceof McpError) {
+            throw error46;
+          }
+          throw new McpError(ErrorCode.InvalidRequest, `Failed to cancel task: ${error46 instanceof Error ? error46.message : String(error46)}`);
+        }
+      });
+    }
+  }
+  async _oncancel(notification) {
+    const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
+    controller === null || controller === void 0 ? void 0 : controller.abort(notification.params.reason);
   }
   _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
     this._timeoutInfo.set(messageId, {
@@ -32871,10 +33274,11 @@ var Protocol = class {
     const responseHandlers = this._responseHandlers;
     this._responseHandlers = /* @__PURE__ */ new Map();
     this._progressHandlers.clear();
+    this._taskProgressTokens.clear();
     this._pendingDebouncedNotifications.clear();
+    const error46 = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
     this._transport = void 0;
     (_a2 = this.onclose) === null || _a2 === void 0 ? void 0 : _a2.call(this);
-    const error46 = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
     for (const handler2 of responseHandlers.values()) {
       handler2(error46);
     }
@@ -32892,47 +33296,94 @@ var Protocol = class {
     Promise.resolve().then(() => handler2(notification)).catch((error46) => this._onerror(new Error(`Uncaught error in notification handler: ${error46}`)));
   }
   _onrequest(request2, extra) {
-    var _a2, _b;
+    var _a2, _b, _c, _d, _e, _f;
     const handler2 = (_a2 = this._requestHandlers.get(request2.method)) !== null && _a2 !== void 0 ? _a2 : this.fallbackRequestHandler;
     const capturedTransport = this._transport;
+    const relatedTaskId = (_d = (_c = (_b = request2.params) === null || _b === void 0 ? void 0 : _b._meta) === null || _c === void 0 ? void 0 : _c[RELATED_TASK_META_KEY]) === null || _d === void 0 ? void 0 : _d.taskId;
     if (handler2 === void 0) {
-      capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
+      const errorResponse = {
         jsonrpc: "2.0",
         id: request2.id,
         error: {
           code: ErrorCode.MethodNotFound,
           message: "Method not found"
         }
-      }).catch((error46) => this._onerror(new Error(`Failed to send an error response: ${error46}`)));
+      };
+      if (relatedTaskId && this._taskMessageQueue) {
+        this._enqueueTaskMessage(relatedTaskId, {
+          type: "error",
+          message: errorResponse,
+          timestamp: Date.now()
+        }, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId).catch((error46) => this._onerror(new Error(`Failed to enqueue error response: ${error46}`)));
+      } else {
+        capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send(errorResponse).catch((error46) => this._onerror(new Error(`Failed to send an error response: ${error46}`)));
+      }
       return;
     }
     const abortController = new AbortController();
     this._requestHandlerAbortControllers.set(request2.id, abortController);
+    const taskCreationParams = (_e = request2.params) === null || _e === void 0 ? void 0 : _e.task;
+    const taskStore = this._taskStore ? this.requestTaskStore(request2, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId) : void 0;
     const fullExtra = {
       signal: abortController.signal,
       sessionId: capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId,
-      _meta: (_b = request2.params) === null || _b === void 0 ? void 0 : _b._meta,
-      sendNotification: (notification) => this.notification(notification, { relatedRequestId: request2.id }),
-      sendRequest: (r, resultSchema, options) => this.request(r, resultSchema, { ...options, relatedRequestId: request2.id }),
+      _meta: (_f = request2.params) === null || _f === void 0 ? void 0 : _f._meta,
+      sendNotification: async (notification) => {
+        const notificationOptions = { relatedRequestId: request2.id };
+        if (relatedTaskId) {
+          notificationOptions.relatedTask = { taskId: relatedTaskId };
+        }
+        await this.notification(notification, notificationOptions);
+      },
+      sendRequest: async (r, resultSchema, options) => {
+        var _a3, _b2;
+        const requestOptions = { ...options, relatedRequestId: request2.id };
+        if (relatedTaskId && !requestOptions.relatedTask) {
+          requestOptions.relatedTask = { taskId: relatedTaskId };
+        }
+        const effectiveTaskId = (_b2 = (_a3 = requestOptions.relatedTask) === null || _a3 === void 0 ? void 0 : _a3.taskId) !== null && _b2 !== void 0 ? _b2 : relatedTaskId;
+        if (effectiveTaskId && taskStore) {
+          await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
+        }
+        return await this.request(r, resultSchema, requestOptions);
+      },
       authInfo: extra === null || extra === void 0 ? void 0 : extra.authInfo,
       requestId: request2.id,
-      requestInfo: extra === null || extra === void 0 ? void 0 : extra.requestInfo
+      requestInfo: extra === null || extra === void 0 ? void 0 : extra.requestInfo,
+      taskId: relatedTaskId,
+      taskStore,
+      taskRequestedTtl: taskCreationParams === null || taskCreationParams === void 0 ? void 0 : taskCreationParams.ttl,
+      closeSSEStream: extra === null || extra === void 0 ? void 0 : extra.closeSSEStream,
+      closeStandaloneSSEStream: extra === null || extra === void 0 ? void 0 : extra.closeStandaloneSSEStream
     };
-    Promise.resolve().then(() => handler2(request2, fullExtra)).then((result) => {
+    Promise.resolve().then(() => {
+      if (taskCreationParams) {
+        this.assertTaskHandlerCapability(request2.method);
+      }
+    }).then(() => handler2(request2, 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: request2.id
-      });
-    }, (error46) => {
+      };
+      if (relatedTaskId && this._taskMessageQueue) {
+        await this._enqueueTaskMessage(relatedTaskId, {
+          type: "response",
+          message: response,
+          timestamp: Date.now()
+        }, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId);
+      } else {
+        await (capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send(response));
+      }
+    }, async (error46) => {
       var _a3;
       if (abortController.signal.aborted) {
         return;
       }
-      return capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send({
+      const errorResponse = {
         jsonrpc: "2.0",
         id: request2.id,
         error: {
@@ -32940,7 +33391,16 @@ var Protocol = class {
           message: (_a3 = error46.message) !== null && _a3 !== void 0 ? _a3 : "Internal error",
           ...error46["data"] !== void 0 && { data: error46["data"] }
         }
-      });
+      };
+      if (relatedTaskId && this._taskMessageQueue) {
+        await this._enqueueTaskMessage(relatedTaskId, {
+          type: "error",
+          message: errorResponse,
+          timestamp: Date.now()
+        }, capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.sessionId);
+      } else {
+        await (capturedTransport === null || capturedTransport === void 0 ? void 0 : capturedTransport.send(errorResponse));
+      }
     }).catch((error46) => this._onerror(new Error(`Failed to send response: ${error46}`))).finally(() => {
       this._requestHandlerAbortControllers.delete(request2.id);
     });
@@ -32959,6 +33419,9 @@ var Protocol = class {
       try {
         this._resetTimeout(messageId);
       } catch (error46) {
+        this._responseHandlers.delete(messageId);
+        this._progressHandlers.delete(messageId);
+        this._cleanupTimeout(messageId);
         responseHandler(error46);
         return;
       }
@@ -32967,14 +33430,38 @@ var Protocol = class {
   }
   _onresponse(response) {
     const messageId = Number(response.id);
+    const resolver = this._requestResolvers.get(messageId);
+    if (resolver) {
+      this._requestResolvers.delete(messageId);
+      if (isJSONRPCResponse(response)) {
+        resolver(response);
+      } else {
+        const error46 = new McpError(response.error.code, response.error.message, response.error.data);
+        resolver(error46);
+      }
+      return;
+    }
     const handler2 = this._responseHandlers.get(messageId);
     if (handler2 === void 0) {
       this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
       return;
     }
     this._responseHandlers.delete(messageId);
-    this._progressHandlers.delete(messageId);
     this._cleanupTimeout(messageId);
+    let isTaskResponse = false;
+    if (isJSONRPCResponse(response) && response.result && typeof response.result === "object") {
+      const result = response.result;
+      if (result.task && typeof result.task === "object") {
+        const task = result.task;
+        if (typeof task.taskId === "string") {
+          isTaskResponse = true;
+          this._taskProgressTokens.set(task.taskId, messageId);
+        }
+      }
+    }
+    if (!isTaskResponse) {
+      this._progressHandlers.delete(messageId);
+    }
     if (isJSONRPCResponse(response)) {
       handler2(response);
     } else {
@@ -32993,22 +33480,120 @@ var Protocol = class {
     await ((_a2 = this._transport) === null || _a2 === void 0 ? void 0 : _a2.close());
   }
   /**
-   * Sends a request and wait for a response.
+   * Sends a request and returns an AsyncGenerator that yields response messages.
+   * The generator is guaranteed to end with either a 'result' or 'error' message.
+   *
+   * @example
+   * ```typescript
+   * const stream = protocol.requestStream(request, resultSchema, options);
+   * for await (const message of stream) {
+   *   switch (message.type) {
+   *     case 'taskCreated':
+   *       console.log('Task created:', message.task.taskId);
+   *       break;
+   *     case 'taskStatus':
+   *       console.log('Task status:', message.task.status);
+   *       break;
+   *     case 'result':
+   *       console.log('Final result:', message.result);
+   *       break;
+   *     case 'error':
+   *       console.error('Error:', message.error);
+   *       break;
+   *   }
+   * }
+   * ```
+   *
+   * @experimental Use `client.experimental.tasks.requestStream()` to access this method.
+   */
+  async *requestStream(request2, resultSchema, options) {
+    var _a2, _b, _c, _d;
+    const { task } = options !== null && options !== void 0 ? options : {};
+    if (!task) {
+      try {
+        const result = await this.request(request2, resultSchema, options);
+        yield { type: "result", result };
+      } catch (error46) {
+        yield {
+          type: "error",
+          error: error46 instanceof McpError ? error46 : new McpError(ErrorCode.InternalError, String(error46))
+        };
+      }
+      return;
+    }
+    let taskId;
+    try {
+      const createResult = await this.request(request2, 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 = (_c = (_a2 = task2.pollInterval) !== null && _a2 !== void 0 ? _a2 : (_b = this._options) === null || _b === void 0 ? void 0 : _b.defaultTaskPollInterval) !== null && _c !== void 0 ? _c : 1e3;
+        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+        (_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.throwIfAborted();
+      }
+    } catch (error46) {
+      yield {
+        type: "error",
+        error: error46 instanceof McpError ? error46 : new McpError(ErrorCode.InternalError, String(error46))
+      };
+    }
+  }
+  /**
+   * Sends a request and waits for a response.
    *
    * Do not use this method to emit notifications! Use notification() instead.
    */
   request(request2, resultSchema, options) {
-    const { relatedRequestId, resumptionToken, onresumptiontoken } = options !== null && options !== void 0 ? options : {};
+    const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options !== null && options !== void 0 ? options : {};
     return new Promise((resolve2, reject) => {
-      var _a2, _b, _c, _d, _e, _f;
+      var _a2, _b, _c, _d, _e, _f, _g;
+      const earlyReject = (error46) => {
+        reject(error46);
+      };
       if (!this._transport) {
-        reject(new Error("Not connected"));
+        earlyReject(new Error("Not connected"));
         return;
       }
       if (((_a2 = this._options) === null || _a2 === void 0 ? void 0 : _a2.enforceStrictCapabilities) === true) {
-        this.assertCapabilityForMethod(request2.method);
-      }
-      (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
+        try {
+          this.assertCapabilityForMethod(request2.method);
+          if (task) {
+            this.assertTaskCapability(request2.method);
+          }
+        } catch (e) {
+          earlyReject(e);
+          return;
+        }
+      }
+      (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
       const messageId = this._requestMessageId++;
       const jsonrpcRequest = {
         ...request2,
@@ -33025,6 +33610,21 @@ var Protocol = class {
           }
         };
       }
+      if (task) {
+        jsonrpcRequest.params = {
+          ...jsonrpcRequest.params,
+          task
+        };
+      }
+      if (relatedTask) {
+        jsonrpcRequest.params = {
+          ...jsonrpcRequest.params,
+          _meta: {
+            ...((_d = jsonrpcRequest.params) === null || _d === void 0 ? void 0 : _d._meta) || {},
+            [RELATED_TASK_META_KEY]: relatedTask
+          }
+        };
+      }
       const cancel = (reason) => {
         var _a3;
         this._responseHandlers.delete(messageId);
@@ -33037,8 +33637,9 @@ var Protocol = class {
             requestId: messageId,
             reason: String(reason)
           }
-        }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error46) => this._onerror(new Error(`Failed to send cancellation: ${error46}`)));
-        reject(reason);
+        }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error47) => this._onerror(new Error(`Failed to send cancellation: ${error47}`)));
+        const error46 = reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason));
+        reject(error46);
       };
       this._responseHandlers.set(messageId, (response) => {
         var _a3;
@@ -33059,53 +33660,150 @@ var Protocol = class {
           reject(error46);
         }
       });
-      (_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.addEventListener("abort", () => {
+      (_e = options === null || options === void 0 ? void 0 : options.signal) === null || _e === void 0 ? void 0 : _e.addEventListener("abort", () => {
         var _a3;
         cancel((_a3 = options === null || options === void 0 ? void 0 : options.signal) === null || _a3 === void 0 ? void 0 : _a3.reason);
       });
-      const timeout = (_e = options === null || options === void 0 ? void 0 : options.timeout) !== null && _e !== void 0 ? _e : DEFAULT_REQUEST_TIMEOUT_MSEC;
+      const timeout = (_f = options === null || options === void 0 ? void 0 : options.timeout) !== null && _f !== void 0 ? _f : DEFAULT_REQUEST_TIMEOUT_MSEC;
       const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
-      this._setupTimeout(messageId, timeout, options === null || options === void 0 ? void 0 : options.maxTotalTimeout, timeoutHandler, (_f = options === null || options === void 0 ? void 0 : options.resetTimeoutOnProgress) !== null && _f !== void 0 ? _f : false);
-      this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error46) => {
-        this._cleanupTimeout(messageId);
-        reject(error46);
-      });
+      this._setupTimeout(messageId, timeout, options === null || options === void 0 ? void 0 : options.maxTotalTimeout, timeoutHandler, (_g = options === null || options === void 0 ? void 0 : options.resetTimeoutOnProgress) !== null && _g !== void 0 ? _g : false);
+      const relatedTaskId = relatedTask === null || relatedTask === void 0 ? void 0 : relatedTask.taskId;
+      if (relatedTaskId) {
+        const responseResolver = (response) => {
+          const handler2 = this._responseHandlers.get(messageId);
+          if (handler2) {
+            handler2(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((error46) => {
+          this._cleanupTimeout(messageId);
+          reject(error46);
+        });
+      } else {
+        this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error46) => {
+          this._cleanupTimeout(messageId);
+          reject(error46);
+        });
+      }
     });
   }
+  /**
+   * 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 _a2, _b;
+    var _a2, _b, _c, _d, _e;
     if (!this._transport) {
       throw new Error("Not connected");
     }
     this.assertNotificationCapability(notification.method);
-    const debouncedMethods = (_b = (_a2 = this._options) === null || _a2 === void 0 ? void 0 : _a2.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 = (_a2 = options === null || options === void 0 ? void 0 : options.relatedTask) === null || _a2 === void 0 ? void 0 : _a2.taskId;
+    if (relatedTaskId) {
+      const jsonrpcNotification2 = {
+        ...notification,
+        jsonrpc: "2.0",
+        params: {
+          ...notification.params,
+          _meta: {
+            ...((_b = notification.params) === null || _b === void 0 ? void 0 : _b._meta) || {},
+            [RELATED_TASK_META_KEY]: options.relatedTask
+          }
+        }
+      };
+      await this._enqueueTaskMessage(relatedTaskId, {
+        type: "notification",
+        message: jsonrpcNotification2,
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const debouncedMethods = (_d = (_c = this._options) === null || _c === void 0 ? void 0 : _c.debouncedNotificationMethods) !== null && _d !== void 0 ? _d : [];
+    const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !(options === null || options === void 0 ? void 0 : options.relatedRequestId) && !(options === null || options === void 0 ? void 0 : options.relatedTask);
     if (canDebounce) {
       if (this._pendingDebouncedNotifications.has(notification.method)) {
         return;
       }
       this._pendingDebouncedNotifications.add(notification.method);
       Promise.resolve().then(() => {
-        var _a3;
+        var _a3, _b2;
         this._pendingDebouncedNotifications.delete(notification.method);
         if (!this._transport) {
           return;
         }
-        const jsonrpcNotification2 = {
+        let jsonrpcNotification2 = {
           ...notification,
           jsonrpc: "2.0"
         };
-        (_a3 = this._transport) === null || _a3 === void 0 ? void 0 : _a3.send(jsonrpcNotification2, options).catch((error46) => this._onerror(error46));
+        if (options === null || options === void 0 ? void 0 : options.relatedTask) {
+          jsonrpcNotification2 = {
+            ...jsonrpcNotification2,
+            params: {
+              ...jsonrpcNotification2.params,
+              _meta: {
+                ...((_a3 = jsonrpcNotification2.params) === null || _a3 === void 0 ? void 0 : _a3._meta) || {},
+                [RELATED_TASK_META_KEY]: options.relatedTask
+              }
+            }
+          };
+        }
+        (_b2 = this._transport) === null || _b2 === void 0 ? void 0 : _b2.send(jsonrpcNotification2, options).catch((error46) => this._onerror(error46));
       });
       return;
     }
-    const jsonrpcNotification = {
+    let jsonrpcNotification = {
       ...notification,
       jsonrpc: "2.0"
     };
+    if (options === null || options === void 0 ? void 0 : options.relatedTask) {
+      jsonrpcNotification = {
+        ...jsonrpcNotification,
+        params: {
+          ...jsonrpcNotification.params,
+          _meta: {
+            ...((_e = jsonrpcNotification.params) === null || _e === void 0 ? void 0 : _e._meta) || {},
+            [RELATED_TASK_META_KEY]: options.relatedTask
+          }
+        }
+      };
+    }
     await this._transport.send(jsonrpcNotification, options);
   }
   /**
@@ -33153,6 +33851,152 @@ 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) {
+    var _a2;
+    if (!this._taskStore || !this._taskMessageQueue) {
+      throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
+    }
+    const maxQueueSize = (_a2 = this._options) === null || _a2 === void 0 ? void 0 : _a2.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) {
+    var _a2, _b, _c;
+    let interval = (_b = (_a2 = this._options) === null || _a2 === void 0 ? void 0 : _a2.defaultTaskPollInterval) !== null && _b !== void 0 ? _b : 1e3;
+    try {
+      const task = await ((_c = this._taskStore) === null || _c === void 0 ? void 0 : _c.getTask(taskId));
+      if (task === null || task === void 0 ? void 0 : task.pollInterval) {
+        interval = task.pollInterval;
+      }
+    } catch (_d) {
+    }
+    return new Promise((resolve2, reject) => {
+      if (signal.aborted) {
+        reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+        return;
+      }
+      const timeoutId = setTimeout(resolve2, interval);
+      signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+        reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+      }, { once: true });
+    });
+  }
+  requestTaskStore(request2, sessionId) {
+    const taskStore = this._taskStore;
+    if (!taskStore) {
+      throw new Error("No task store configured");
+    }
+    return {
+      createTask: async (taskParams) => {
+        if (!request2) {
+          throw new Error("No request provided");
+        }
+        return await taskStore.createTask(taskParams, request2.id, {
+          method: request2.method,
+          params: request2.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 isPlainObject4(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -33174,7 +34018,7 @@ function mergeCapabilities(base, additional) {
   return result;
 }
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.23.0_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
 var import_ajv = __toESM(require_ajv(), 1);
 var import_ajv_formats = __toESM(require_dist(), 1);
 function createDefaultAjvInstance() {
@@ -33243,7 +34087,116 @@ var AjvJsonSchemaValidator = class {
   }
 };
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.23.0_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
+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(request2, resultSchema, options) {
+    return this._server.requestStream(request2, 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.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
+function assertToolsCallTaskCapability(requests, method, entityName) {
+  var _a2;
+  if (!requests) {
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  }
+  switch (method) {
+    case "tools/call":
+      if (!((_a2 = requests.tools) === null || _a2 === void 0 ? void 0 : _a2.call)) {
+        throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+      }
+      break;
+    default:
+      break;
+  }
+}
+function assertClientRequestTaskCapability(requests, method, entityName) {
+  var _a2, _b;
+  if (!requests) {
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  }
+  switch (method) {
+    case "sampling/createMessage":
+      if (!((_a2 = requests.sampling) === null || _a2 === void 0 ? void 0 : _a2.createMessage)) {
+        throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+      }
+      break;
+    case "elicitation/create":
+      if (!((_b = requests.elicitation) === null || _b === void 0 ? void 0 : _b.create)) {
+        throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
 var Server = class extends Protocol {
   /**
    * Initializes this server with the given name and version information.
@@ -33279,6 +34232,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.
    *
@@ -33290,6 +34258,58 @@ 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, handler2) {
+    var _a2, _b, _c;
+    const shape = getObjectShape(requestSchema);
+    const methodSchema = shape === null || shape === void 0 ? void 0 : shape.method;
+    if (!methodSchema) {
+      throw new Error("Schema is missing a method literal");
+    }
+    let methodValue;
+    if (isZ4Schema(methodSchema)) {
+      const v4Schema = methodSchema;
+      const v4Def = (_a2 = v4Schema._zod) === null || _a2 === void 0 ? void 0 : _a2.def;
+      methodValue = (_b = v4Def === null || v4Def === void 0 ? void 0 : v4Def.value) !== null && _b !== void 0 ? _b : v4Schema.value;
+    } else {
+      const v3Schema = methodSchema;
+      const legacyDef = v3Schema._def;
+      methodValue = (_c = legacyDef === null || legacyDef === void 0 ? void 0 : legacyDef.value) !== null && _c !== void 0 ? _c : v3Schema.value;
+    }
+    if (typeof methodValue !== "string") {
+      throw new Error("Schema method literal must be a string");
+    }
+    const method = methodValue;
+    if (method === "tools/call") {
+      const wrappedHandler = async (request2, extra) => {
+        const validatedRequest = safeParse4(CallToolRequestSchema, request2);
+        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(handler2(request2, extra));
+        if (params.task) {
+          const taskValidationResult = safeParse4(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 = safeParse4(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, handler2);
+  }
   assertCapabilityForMethod(method) {
     var _a2, _b, _c;
     switch (method) {
@@ -33348,6 +34368,9 @@ var Server = class extends Protocol {
     }
   }
   assertRequestHandlerCapability(method) {
+    if (!this._capabilities) {
+      return;
+    }
     switch (method) {
       case "completion/complete":
         if (!this._capabilities.completions) {
@@ -33378,11 +34401,30 @@ 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) {
+    var _a2, _b;
+    assertClientRequestTaskCapability((_b = (_a2 = this._clientCapabilities) === null || _a2 === void 0 ? void 0 : _a2.tasks) === null || _b === void 0 ? void 0 : _b.requests, method, "Client");
+  }
+  assertTaskHandlerCapability(method) {
+    var _a2;
+    if (!this._capabilities) {
+      return;
+    }
+    assertToolsCallTaskCapability((_a2 = this._capabilities.tasks) === null || _a2 === void 0 ? void 0 : _a2.requests, method, "Server");
+  }
   async _oninitialize(request2) {
     const requestedVersion = request2.params.protocolVersion;
     this._clientCapabilities = request2.params.capabilities;
@@ -33413,6 +34455,7 @@ var Server = class extends Protocol {
   async ping() {
     return this.request({ method: "ping" }, EmptyResultSchema);
   }
+  // Implementation
   async createMessage(params, options) {
     var _a2, _b;
     if (params.tools || params.toolChoice) {
@@ -33443,6 +34486,9 @@ var Server = class extends Protocol {
         }
       }
     }
+    if (params.tools) {
+      return this.request({ method: "sampling/createMessage", params }, CreateMessageResultWithToolsSchema, options);
+    }
     return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
   }
   /**
@@ -33543,8 +34589,8 @@ var Server = class extends Protocol {
   }
 };
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.23.0_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
-var COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
+var COMPLETABLE_SYMBOL = /* @__PURE__ */ Symbol.for("mcp.completable");
 function isCompletable(schema5) {
   return !!schema5 && typeof schema5 === "object" && COMPLETABLE_SYMBOL in schema5;
 }
@@ -33557,7 +34603,7 @@ var McpZodTypeKind;
   McpZodTypeKind2["Completable"] = "McpCompletable";
 })(McpZodTypeKind || (McpZodTypeKind = {}));
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.23.0_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
 var TOOL_NAME_REGEX = /^[A-Za-z0-9._-]{1,128}$/;
 function validateToolName(name) {
   const warnings = [];
@@ -33615,7 +34661,22 @@ function validateAndWarnToolName(name) {
   return result.isValid;
 }
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.23.0_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js
+var ExperimentalMcpServerTasks = class {
+  constructor(_mcpServer) {
+    this._mcpServer = _mcpServer;
+  }
+  registerToolTask(name, config2, handler2) {
+    const execution = { taskSupport: "required", ...config2.execution };
+    if (execution.taskSupport === "forbidden") {
+      throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
+    }
+    const mcpServerInternal = this._mcpServer;
+    return mcpServerInternal._createRegisteredTool(name, config2.title, config2.description, config2.inputSchema, config2.outputSchema, config2.annotations, execution, config2._meta, handler2);
+  }
+};
+
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
 var McpServer = class {
   constructor(serverInfo, options) {
     this._registeredResources = {};
@@ -33628,6 +34689,21 @@ var McpServer = class {
     this._promptHandlersInitialized = false;
     this.server = new Server(serverInfo, options);
   }
+  /**
+   * Access experimental features.
+   *
+   * WARNING: These APIs are experimental and may change without notice.
+   *
+   * @experimental
+   */
+  get experimental() {
+    if (!this._experimental) {
+      this._experimental = {
+        tasks: new ExperimentalMcpServerTasks(this)
+      };
+    }
+    return this._experimental;
+  }
   /**
    * Attaches to the given transport, starts it, and starts listening for messages.
    *
@@ -33667,6 +34743,7 @@ var McpServer = class {
             }) : EMPTY_OBJECT_JSON_SCHEMA;
           })(),
           annotations: tool.annotations,
+          execution: tool.execution,
           _meta: tool._meta
         };
         if (tool.outputSchema) {
@@ -33682,39 +34759,34 @@ var McpServer = class {
       })
     }));
     this.server.setRequestHandler(CallToolRequestSchema, async (request2, extra) => {
-      const tool = this._registeredTools[request2.params.name];
-      let result;
+      var _a2;
       try {
+        const tool = this._registeredTools[request2.params.name];
         if (!tool) {
           throw new McpError(ErrorCode.InvalidParams, `Tool ${request2.params.name} not found`);
         }
         if (!tool.enabled) {
           throw new McpError(ErrorCode.InvalidParams, `Tool ${request2.params.name} disabled`);
         }
-        if (tool.inputSchema) {
-          const cb = tool.callback;
-          const inputObj = normalizeObjectSchema(tool.inputSchema);
-          const schemaToParse = inputObj !== null && inputObj !== void 0 ? inputObj : tool.inputSchema;
-          const parseResult = await safeParseAsync3(schemaToParse, request2.params.arguments);
-          if (!parseResult.success) {
-            throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${request2.params.name}: ${getParseErrorMessage(parseResult.error)}`);
-          }
-          const args2 = parseResult.data;
-          result = await Promise.resolve(cb(args2, extra));
-        } else {
-          const cb = tool.callback;
-          result = await Promise.resolve(cb(extra));
+        const isTaskRequest = !!request2.params.task;
+        const taskSupport = (_a2 = tool.execution) === null || _a2 === void 0 ? void 0 : _a2.taskSupport;
+        const isTaskHandler = "createTask" in tool.handler;
+        if ((taskSupport === "required" || taskSupport === "optional") && !isTaskHandler) {
+          throw new McpError(ErrorCode.InternalError, `Tool ${request2.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
         }
-        if (tool.outputSchema && !result.isError) {
-          if (!result.structuredContent) {
-            throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${request2.params.name} has an output schema but no structured content was provided`);
-          }
-          const outputObj = normalizeObjectSchema(tool.outputSchema);
-          const parseResult = await safeParseAsync3(outputObj, result.structuredContent);
-          if (!parseResult.success) {
-            throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${request2.params.name}: ${getParseErrorMessage(parseResult.error)}`);
-          }
+        if (taskSupport === "required" && !isTaskRequest) {
+          throw new McpError(ErrorCode.MethodNotFound, `Tool ${request2.params.name} requires task augmentation (taskSupport: 'required')`);
+        }
+        if (taskSupport === "optional" && !isTaskRequest && isTaskHandler) {
+          return await this.handleAutomaticTaskPolling(tool, request2, extra);
+        }
+        const args2 = await this.validateToolInput(tool, request2.params.arguments, request2.params.name);
+        const result = await this.executeToolHandler(tool, args2, extra);
+        if (isTaskRequest) {
+          return result;
         }
+        await this.validateToolOutput(tool, result, request2.params.name);
+        return result;
       } catch (error46) {
         if (error46 instanceof McpError) {
           if (error46.code === ErrorCode.UrlElicitationRequired) {
@@ -33723,7 +34795,6 @@ var McpServer = class {
         }
         return this.createToolError(error46 instanceof Error ? error46.message : String(error46));
       }
-      return result;
     });
     this._toolHandlersInitialized = true;
   }
@@ -33744,6 +34815,102 @@ var McpServer = class {
       isError: true
     };
   }
+  /**
+   * Validates tool input arguments against the tool's input schema.
+   */
+  async validateToolInput(tool, args2, toolName) {
+    if (!tool.inputSchema) {
+      return void 0;
+    }
+    const inputObj = normalizeObjectSchema(tool.inputSchema);
+    const schemaToParse = inputObj !== null && inputObj !== void 0 ? inputObj : tool.inputSchema;
+    const parseResult = await safeParseAsync3(schemaToParse, args2);
+    if (!parseResult.success) {
+      const error46 = "error" in parseResult ? parseResult.error : "Unknown error";
+      const errorMessage = getParseErrorMessage(error46);
+      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
+    }
+    return parseResult.data;
+  }
+  /**
+   * Validates tool output against the tool's output schema.
+   */
+  async validateToolOutput(tool, result, toolName) {
+    if (!tool.outputSchema) {
+      return;
+    }
+    if (!("content" in result)) {
+      return;
+    }
+    if (result.isError) {
+      return;
+    }
+    if (!result.structuredContent) {
+      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
+    }
+    const outputObj = normalizeObjectSchema(tool.outputSchema);
+    const parseResult = await safeParseAsync3(outputObj, result.structuredContent);
+    if (!parseResult.success) {
+      const error46 = "error" in parseResult ? parseResult.error : "Unknown error";
+      const errorMessage = getParseErrorMessage(error46);
+      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
+    }
+  }
+  /**
+   * Executes a tool handler (either regular or task-based).
+   */
+  async executeToolHandler(tool, args2, extra) {
+    const handler2 = tool.handler;
+    const isTaskHandler = "createTask" in handler2;
+    if (isTaskHandler) {
+      if (!extra.taskStore) {
+        throw new Error("No task store provided.");
+      }
+      const taskExtra = { ...extra, taskStore: extra.taskStore };
+      if (tool.inputSchema) {
+        const typedHandler = handler2;
+        return await Promise.resolve(typedHandler.createTask(args2, taskExtra));
+      } else {
+        const typedHandler = handler2;
+        return await Promise.resolve(typedHandler.createTask(taskExtra));
+      }
+    }
+    if (tool.inputSchema) {
+      const typedHandler = handler2;
+      return await Promise.resolve(typedHandler(args2, extra));
+    } else {
+      const typedHandler = handler2;
+      return await Promise.resolve(typedHandler(extra));
+    }
+  }
+  /**
+   * Handles automatic task polling for tools with taskSupport 'optional'.
+   */
+  async handleAutomaticTaskPolling(tool, request2, extra) {
+    var _a2;
+    if (!extra.taskStore) {
+      throw new Error("No task store provided for task-capable tool.");
+    }
+    const args2 = await this.validateToolInput(tool, request2.params.arguments, request2.params.name);
+    const handler2 = tool.handler;
+    const taskExtra = { ...extra, taskStore: extra.taskStore };
+    const createTaskResult = args2 ? await Promise.resolve(handler2.createTask(args2, taskExtra)) : (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await Promise.resolve(handler2.createTask(taskExtra))
+    );
+    const taskId = createTaskResult.task.taskId;
+    let task = createTaskResult.task;
+    const pollInterval = (_a2 = task.pollInterval) !== null && _a2 !== void 0 ? _a2 : 5e3;
+    while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+      const updatedTask = await extra.taskStore.getTask(taskId);
+      if (!updatedTask) {
+        throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
+      }
+      task = updatedTask;
+    }
+    return await extra.taskStore.getTaskResult(taskId);
+  }
   setCompletionRequestHandler() {
     if (this._completionHandlerInitialized) {
       return;
@@ -33899,7 +35066,9 @@ var McpServer = class {
         const argsObj = normalizeObjectSchema(prompt.argsSchema);
         const parseResult = await safeParseAsync3(argsObj, request2.params.arguments);
         if (!parseResult.success) {
-          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request2.params.name}: ${getParseErrorMessage(parseResult.error)}`);
+          const error46 = "error" in parseResult ? parseResult.error : "Unknown error";
+          const errorMessage = getParseErrorMessage(error46);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request2.params.name}: ${errorMessage}`);
         }
         const args2 = parseResult.data;
         const cb = prompt.callback;
@@ -34051,7 +35220,7 @@ var McpServer = class {
     this._registeredPrompts[name] = registeredPrompt;
     return registeredPrompt;
   }
-  _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, _meta, callback) {
+  _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, handler2) {
     validateAndWarnToolName(name);
     const registeredTool = {
       title,
@@ -34059,8 +35228,9 @@ var McpServer = class {
       inputSchema: getZodSchemaObject(inputSchema),
       outputSchema: getZodSchemaObject(outputSchema),
       annotations,
+      execution,
       _meta,
-      callback,
+      handler: handler2,
       enabled: true,
       disable: () => registeredTool.update({ enabled: false }),
       enable: () => registeredTool.update({ enabled: true }),
@@ -34081,7 +35251,7 @@ var McpServer = class {
         if (typeof updates.paramsSchema !== "undefined")
           registeredTool.inputSchema = objectFromShape(updates.paramsSchema);
         if (typeof updates.callback !== "undefined")
-          registeredTool.callback = updates.callback;
+          registeredTool.handler = updates.callback;
         if (typeof updates.annotations !== "undefined")
           registeredTool.annotations = updates.annotations;
         if (typeof updates._meta !== "undefined")
@@ -34112,9 +35282,9 @@ var McpServer = class {
     }
     if (rest.length > 1) {
       const firstArg = rest[0];
-      if (isZodRawShape(firstArg)) {
+      if (isZodRawShapeCompat(firstArg)) {
         inputSchema = rest.shift();
-        if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShape(rest[0])) {
+        if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShapeCompat(rest[0])) {
           annotations = rest.shift();
         }
       } else if (typeof firstArg === "object" && firstArg !== null) {
@@ -34122,7 +35292,7 @@ var McpServer = class {
       }
     }
     const callback = rest[0];
-    return this._createRegisteredTool(name, void 0, description, inputSchema, outputSchema, annotations, void 0, callback);
+    return this._createRegisteredTool(name, void 0, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, void 0, callback);
   }
   /**
    * Registers a tool with a config object and callback.
@@ -34132,7 +35302,7 @@ var McpServer = class {
       throw new Error(`Tool ${name} is already registered`);
     }
     const { title, description, inputSchema, outputSchema, annotations, _meta } = config2;
-    return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, _meta, cb);
+    return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
   }
   prompt(name, ...rest) {
     if (this._registeredPrompts[name]) {
@@ -34211,20 +35381,29 @@ var EMPTY_OBJECT_JSON_SCHEMA = {
   type: "object",
   properties: {}
 };
-function isZodRawShape(obj) {
-  if (typeof obj !== "object" || obj === null)
-    return false;
-  const isEmptyObject = Object.keys(obj).length === 0;
-  return isEmptyObject || Object.values(obj).some(isZodTypeLike);
-}
 function isZodTypeLike(value) {
   return value !== null && typeof value === "object" && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
 }
+function isZodSchemaInstance(obj) {
+  return "_def" in obj || "_zod" in obj || isZodTypeLike(obj);
+}
+function isZodRawShapeCompat(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  if (isZodSchemaInstance(obj)) {
+    return false;
+  }
+  if (Object.keys(obj).length === 0) {
+    return true;
+  }
+  return Object.values(obj).some(isZodTypeLike);
+}
 function getZodSchemaObject(schema5) {
   if (!schema5) {
     return void 0;
   }
-  if (isZodRawShape(schema5)) {
+  if (isZodRawShapeCompat(schema5)) {
     return objectFromShape(schema5);
   }
   return schema5;
@@ -34271,10 +35450,10 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.23.0_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 import process2 from "node:process";
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.23.0_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
 var ReadBuffer = class {
   append(chunk) {
     this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
@@ -34302,7 +35481,7 @@ function serializeMessage(message) {
   return JSON.stringify(message) + "\n";
 }
 
-// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.23.0_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+// ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.24.3_zod@4.1.13/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 var StdioServerTransport = class {
   constructor(_stdin = process2.stdin, _stdout = process2.stdout) {
     this._stdin = _stdin;
@@ -34369,7 +35548,7 @@ var StdioServerTransport = class {
 // ../mcp/package.json
 var package_default = {
   name: "@aku11i/phantom-mcp",
-  version: "3.2.0",
+  version: "3.3.1",
   private: true,
   type: "module",
   main: "./src/index.ts",
@@ -34385,11 +35564,11 @@ var package_default = {
     "@aku11i/phantom-github": "workspace:*",
     "@aku11i/phantom-process": "workspace:*",
     "@aku11i/phantom-shared": "workspace:*",
-    "@modelcontextprotocol/sdk": "^1.23.0",
+    "@modelcontextprotocol/sdk": "^1.24.3",
     zod: "^4.1.13"
   },
   devDependencies: {
-    "@modelcontextprotocol/inspector": "^0.17.2"
+    "@modelcontextprotocol/inspector": "^0.17.5"
   }
 };
 
@@ -34662,6 +35841,10 @@ var preferencesHelp = {
       command: 'phantom preferences set ai "codex --full-auto"',
       description: "Set the AI assistant preference (stored as phantom.ai in git config --global)"
     },
+    {
+      command: "phantom preferences set worktreesDirectory ../phantom-worktrees",
+      description: "Store a custom worktreesDirectory (relative to the Git repository root) for all commands"
+    },
     {
       command: "phantom preferences remove editor",
       description: "Remove the editor preference (fallback to env/default)"
@@ -34674,7 +35857,10 @@ var preferencesHelp = {
     "  remove <key> Remove a preference value",
     "",
     "Preferences are saved in git config with the 'phantom.' prefix (global scope).",
-    "Supported keys: editor (used by 'phantom edit', preferred over $EDITOR) and ai (used by 'phantom ai')."
+    "Supported keys:",
+    "  editor - used by 'phantom edit', preferred over $EDITOR",
+    "  ai - used by 'phantom ai'",
+    "  worktreesDirectory - path relative to the Git repo root for storing worktrees (defaults to .git/phantom/worktrees)"
   ]
 };
 var preferencesGetHelp = {
@@ -34689,9 +35875,13 @@ var preferencesGetHelp = {
     {
       command: "phantom preferences get ai",
       description: "Show the AI assistant preference"
+    },
+    {
+      command: "phantom preferences get worktreesDirectory",
+      description: "Show the preferred worktrees directory (relative to repo root)"
     }
   ],
-  notes: ["Supported keys: editor, ai"]
+  notes: ["Supported keys: editor, ai, worktreesDirectory"]
 };
 var preferencesSetHelp = {
   name: "preferences set",
@@ -34705,9 +35895,16 @@ var preferencesSetHelp = {
     {
       command: "phantom preferences set ai claude",
       description: "Configure the AI assistant command"
+    },
+    {
+      command: "phantom preferences set worktreesDirectory ../phantom-worktrees",
+      description: "Store worktrees in ../phantom-worktrees relative to the Git repository root"
     }
   ],
-  notes: ["Supported keys: editor, ai"]
+  notes: [
+    "Supported keys: editor, ai, worktreesDirectory",
+    "For worktreesDirectory, provide a path relative to the Git repository root; defaults to .git/phantom/worktrees when unset"
+  ]
 };
 var preferencesRemoveHelp = {
   name: "preferences remove",
@@ -34721,9 +35918,13 @@ var preferencesRemoveHelp = {
     {
       command: "phantom preferences remove ai",
       description: "Unset the AI assistant preference"
+    },
+    {
+      command: "phantom preferences remove worktreesDirectory",
+      description: "Unset the custom worktrees directory preference"
     }
   ],
-  notes: ["Supported keys: editor, ai"]
+  notes: ["Supported keys: editor, ai, worktreesDirectory"]
 };
 
 // src/handlers/preferences.ts
@@ -34737,7 +35938,7 @@ async function preferencesHandler(args2) {
 
 // src/handlers/preferences-get.ts
 import { parseArgs as parseArgs10 } from "node:util";
-var supportedKeys = ["editor", "ai"];
+var supportedKeys = ["editor", "ai", "worktreesDirectory"];
 async function preferencesGetHandler(args2) {
   const { positionals } = parseArgs10({
     args: args2,
@@ -34760,7 +35961,7 @@ async function preferencesGetHandler(args2) {
   }
   try {
     const preferences = await loadPreferences();
-    const value = inputKey === "editor" ? preferences.editor : inputKey === "ai" ? preferences.ai : void 0;
+    const value = inputKey === "editor" ? preferences.editor : inputKey === "ai" ? preferences.ai : inputKey === "worktreesDirectory" ? preferences.worktreesDirectory : void 0;
     if (value === void 0) {
       output.log(
         `Preference '${inputKey}' is not set (git config --global phantom.${inputKey})`
@@ -34779,7 +35980,7 @@ async function preferencesGetHandler(args2) {
 
 // src/handlers/preferences-remove.ts
 import { parseArgs as parseArgs11 } from "node:util";
-var supportedKeys2 = ["editor", "ai"];
+var supportedKeys2 = ["editor", "ai", "worktreesDirectory"];
 async function preferencesRemoveHandler(args2) {
   const { positionals } = parseArgs11({
     args: args2,
@@ -34818,7 +36019,7 @@ async function preferencesRemoveHandler(args2) {
 }
 
 // src/handlers/preferences-set.ts
-var supportedKeys3 = ["editor", "ai"];
+var supportedKeys3 = ["editor", "ai", "worktreesDirectory"];
 async function preferencesSetHandler(args2) {
   if (args2.length < 2) {
     exitWithError(
@@ -34986,7 +36187,7 @@ import { parseArgs as parseArgs13 } from "node:util";
 // package.json
 var package_default2 = {
   name: "@aku11i/phantom-cli",
-  version: "3.2.0",
+  version: "3.3.1",
   private: true,
   type: "module",
   scripts: {
@@ -35309,8 +36510,8 @@ var createHelp = {
 // src/help/delete.ts
 var deleteHelp = {
   name: "delete",
-  description: "Delete a Git worktree",
-  usage: "phantom delete <name> [options]",
+  description: "Delete one or more Git worktrees",
+  usage: "phantom delete <name...> [options]",
   options: [
     {
       name: "force",
@@ -35334,6 +36535,10 @@ var deleteHelp = {
       description: "Delete a worktree",
       command: "phantom delete feature-auth"
     },
+    {
+      description: "Delete multiple worktrees in one command",
+      command: "phantom delete feature-auth docs-cleanup spike-login"
+    },
     {
       description: "Force delete a worktree with uncommitted changes",
       command: "phantom delete experimental --force"
@@ -35349,6 +36554,7 @@ var deleteHelp = {
   ],
   notes: [
     "By default, deletion will fail if the worktree has uncommitted changes",
+    "You can pass multiple worktree names to delete them at once",
     "The associated branch will also be deleted if it's not checked out elsewhere",
     "With --fzf, you can interactively select the worktree to delete"
   ]