@settlemint/sdk-mcp 2.3.0 → 2.3.1-pr9c56c214

package/dist/mcp.js

@@ -36456,18 +36456,18 @@ var require_help = __commonJS((exports) => {
   class Help {
     constructor() {
       this.helpWidth = undefined;
+      this.minWidthToWrap = 40;
       this.sortSubcommands = false;
       this.sortOptions = false;
       this.showGlobalOptions = false;
     }
+    prepareContext(contextOptions) {
+      this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
+    }
     visibleCommands(cmd) {
       const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
-      if (cmd._hasImplicitHelpCommand()) {
-        const [, helpName, helpArgs] = cmd._helpCommandnameAndArgs.match(/([^ ]+) *(.*)/);
-        const helpCommand = cmd.createCommand(helpName).helpOption(false);
-        helpCommand.description(cmd._helpCommandDescription);
-        if (helpArgs)
-          helpCommand.arguments(helpArgs);
+      const helpCommand = cmd._getHelpCommand();
+      if (helpCommand && !helpCommand._hidden) {
         visibleCommands.push(helpCommand);
       }
       if (this.sortSubcommands) {
@@ -36485,18 +36485,17 @@ var require_help = __commonJS((exports) => {
     }
     visibleOptions(cmd) {
       const visibleOptions = cmd.options.filter((option) => !option.hidden);
-      const showShortHelpFlag = cmd._hasHelpOption && cmd._helpShortFlag && !cmd._findOption(cmd._helpShortFlag);
-      const showLongHelpFlag = cmd._hasHelpOption && !cmd._findOption(cmd._helpLongFlag);
-      if (showShortHelpFlag || showLongHelpFlag) {
-        let helpOption;
-        if (!showShortHelpFlag) {
-          helpOption = cmd.createOption(cmd._helpLongFlag, cmd._helpDescription);
-        } else if (!showLongHelpFlag) {
-          helpOption = cmd.createOption(cmd._helpShortFlag, cmd._helpDescription);
-        } else {
-          helpOption = cmd.createOption(cmd._helpFlags, cmd._helpDescription);
+      const helpOption = cmd._getHelpOption();
+      if (helpOption && !helpOption.hidden) {
+        const removeShort = helpOption.short && cmd._findOption(helpOption.short);
+        const removeLong = helpOption.long && cmd._findOption(helpOption.long);
+        if (!removeShort && !removeLong) {
+          visibleOptions.push(helpOption);
+        } else if (helpOption.long && !removeLong) {
+          visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
+        } else if (helpOption.short && !removeShort) {
+          visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
         }
-        visibleOptions.push(helpOption);
       }
       if (this.sortOptions) {
         visibleOptions.sort(this.compareOptions);
@@ -36539,22 +36538,22 @@ var require_help = __commonJS((exports) => {
     }
     longestSubcommandTermLength(cmd, helper) {
       return helper.visibleCommands(cmd).reduce((max, command) => {
-        return Math.max(max, helper.subcommandTerm(command).length);
+        return Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command))));
       }, 0);
     }
     longestOptionTermLength(cmd, helper) {
       return helper.visibleOptions(cmd).reduce((max, option) => {
-        return Math.max(max, helper.optionTerm(option).length);
+        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
       }, 0);
     }
     longestGlobalOptionTermLength(cmd, helper) {
       return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-        return Math.max(max, helper.optionTerm(option).length);
+        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
       }, 0);
     }
     longestArgumentTermLength(cmd, helper) {
       return helper.visibleArguments(cmd).reduce((max, argument) => {
-        return Math.max(max, helper.argumentTerm(argument).length);
+        return Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument))));
       }, 0);
     }
     commandUsage(cmd) {
@@ -36592,7 +36591,11 @@ var require_help = __commonJS((exports) => {
         extraInfo.push(`env: ${option.envVar}`);
       }
       if (extraInfo.length > 0) {
-        return `${option.description} (${extraInfo.join(", ")})`;
+        const extraDescription = `(${extraInfo.join(", ")})`;
+        if (option.description) {
+          return `${option.description} ${extraDescription}`;
+        }
+        return extraDescription;
       }
       return option.description;
     }
@@ -36605,95 +36608,202 @@ var require_help = __commonJS((exports) => {
         extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
       }
       if (extraInfo.length > 0) {
-        const extraDescripton = `(${extraInfo.join(", ")})`;
+        const extraDescription = `(${extraInfo.join(", ")})`;
         if (argument.description) {
-          return `${argument.description} ${extraDescripton}`;
+          return `${argument.description} ${extraDescription}`;
         }
-        return extraDescripton;
+        return extraDescription;
       }
       return argument.description;
     }
+    formatItemList(heading, items, helper) {
+      if (items.length === 0)
+        return [];
+      return [helper.styleTitle(heading), ...items, ""];
+    }
+    groupItems(unsortedItems, visibleItems, getGroup) {
+      const result = new Map;
+      unsortedItems.forEach((item) => {
+        const group = getGroup(item);
+        if (!result.has(group))
+          result.set(group, []);
+      });
+      visibleItems.forEach((item) => {
+        const group = getGroup(item);
+        if (!result.has(group)) {
+          result.set(group, []);
+        }
+        result.get(group).push(item);
+      });
+      return result;
+    }
     formatHelp(cmd, helper) {
       const termWidth = helper.padWidth(cmd, helper);
-      const helpWidth = helper.helpWidth || 80;
-      const itemIndentWidth = 2;
-      const itemSeparatorWidth = 2;
-      function formatItem(term, description) {
-        if (description) {
-          const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-          return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
-        }
-        return term;
+      const helpWidth = helper.helpWidth ?? 80;
+      function callFormatItem(term, description) {
+        return helper.formatItem(term, termWidth, description, helper);
       }
-      function formatList(textArray) {
-        return textArray.join(`
-`).replace(/^/gm, " ".repeat(itemIndentWidth));
-      }
-      let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
+      let output = [
+        `${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`,
+        ""
+      ];
       const commandDescription = helper.commandDescription(cmd);
       if (commandDescription.length > 0) {
-        output = output.concat([helper.wrap(commandDescription, helpWidth, 0), ""]);
+        output = output.concat([
+          helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth),
+          ""
+        ]);
       }
       const argumentList = helper.visibleArguments(cmd).map((argument) => {
-        return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
+        return callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument)));
       });
-      if (argumentList.length > 0) {
-        output = output.concat(["Arguments:", formatList(argumentList), ""]);
-      }
-      const optionList = helper.visibleOptions(cmd).map((option) => {
-        return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+      output = output.concat(this.formatItemList("Arguments:", argumentList, helper));
+      const optionGroups = this.groupItems(cmd.options, helper.visibleOptions(cmd), (option) => option.helpGroupHeading ?? "Options:");
+      optionGroups.forEach((options, group) => {
+        const optionList = options.map((option) => {
+          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
+        });
+        output = output.concat(this.formatItemList(group, optionList, helper));
       });
-      if (optionList.length > 0) {
-        output = output.concat(["Options:", formatList(optionList), ""]);
-      }
-      if (this.showGlobalOptions) {
+      if (helper.showGlobalOptions) {
         const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-          return formatItem(helper.optionTerm(option), helper.optionDescription(option));
+          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
         });
-        if (globalOptionList.length > 0) {
-          output = output.concat(["Global Options:", formatList(globalOptionList), ""]);
-        }
+        output = output.concat(this.formatItemList("Global Options:", globalOptionList, helper));
       }
-      const commandList = helper.visibleCommands(cmd).map((cmd2) => {
-        return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
+      const commandGroups = this.groupItems(cmd.commands, helper.visibleCommands(cmd), (sub) => sub.helpGroup() || "Commands:");
+      commandGroups.forEach((commands, group) => {
+        const commandList = commands.map((sub) => {
+          return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(sub)), helper.styleSubcommandDescription(helper.subcommandDescription(sub)));
+        });
+        output = output.concat(this.formatItemList(group, commandList, helper));
       });
-      if (commandList.length > 0) {
-        output = output.concat(["Commands:", formatList(commandList), ""]);
-      }
       return output.join(`
 `);
     }
+    displayWidth(str) {
+      return stripColor(str).length;
+    }
+    styleTitle(str) {
+      return str;
+    }
+    styleUsage(str) {
+      return str.split(" ").map((word) => {
+        if (word === "[options]")
+          return this.styleOptionText(word);
+        if (word === "[command]")
+          return this.styleSubcommandText(word);
+        if (word[0] === "[" || word[0] === "<")
+          return this.styleArgumentText(word);
+        return this.styleCommandText(word);
+      }).join(" ");
+    }
+    styleCommandDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleOptionDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleSubcommandDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleArgumentDescription(str) {
+      return this.styleDescriptionText(str);
+    }
+    styleDescriptionText(str) {
+      return str;
+    }
+    styleOptionTerm(str) {
+      return this.styleOptionText(str);
+    }
+    styleSubcommandTerm(str) {
+      return str.split(" ").map((word) => {
+        if (word === "[options]")
+          return this.styleOptionText(word);
+        if (word[0] === "[" || word[0] === "<")
+          return this.styleArgumentText(word);
+        return this.styleSubcommandText(word);
+      }).join(" ");
+    }
+    styleArgumentTerm(str) {
+      return this.styleArgumentText(str);
+    }
+    styleOptionText(str) {
+      return str;
+    }
+    styleArgumentText(str) {
+      return str;
+    }
+    styleSubcommandText(str) {
+      return str;
+    }
+    styleCommandText(str) {
+      return str;
+    }
     padWidth(cmd, helper) {
       return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
     }
-    wrap(str, width, indent2, minColumnWidth = 40) {
-      const indents = " \\f\\t\\v   -   　\uFEFF";
-      const manualIndent = new RegExp(`[\\n][${indents}]+`);
-      if (str.match(manualIndent))
-        return str;
-      const columnWidth = width - indent2;
-      if (columnWidth < minColumnWidth)
+    preformatted(str) {
+      return /\n[^\S\r\n]/.test(str);
+    }
+    formatItem(term, termWidth, description, helper) {
+      const itemIndent = 2;
+      const itemIndentStr = " ".repeat(itemIndent);
+      if (!description)
+        return itemIndentStr + term;
+      const paddedTerm = term.padEnd(termWidth + term.length - helper.displayWidth(term));
+      const spacerWidth = 2;
+      const helpWidth = this.helpWidth ?? 80;
+      const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
+      let formattedDescription;
+      if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) {
+        formattedDescription = description;
+      } else {
+        const wrappedDescription = helper.boxWrap(description, remainingWidth);
+        formattedDescription = wrappedDescription.replace(/\n/g, `
+` + " ".repeat(termWidth + spacerWidth));
+      }
+      return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
+${itemIndentStr}`);
+    }
+    boxWrap(str, width) {
+      if (width < this.minWidthToWrap)
         return str;
-      const leadingStr = str.slice(0, indent2);
-      const columnText = str.slice(indent2).replace(`\r
-`, `
-`);
-      const indentString = " ".repeat(indent2);
-      const zeroWidthSpace = "​";
-      const breaks = `\\s${zeroWidthSpace}`;
-      const regex = new RegExp(`
-|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`, "g");
-      const lines = columnText.match(regex) || [];
-      return leadingStr + lines.map((line, i) => {
-        if (line === `
-`)
-          return "";
-        return (i > 0 ? indentString : "") + line.trimEnd();
-      }).join(`
+      const rawLines = str.split(/\r\n|\n/);
+      const chunkPattern = /[\s]*[^\s]+/g;
+      const wrappedLines = [];
+      rawLines.forEach((line) => {
+        const chunks = line.match(chunkPattern);
+        if (chunks === null) {
+          wrappedLines.push("");
+          return;
+        }
+        let sumChunks = [chunks.shift()];
+        let sumWidth = this.displayWidth(sumChunks[0]);
+        chunks.forEach((chunk) => {
+          const visibleWidth = this.displayWidth(chunk);
+          if (sumWidth + visibleWidth <= width) {
+            sumChunks.push(chunk);
+            sumWidth += visibleWidth;
+            return;
+          }
+          wrappedLines.push(sumChunks.join(""));
+          const nextChunk = chunk.trimStart();
+          sumChunks = [nextChunk];
+          sumWidth = this.displayWidth(nextChunk);
+        });
+        wrappedLines.push(sumChunks.join(""));
+      });
+      return wrappedLines.join(`
 `);
     }
   }
+  function stripColor(str) {
+    const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
+    return str.replace(sgrPattern, "");
+  }
   exports.Help = Help;
+  exports.stripColor = stripColor;
 });
 
 // ../../node_modules/commander/lib/option.js
@@ -36724,6 +36834,7 @@ var require_option = __commonJS((exports) => {
       this.argChoices = undefined;
       this.conflictsWith = [];
       this.implied = undefined;
+      this.helpGroupHeading = undefined;
     }
     default(value, description) {
       this.defaultValue = value;
@@ -36788,7 +36899,14 @@ var require_option = __commonJS((exports) => {
       return this.short.replace(/^-/, "");
     }
     attributeName() {
-      return camelcase(this.name().replace(/^no-/, ""));
+      if (this.negate) {
+        return camelcase(this.name().replace(/^no-/, ""));
+      }
+      return camelcase(this.name());
+    }
+    helpGroup(heading) {
+      this.helpGroupHeading = heading;
+      return this;
     }
     is(arg) {
       return this.short === arg || this.long === arg;
@@ -36833,18 +36951,41 @@ var require_option = __commonJS((exports) => {
   function splitOptionFlags(flags) {
     let shortFlag;
     let longFlag;
-    const flagParts = flags.split(/[ |,]+/);
-    if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
+    const shortFlagExp = /^-[^-]$/;
+    const longFlagExp = /^--[^-]/;
+    const flagParts = flags.split(/[ |,]+/).concat("guard");
+    if (shortFlagExp.test(flagParts[0]))
+      shortFlag = flagParts.shift();
+    if (longFlagExp.test(flagParts[0]))
+      longFlag = flagParts.shift();
+    if (!shortFlag && shortFlagExp.test(flagParts[0]))
       shortFlag = flagParts.shift();
-    longFlag = flagParts.shift();
-    if (!shortFlag && /^-[^-]$/.test(longFlag)) {
+    if (!shortFlag && longFlagExp.test(flagParts[0])) {
       shortFlag = longFlag;
-      longFlag = undefined;
-    }
+      longFlag = flagParts.shift();
+    }
+    if (flagParts[0].startsWith("-")) {
+      const unsupportedFlag = flagParts[0];
+      const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
+      if (/^-[^-][^-]/.test(unsupportedFlag))
+        throw new Error(`${baseError}
+- a short flag is a single dash and a single character
+  - either use a single dash and a single character (for a short flag)
+  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`);
+      if (shortFlagExp.test(unsupportedFlag))
+        throw new Error(`${baseError}
+- too many short flags`);
+      if (longFlagExp.test(unsupportedFlag))
+        throw new Error(`${baseError}
+- too many long flags`);
+      throw new Error(`${baseError}
+- unrecognised flag format`);
+    }
+    if (shortFlag === undefined && longFlag === undefined)
+      throw new Error(`option creation failed due to no flags found in '${flags}'.`);
     return { shortFlag, longFlag };
   }
   exports.Option = Option;
-  exports.splitOptionFlags = splitOptionFlags;
   exports.DualOptions = DualOptions;
 });
 
@@ -36923,15 +37064,15 @@ var require_suggestSimilar = __commonJS((exports) => {
 
 // ../../node_modules/commander/lib/command.js
 var require_command = __commonJS((exports) => {
-  var EventEmitter2 = __require("events").EventEmitter;
-  var childProcess = __require("child_process");
-  var path2 = __require("path");
-  var fs = __require("fs");
-  var process3 = __require("process");
+  var EventEmitter2 = __require("node:events").EventEmitter;
+  var childProcess = __require("node:child_process");
+  var path2 = __require("node:path");
+  var fs = __require("node:fs");
+  var process3 = __require("node:process");
   var { Argument, humanReadableArgName } = require_argument();
   var { CommanderError } = require_error3();
-  var { Help } = require_help();
-  var { Option, splitOptionFlags, DualOptions } = require_option();
+  var { Help, stripColor } = require_help();
+  var { Option, DualOptions } = require_option();
   var { suggestSimilar } = require_suggestSimilar();
 
   class Command extends EventEmitter2 {
@@ -36941,7 +37082,7 @@ var require_command = __commonJS((exports) => {
       this.options = [];
       this.parent = null;
       this._allowUnknownOption = false;
-      this._allowExcessArguments = true;
+      this._allowExcessArguments = false;
       this.registeredArguments = [];
       this._args = this.registeredArguments;
       this.args = [];
@@ -36968,35 +37109,30 @@ var require_command = __commonJS((exports) => {
       this._lifeCycleHooks = {};
       this._showHelpAfterError = false;
       this._showSuggestionAfterError = true;
+      this._savedState = null;
       this._outputConfiguration = {
         writeOut: (str) => process3.stdout.write(str),
         writeErr: (str) => process3.stderr.write(str),
+        outputError: (str, write) => write(str),
         getOutHelpWidth: () => process3.stdout.isTTY ? process3.stdout.columns : undefined,
         getErrHelpWidth: () => process3.stderr.isTTY ? process3.stderr.columns : undefined,
-        outputError: (str, write) => write(str)
+        getOutHasColors: () => useColor() ?? (process3.stdout.isTTY && process3.stdout.hasColors?.()),
+        getErrHasColors: () => useColor() ?? (process3.stderr.isTTY && process3.stderr.hasColors?.()),
+        stripColor: (str) => stripColor(str)
       };
       this._hidden = false;
-      this._hasHelpOption = true;
-      this._helpFlags = "-h, --help";
-      this._helpDescription = "display help for command";
-      this._helpShortFlag = "-h";
-      this._helpLongFlag = "--help";
+      this._helpOption = undefined;
       this._addImplicitHelpCommand = undefined;
-      this._helpCommandName = "help";
-      this._helpCommandnameAndArgs = "help [command]";
-      this._helpCommandDescription = "display help for command";
+      this._helpCommand = undefined;
       this._helpConfiguration = {};
+      this._helpGroupHeading = undefined;
+      this._defaultCommandGroup = undefined;
+      this._defaultOptionGroup = undefined;
     }
     copyInheritedSettings(sourceCommand) {
       this._outputConfiguration = sourceCommand._outputConfiguration;
-      this._hasHelpOption = sourceCommand._hasHelpOption;
-      this._helpFlags = sourceCommand._helpFlags;
-      this._helpDescription = sourceCommand._helpDescription;
-      this._helpShortFlag = sourceCommand._helpShortFlag;
-      this._helpLongFlag = sourceCommand._helpLongFlag;
-      this._helpCommandName = sourceCommand._helpCommandName;
-      this._helpCommandnameAndArgs = sourceCommand._helpCommandnameAndArgs;
-      this._helpCommandDescription = sourceCommand._helpCommandDescription;
+      this._helpOption = sourceCommand._helpOption;
+      this._helpCommand = sourceCommand._helpCommand;
       this._helpConfiguration = sourceCommand._helpConfiguration;
       this._exitCallback = sourceCommand._exitCallback;
       this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
@@ -37034,7 +37170,7 @@ var require_command = __commonJS((exports) => {
       cmd._executableFile = opts.executableFile || null;
       if (args)
         cmd.arguments(args);
-      this.commands.push(cmd);
+      this._registerCommand(cmd);
       cmd.parent = this;
       cmd.copyInheritedSettings(this);
       if (desc)
@@ -37056,7 +37192,7 @@ var require_command = __commonJS((exports) => {
     configureOutput(configuration) {
       if (configuration === undefined)
         return this._outputConfiguration;
-      Object.assign(this._outputConfiguration, configuration);
+      this._outputConfiguration = Object.assign({}, this._outputConfiguration, configuration);
       return this;
     }
     showHelpAfterError(displayHelp = true) {
@@ -37079,19 +37215,20 @@ var require_command = __commonJS((exports) => {
         this._defaultCommandName = cmd._name;
       if (opts.noHelp || opts.hidden)
         cmd._hidden = true;
-      this.commands.push(cmd);
+      this._registerCommand(cmd);
       cmd.parent = this;
+      cmd._checkForBrokenPassThrough();
       return this;
     }
     createArgument(name, description) {
       return new Argument(name, description);
     }
-    argument(name, description, fn, defaultValue) {
+    argument(name, description, parseArg, defaultValue) {
       const argument = this.createArgument(name, description);
-      if (typeof fn === "function") {
-        argument.default(defaultValue).argParser(fn);
+      if (typeof parseArg === "function") {
+        argument.default(defaultValue).argParser(parseArg);
       } else {
-        argument.default(fn);
+        argument.default(parseArg);
       }
       this.addArgument(argument);
       return this;
@@ -37113,24 +37250,48 @@ var require_command = __commonJS((exports) => {
       this.registeredArguments.push(argument);
       return this;
     }
-    addHelpCommand(enableOrNameAndArgs, description) {
-      if (enableOrNameAndArgs === false) {
-        this._addImplicitHelpCommand = false;
-      } else {
-        this._addImplicitHelpCommand = true;
-        if (typeof enableOrNameAndArgs === "string") {
-          this._helpCommandName = enableOrNameAndArgs.split(" ")[0];
-          this._helpCommandnameAndArgs = enableOrNameAndArgs;
+    helpCommand(enableOrNameAndArgs, description) {
+      if (typeof enableOrNameAndArgs === "boolean") {
+        this._addImplicitHelpCommand = enableOrNameAndArgs;
+        if (enableOrNameAndArgs && this._defaultCommandGroup) {
+          this._initCommandGroup(this._getHelpCommand());
         }
-        this._helpCommandDescription = description || this._helpCommandDescription;
+        return this;
       }
+      const nameAndArgs = enableOrNameAndArgs ?? "help [command]";
+      const [, helpName, helpArgs] = nameAndArgs.match(/([^ ]+) *(.*)/);
+      const helpDescription = description ?? "display help for command";
+      const helpCommand = this.createCommand(helpName);
+      helpCommand.helpOption(false);
+      if (helpArgs)
+        helpCommand.arguments(helpArgs);
+      if (helpDescription)
+        helpCommand.description(helpDescription);
+      this._addImplicitHelpCommand = true;
+      this._helpCommand = helpCommand;
+      if (enableOrNameAndArgs || description)
+        this._initCommandGroup(helpCommand);
       return this;
     }
-    _hasImplicitHelpCommand() {
-      if (this._addImplicitHelpCommand === undefined) {
-        return this.commands.length && !this._actionHandler && !this._findCommand("help");
+    addHelpCommand(helpCommand, deprecatedDescription) {
+      if (typeof helpCommand !== "object") {
+        this.helpCommand(helpCommand, deprecatedDescription);
+        return this;
+      }
+      this._addImplicitHelpCommand = true;
+      this._helpCommand = helpCommand;
+      this._initCommandGroup(helpCommand);
+      return this;
+    }
+    _getHelpCommand() {
+      const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand("help"));
+      if (hasImplicitHelpCommand) {
+        if (this._helpCommand === undefined) {
+          this.helpCommand(undefined, undefined);
+        }
+        return this._helpCommand;
       }
-      return this._addImplicitHelpCommand;
+      return null;
     }
     hook(event, listener) {
       const allowedValues = ["preSubcommand", "preAction", "postAction"];
@@ -37192,7 +37353,31 @@ Expecting one of '${allowedValues.join("', '")}'`);
         throw err;
       }
     }
+    _registerOption(option) {
+      const matchingOption = option.short && this._findOption(option.short) || option.long && this._findOption(option.long);
+      if (matchingOption) {
+        const matchingFlag = option.long && this._findOption(option.long) ? option.long : option.short;
+        throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
+-  already used by option '${matchingOption.flags}'`);
+      }
+      this._initOptionGroup(option);
+      this.options.push(option);
+    }
+    _registerCommand(command) {
+      const knownBy = (cmd) => {
+        return [cmd.name()].concat(cmd.aliases());
+      };
+      const alreadyUsed = knownBy(command).find((name) => this._findCommand(name));
+      if (alreadyUsed) {
+        const existingCmd = knownBy(this._findCommand(alreadyUsed)).join("|");
+        const newCmd = knownBy(command).join("|");
+        throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
+      }
+      this._initCommandGroup(command);
+      this.commands.push(command);
+    }
     addOption(option) {
+      this._registerOption(option);
       const oname = option.name();
       const name = option.attributeName();
       if (option.negate) {
@@ -37203,7 +37388,6 @@ Expecting one of '${allowedValues.join("', '")}'`);
       } else if (option.defaultValue !== undefined) {
         this.setOptionValueWithSource(name, option.defaultValue, "default");
       }
-      this.options.push(option);
       const handleOptionValue = (val, invalidValueMessage, valueSource) => {
         if (val == null && option.presetArg !== undefined) {
           val = option.presetArg;
@@ -37281,15 +37465,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     passThroughOptions(passThrough = true) {
       this._passThroughOptions = !!passThrough;
-      if (!!this.parent && passThrough && !this.parent._enablePositionalOptions) {
-        throw new Error("passThroughOptions can not be used without turning on enablePositionalOptions for parent command(s)");
-      }
+      this._checkForBrokenPassThrough();
       return this;
     }
+    _checkForBrokenPassThrough() {
+      if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) {
+        throw new Error(`passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`);
+      }
+    }
     storeOptionsAsProperties(storeAsProperties = true) {
       if (this.options.length) {
         throw new Error("call .storeOptionsAsProperties() before adding options");
       }
+      if (Object.keys(this._optionValues).length) {
+        throw new Error("call .storeOptionsAsProperties() before setting option values");
+      }
       this._storeOptionsAsProperties = !!storeAsProperties;
       return this;
     }
@@ -37328,11 +37518,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
         throw new Error("first parameter to parse must be array or undefined");
       }
       parseOptions = parseOptions || {};
-      if (argv === undefined) {
-        argv = process3.argv;
-        if (process3.versions && process3.versions.electron) {
+      if (argv === undefined && parseOptions.from === undefined) {
+        if (process3.versions?.electron) {
           parseOptions.from = "electron";
         }
+        const execArgv = process3.execArgv ?? [];
+        if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
+          parseOptions.from = "eval";
+        }
+      }
+      if (argv === undefined) {
+        argv = process3.argv;
       }
       this.rawArgs = argv.slice();
       let userArgs;
@@ -37353,6 +37549,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         case "user":
           userArgs = argv.slice(0);
           break;
+        case "eval":
+          userArgs = argv.slice(1);
+          break;
         default:
           throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
       }
@@ -37362,15 +37561,53 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return userArgs;
     }
     parse(argv, parseOptions) {
+      this._prepareForParse();
       const userArgs = this._prepareUserArgs(argv, parseOptions);
       this._parseCommand([], userArgs);
       return this;
     }
     async parseAsync(argv, parseOptions) {
+      this._prepareForParse();
       const userArgs = this._prepareUserArgs(argv, parseOptions);
       await this._parseCommand([], userArgs);
       return this;
     }
+    _prepareForParse() {
+      if (this._savedState === null) {
+        this.saveStateBeforeParse();
+      } else {
+        this.restoreStateBeforeParse();
+      }
+    }
+    saveStateBeforeParse() {
+      this._savedState = {
+        _name: this._name,
+        _optionValues: { ...this._optionValues },
+        _optionValueSources: { ...this._optionValueSources }
+      };
+    }
+    restoreStateBeforeParse() {
+      if (this._storeOptionsAsProperties)
+        throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
+- either make a new Command for each call to parse, or stop storing options as properties`);
+      this._name = this._savedState._name;
+      this._scriptPath = null;
+      this.rawArgs = [];
+      this._optionValues = { ...this._savedState._optionValues };
+      this._optionValueSources = { ...this._savedState._optionValueSources };
+      this.args = [];
+      this.processedArgs = [];
+    }
+    _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
+      if (fs.existsSync(executableFile))
+        return;
+      const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
+      const executableMissing = `'${executableFile}' does not exist
+ - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
+ - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
+ - ${executableDirMessage}`;
+      throw new Error(executableMissing);
+    }
     _executeSubCommand(subcommand, args) {
       args = args.slice();
       let launchWithNode = false;
@@ -37394,7 +37631,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let resolvedScriptPath;
         try {
           resolvedScriptPath = fs.realpathSync(this._scriptPath);
-        } catch (err) {
+        } catch {
           resolvedScriptPath = this._scriptPath;
         }
         executableDir = path2.resolve(path2.dirname(resolvedScriptPath), executableDir);
@@ -37420,6 +37657,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           proc2 = childProcess.spawn(executableFile, args, { stdio: "inherit" });
         }
       } else {
+        this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
         args.unshift(executableFile);
         args = incrementNodeInspectorPort(process3.execArgv).concat(args);
         proc2 = childProcess.spawn(process3.execPath, args, { stdio: "inherit" });
@@ -37435,21 +37673,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
         });
       }
       const exitCallback = this._exitCallback;
-      if (!exitCallback) {
-        proc2.on("close", process3.exit.bind(process3));
-      } else {
-        proc2.on("close", () => {
-          exitCallback(new CommanderError(process3.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
-        });
-      }
+      proc2.on("close", (code) => {
+        code = code ?? 1;
+        if (!exitCallback) {
+          process3.exit(code);
+        } else {
+          exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
+        }
+      });
       proc2.on("error", (err) => {
         if (err.code === "ENOENT") {
-          const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
-          const executableMissing = `'${executableFile}' does not exist
- - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
- - ${executableDirMessage}`;
-          throw new Error(executableMissing);
+          this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
         } else if (err.code === "EACCES") {
           throw new Error(`'${executableFile}' not executable`);
         }
@@ -37467,6 +37701,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       const subCommand = this._findCommand(commandName);
       if (!subCommand)
         this.help({ error: true });
+      subCommand._prepareForParse();
       let promiseChain;
       promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, "preSubcommand");
       promiseChain = this._chainOrCall(promiseChain, () => {
@@ -37486,9 +37721,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (subCommand && !subCommand._executableHandler) {
         subCommand.help();
       }
-      return this._dispatchSubcommand(subcommandName, [], [
-        this._helpLongFlag || this._helpShortFlag
-      ]);
+      return this._dispatchSubcommand(subcommandName, [], [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"]);
     }
     _checkNumberOfArguments() {
       this.registeredArguments.forEach((arg, i) => {
@@ -37582,17 +37815,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (operands && this._findCommand(operands[0])) {
         return this._dispatchSubcommand(operands[0], operands.slice(1), unknown2);
       }
-      if (this._hasImplicitHelpCommand() && operands[0] === this._helpCommandName) {
+      if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
         return this._dispatchHelpCommand(operands[1]);
       }
       if (this._defaultCommandName) {
-        outputHelpIfRequested(this, unknown2);
+        this._outputHelpIfRequested(unknown2);
         return this._dispatchSubcommand(this._defaultCommandName, operands, unknown2);
       }
       if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
         this.help({ error: true });
       }
-      outputHelpIfRequested(this, parsed.unknown);
+      this._outputHelpIfRequested(parsed.unknown);
       this._checkForMissingMandatoryOptions();
       this._checkForConflictingOptions();
       const checkForUnknownOptions = () => {
@@ -37685,6 +37918,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
       function maybeOption(arg) {
         return arg.length > 1 && arg[0] === "-";
       }
+      const negativeNumberArg = (arg) => {
+        if (!/^-\d*\.?\d+(e[+-]?\d+)?$/.test(arg))
+          return false;
+        return !this._getCommandAndAncestors().some((cmd) => cmd.options.map((opt) => opt.short).some((short) => /^-\d$/.test(short)));
+      };
       let activeVariadicOption = null;
       while (args.length) {
         const arg = args.shift();
@@ -37694,7 +37932,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           dest.push(...args);
           break;
         }
-        if (activeVariadicOption && !maybeOption(arg)) {
+        if (activeVariadicOption && (!maybeOption(arg) || negativeNumberArg(arg))) {
           this.emit(`option:${activeVariadicOption.name()}`, arg);
           continue;
         }
@@ -37709,7 +37947,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
               this.emit(`option:${option.name()}`, value);
             } else if (option.optional) {
               let value = null;
-              if (args.length > 0 && !maybeOption(args[0])) {
+              if (args.length > 0 && (!maybeOption(args[0]) || negativeNumberArg(args[0]))) {
                 value = args.shift();
               }
               this.emit(`option:${option.name()}`, value);
@@ -37740,7 +37978,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             continue;
           }
         }
-        if (maybeOption(arg)) {
+        if (dest === operands && maybeOption(arg) && !(this.commands.length === 0 && negativeNumberArg(arg))) {
           dest = unknown2;
         }
         if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown2.length === 0) {
@@ -37749,7 +37987,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             if (args.length > 0)
               unknown2.push(...args);
             break;
-          } else if (arg === this._helpCommandName && this._hasImplicitHelpCommand()) {
+          } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
             operands.push(arg);
             if (args.length > 0)
               operands.push(...args);
@@ -37911,7 +38149,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       description = description || "output the version number";
       const versionOption = this.createOption(flags, description);
       this._versionOptionName = versionOption.attributeName();
-      this.options.push(versionOption);
+      this._registerOption(versionOption);
       this.on("option:" + versionOption.name(), () => {
         this._outputConfiguration.writeOut(`${str}
 `);
@@ -37943,6 +38181,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       if (alias === command._name)
         throw new Error("Command alias can't be the same as its name");
+      const matchingCommand = this.parent?._findCommand(alias);
+      if (matchingCommand) {
+        const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
+        throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
+      }
       command._aliases.push(alias);
       return this;
     }
@@ -37959,7 +38202,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const args = this.registeredArguments.map((arg) => {
           return humanReadableArgName(arg);
         });
-        return [].concat(this.options.length || this._hasHelpOption ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
+        return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
       }
       this._usage = str;
       return this;
@@ -37970,6 +38213,32 @@ Expecting one of '${allowedValues.join("', '")}'`);
       this._name = str;
       return this;
     }
+    helpGroup(heading) {
+      if (heading === undefined)
+        return this._helpGroupHeading ?? "";
+      this._helpGroupHeading = heading;
+      return this;
+    }
+    commandsGroup(heading) {
+      if (heading === undefined)
+        return this._defaultCommandGroup ?? "";
+      this._defaultCommandGroup = heading;
+      return this;
+    }
+    optionsGroup(heading) {
+      if (heading === undefined)
+        return this._defaultOptionGroup ?? "";
+      this._defaultOptionGroup = heading;
+      return this;
+    }
+    _initOptionGroup(option) {
+      if (this._defaultOptionGroup && !option.helpGroupHeading)
+        option.helpGroup(this._defaultOptionGroup);
+    }
+    _initCommandGroup(cmd) {
+      if (this._defaultCommandGroup && !cmd.helpGroup())
+        cmd.helpGroup(this._defaultCommandGroup);
+    }
     nameFromFilename(filename) {
       this._name = path2.basename(filename, path2.extname(filename));
       return this;
@@ -37982,23 +38251,38 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     helpInformation(contextOptions) {
       const helper = this.createHelp();
-      if (helper.helpWidth === undefined) {
-        helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
-      }
-      return helper.formatHelp(this, helper);
+      const context = this._getOutputContext(contextOptions);
+      helper.prepareContext({
+        error: context.error,
+        helpWidth: context.helpWidth,
+        outputHasColors: context.hasColors
+      });
+      const text = helper.formatHelp(this, helper);
+      if (context.hasColors)
+        return text;
+      return this._outputConfiguration.stripColor(text);
     }
-    _getHelpContext(contextOptions) {
+    _getOutputContext(contextOptions) {
       contextOptions = contextOptions || {};
-      const context = { error: !!contextOptions.error };
-      let write;
-      if (context.error) {
-        write = (arg) => this._outputConfiguration.writeErr(arg);
+      const error = !!contextOptions.error;
+      let baseWrite;
+      let hasColors2;
+      let helpWidth;
+      if (error) {
+        baseWrite = (str) => this._outputConfiguration.writeErr(str);
+        hasColors2 = this._outputConfiguration.getErrHasColors();
+        helpWidth = this._outputConfiguration.getErrHelpWidth();
       } else {
-        write = (arg) => this._outputConfiguration.writeOut(arg);
-      }
-      context.write = contextOptions.write || write;
-      context.command = this;
-      return context;
+        baseWrite = (str) => this._outputConfiguration.writeOut(str);
+        hasColors2 = this._outputConfiguration.getOutHasColors();
+        helpWidth = this._outputConfiguration.getOutHelpWidth();
+      }
+      const write = (str) => {
+        if (!hasColors2)
+          str = this._outputConfiguration.stripColor(str);
+        return baseWrite(str);
+      };
+      return { error, write, hasColors: hasColors2, helpWidth };
     }
     outputHelp(contextOptions) {
       let deprecatedCallback;
@@ -38006,38 +38290,60 @@ Expecting one of '${allowedValues.join("', '")}'`);
         deprecatedCallback = contextOptions;
         contextOptions = undefined;
       }
-      const context = this._getHelpContext(contextOptions);
-      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", context));
-      this.emit("beforeHelp", context);
-      let helpInformation = this.helpInformation(context);
+      const outputContext = this._getOutputContext(contextOptions);
+      const eventContext = {
+        error: outputContext.error,
+        write: outputContext.write,
+        command: this
+      };
+      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", eventContext));
+      this.emit("beforeHelp", eventContext);
+      let helpInformation = this.helpInformation({ error: outputContext.error });
       if (deprecatedCallback) {
         helpInformation = deprecatedCallback(helpInformation);
         if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
           throw new Error("outputHelp callback must return a string or a Buffer");
         }
       }
-      context.write(helpInformation);
-      if (this._helpLongFlag) {
-        this.emit(this._helpLongFlag);
+      outputContext.write(helpInformation);
+      if (this._getHelpOption()?.long) {
+        this.emit(this._getHelpOption().long);
       }
-      this.emit("afterHelp", context);
-      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", context));
+      this.emit("afterHelp", eventContext);
+      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", eventContext));
     }
     helpOption(flags, description) {
       if (typeof flags === "boolean") {
-        this._hasHelpOption = flags;
+        if (flags) {
+          if (this._helpOption === null)
+            this._helpOption = undefined;
+          if (this._defaultOptionGroup) {
+            this._initOptionGroup(this._getHelpOption());
+          }
+        } else {
+          this._helpOption = null;
+        }
         return this;
       }
-      this._helpFlags = flags || this._helpFlags;
-      this._helpDescription = description || this._helpDescription;
-      const helpFlags = splitOptionFlags(this._helpFlags);
-      this._helpShortFlag = helpFlags.shortFlag;
-      this._helpLongFlag = helpFlags.longFlag;
+      this._helpOption = this.createOption(flags ?? "-h, --help", description ?? "display help for command");
+      if (flags || description)
+        this._initOptionGroup(this._helpOption);
+      return this;
+    }
+    _getHelpOption() {
+      if (this._helpOption === undefined) {
+        this.helpOption(undefined, undefined);
+      }
+      return this._helpOption;
+    }
+    addHelpOption(option) {
+      this._helpOption = option;
+      this._initOptionGroup(option);
       return this;
     }
     help(contextOptions) {
       this.outputHelp(contextOptions);
-      let exitCode = process3.exitCode || 0;
+      let exitCode = Number(process3.exitCode ?? 0);
       if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
         exitCode = 1;
       }
@@ -38064,12 +38370,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
       return this;
     }
-  }
-  function outputHelpIfRequested(cmd, args) {
-    const helpOption = cmd._hasHelpOption && args.find((arg) => arg === cmd._helpLongFlag || arg === cmd._helpShortFlag);
-    if (helpOption) {
-      cmd.outputHelp();
-      cmd._exit(0, "commander.helpDisplayed", "(outputHelp)");
+    _outputHelpIfRequested(args) {
+      const helpOption = this._getHelpOption();
+      const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
+      if (helpRequested) {
+        this.outputHelp();
+        this._exit(0, "commander.helpDisplayed", "(outputHelp)");
+      }
     }
   }
   function incrementNodeInspectorPort(args) {
@@ -38101,18 +38408,28 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return arg;
     });
   }
+  function useColor() {
+    if (process3.env.NO_COLOR || process3.env.FORCE_COLOR === "0" || process3.env.FORCE_COLOR === "false")
+      return false;
+    if (process3.env.FORCE_COLOR || process3.env.CLICOLOR_FORCE !== undefined)
+      return true;
+    return;
+  }
   exports.Command = Command;
+  exports.useColor = useColor;
 });
 
 // ../../node_modules/commander/index.js
-var require_commander = __commonJS((exports, module) => {
+var require_commander = __commonJS((exports) => {
   var { Argument } = require_argument();
   var { Command } = require_command();
   var { CommanderError, InvalidArgumentError } = require_error3();
   var { Help } = require_help();
   var { Option } = require_option();
-  exports = module.exports = new Command;
-  exports.program = exports;
+  exports.program = new Command;
+  exports.createCommand = (name) => new Command(name);
+  exports.createOption = (flags, description) => new Option(flags, description);
+  exports.createArgument = (name, description) => new Argument(name, description);
   exports.Command = Command;
   exports.Option = Option;
   exports.Argument = Argument;
@@ -53834,8 +54151,14 @@ var ToolSchema = z.object({
   description: z.optional(z.string()),
   inputSchema: z.object({
     type: z.literal("object"),
-    properties: z.optional(z.object({}).passthrough())
+    properties: z.optional(z.object({}).passthrough()),
+    required: z.optional(z.array(z.string()))
   }).passthrough(),
+  outputSchema: z.optional(z.object({
+    type: z.literal("object"),
+    properties: z.optional(z.object({}).passthrough()),
+    required: z.optional(z.array(z.string()))
+  }).passthrough()),
   annotations: z.optional(ToolAnnotationsSchema)
 }).passthrough();
 var ListToolsRequestSchema = PaginatedRequestSchema.extend({
@@ -53844,10 +54167,26 @@ var ListToolsRequestSchema = PaginatedRequestSchema.extend({
 var ListToolsResultSchema = PaginatedResultSchema.extend({
   tools: z.array(ToolSchema)
 });
-var CallToolResultSchema = ResultSchema.extend({
-  content: z.array(z.union([TextContentSchema, ImageContentSchema, AudioContentSchema, EmbeddedResourceSchema])),
-  isError: z.boolean().default(false).optional()
+var ContentListSchema = z.array(z.union([
+  TextContentSchema,
+  ImageContentSchema,
+  AudioContentSchema,
+  EmbeddedResourceSchema
+]));
+var CallToolUnstructuredResultSchema = ResultSchema.extend({
+  content: ContentListSchema,
+  structuredContent: z.never().optional(),
+  isError: z.optional(z.boolean())
 });
+var CallToolStructuredResultSchema = ResultSchema.extend({
+  structuredContent: z.object({}).passthrough(),
+  content: z.optional(ContentListSchema),
+  isError: z.optional(z.boolean())
+});
+var CallToolResultSchema = z.union([
+  CallToolUnstructuredResultSchema,
+  CallToolStructuredResultSchema
+]);
 var CompatibilityCallToolResultSchema = CallToolResultSchema.or(ResultSchema.extend({
   toolResult: z.unknown()
 }));
@@ -55766,7 +56105,7 @@ class McpServer {
     });
     this.server.setRequestHandler(ListToolsRequestSchema, () => ({
       tools: Object.entries(this._registeredTools).filter(([, tool]) => tool.enabled).map(([name, tool]) => {
-        return {
+        const toolDefinition = {
           name,
           description: tool.description,
           inputSchema: tool.inputSchema ? zodToJsonSchema(tool.inputSchema, {
@@ -55774,6 +56113,10 @@ class McpServer {
           }) : EMPTY_OBJECT_JSON_SCHEMA,
           annotations: tool.annotations
         };
+        if (tool.outputSchema) {
+          toolDefinition.outputSchema = zodToJsonSchema(tool.outputSchema, { strictUnions: true });
+        }
+        return toolDefinition;
       })
     }));
     this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
@@ -55784,6 +56127,7 @@ class McpServer {
       if (!tool.enabled) {
         throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
       }
+      let result;
       if (tool.inputSchema) {
         const parseResult = await tool.inputSchema.safeParseAsync(request.params.arguments);
         if (!parseResult.success) {
@@ -55792,9 +56136,9 @@ class McpServer {
         const args = parseResult.data;
         const cb = tool.callback;
         try {
-          return await Promise.resolve(cb(args, extra));
+          result = await Promise.resolve(cb(args, extra));
         } catch (error) {
-          return {
+          result = {
             content: [
               {
                 type: "text",
@@ -55807,9 +56151,9 @@ class McpServer {
       } else {
         const cb = tool.callback;
         try {
-          return await Promise.resolve(cb(extra));
+          result = await Promise.resolve(cb(extra));
         } catch (error) {
-          return {
+          result = {
             content: [
               {
                 type: "text",
@@ -55820,6 +56164,27 @@ class McpServer {
           };
         }
       }
+      if (tool.outputSchema) {
+        if (!result.structuredContent && !result.isError) {
+          throw new McpError(ErrorCode.InternalError, `Tool ${request.params.name} has outputSchema but returned no structuredContent`);
+        }
+        if (result.structuredContent && !result.content) {
+          result.content = [
+            {
+              type: "text",
+              text: JSON.stringify(result.structuredContent, null, 2)
+            }
+          ];
+        }
+      } else {
+        if (!result.content && !result.isError) {
+          throw new McpError(ErrorCode.InternalError, `Tool ${request.params.name} has no outputSchema and must return content`);
+        }
+        if (result.structuredContent) {
+          throw new McpError(ErrorCode.InternalError, `Tool ${request.params.name} has no outputSchema but returned structuredContent`);
+        }
+      }
+      return result;
     });
     this._toolHandlersInitialized = true;
   }
@@ -56053,33 +56418,13 @@ class McpServer {
       return registeredResourceTemplate;
     }
   }
-  tool(name, ...rest) {
-    if (this._registeredTools[name]) {
-      throw new Error(`Tool ${name} is already registered`);
-    }
-    let description;
-    if (typeof rest[0] === "string") {
-      description = rest.shift();
-    }
-    let paramsSchema;
-    let annotations;
-    if (rest.length > 1) {
-      const firstArg = rest[0];
-      if (isZodRawShape(firstArg)) {
-        paramsSchema = rest.shift();
-        if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShape(rest[0])) {
-          annotations = rest.shift();
-        }
-      } else if (typeof firstArg === "object" && firstArg !== null) {
-        annotations = rest.shift();
-      }
-    }
-    const cb = rest[0];
+  _createRegisteredTool(name, description, inputSchema, outputSchema, annotations, callback) {
     const registeredTool = {
       description,
-      inputSchema: paramsSchema === undefined ? undefined : z.object(paramsSchema),
+      inputSchema: inputSchema === undefined ? undefined : z.object(inputSchema),
+      outputSchema: outputSchema === undefined ? undefined : z.object(outputSchema),
       annotations,
-      callback: cb,
+      callback,
       enabled: true,
       disable: () => registeredTool.update({ enabled: false }),
       enable: () => registeredTool.update({ enabled: true }),
@@ -56108,6 +56453,38 @@ class McpServer {
     this.sendToolListChanged();
     return registeredTool;
   }
+  tool(name, ...rest) {
+    if (this._registeredTools[name]) {
+      throw new Error(`Tool ${name} is already registered`);
+    }
+    let description;
+    let inputSchema;
+    let outputSchema;
+    let annotations;
+    if (typeof rest[0] === "string") {
+      description = rest.shift();
+    }
+    if (rest.length > 1) {
+      const firstArg = rest[0];
+      if (isZodRawShape(firstArg)) {
+        inputSchema = rest.shift();
+        if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShape(rest[0])) {
+          annotations = rest.shift();
+        }
+      } else if (typeof firstArg === "object" && firstArg !== null) {
+        annotations = rest.shift();
+      }
+    }
+    const callback = rest[0];
+    return this._createRegisteredTool(name, description, inputSchema, outputSchema, annotations, callback);
+  }
+  registerTool(name, config, cb) {
+    if (this._registeredTools[name]) {
+      throw new Error(`Tool ${name} is already registered`);
+    }
+    const { description, inputSchema, outputSchema, annotations } = config;
+    return this._createRegisteredTool(name, description, inputSchema, outputSchema, annotations, cb);
+  }
   prompt(name, ...rest) {
     if (this._registeredPrompts[name]) {
       throw new Error(`Prompt ${name} is already registered`);
@@ -56300,7 +56677,7 @@ class StdioServerTransport {
 }
 
 // ../utils/dist/environment.mjs
-import { join as join2 } from "node:path";
+import { join as join2 } from "path";
 
 // ../../node_modules/yoctocolors/base.js
 import tty from "node:tty";
@@ -61874,7 +62251,7 @@ var {
 var package_default = {
   name: "@settlemint/sdk-mcp",
   description: "MCP interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "2.3.0",
+  version: "2.3.1-pr9c56c214",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -61915,11 +62292,11 @@ var package_default = {
   dependencies: {
     "@graphql-tools/load": "8.1.0",
     "@graphql-tools/url-loader": "8.0.31",
-    "@modelcontextprotocol/sdk": "1.11.3",
-    "@settlemint/sdk-js": "2.3.0",
-    "@settlemint/sdk-utils": "2.3.0",
+    "@modelcontextprotocol/sdk": "1.11.4",
+    "@settlemint/sdk-js": "2.3.1-pr9c56c214",
+    "@settlemint/sdk-utils": "2.3.1-pr9c56c214",
     "@commander-js/extra-typings": "11.1.0",
-    commander: "11.1.0",
+    commander: "14.0.0",
     zod: "3.24.4"
   },
   devDependencies: {},
@@ -64207,7 +64584,7 @@ function initGraphQLTada() {
 var t3 = initGraphQLTada();
 
 // ../js/dist/settlemint.mjs
-import { createHash } from "node:crypto";
+import { createHash } from "crypto";
 var graphql = initGraphQLTada();
 var WorkspaceFragment = graphql(`
     fragment Workspace on Workspace {
@@ -67687,4 +68064,4 @@ await main().catch((error2) => {
   process.exit(1);
 });
 
-//# debugId=433800AB979D17CA64756E2164756E21
+//# debugId=401A80C2AAF1B2E464756E2164756E21