@alcyone-labs/arg-parser 2.3.0 → 2.4.0

package/dist/index.cjs

@@ -31,16 +31,17 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var __flags, _throwForDuplicateFlags, _appName, _appCommandName, _subCommandName, _parameters, _handler, _throwForDuplicateFlags2, _description, _handleErrors, _autoExit, _parentParser, _lastParseResult, _inheritParentFlags, _subCommands, _flagManager, _dxtGenerator, _configurationManager, _fuzzyMode, _mcpResourcesManager, _mcpPromptsManager, _mcpNotificationsManager, _ArgParserBase_instances, _identifyCommandChainAndParsers_fn, _handleGlobalChecks_fn, _validateMandatoryFlags_fn, _applyDefaultValues_fn, _prepareAndExecuteHandler_fn, parseFlags_fn, _enableFuzzyMode_fn, displayErrorAndExit_fn, _printRecursiveToConsole_fn, _buildRecursiveString_fn, _buildRecursiveJson_fn, _handleSaveToEnvFlag_fn, _handleBuildDxtFlag_fn, _handleMcpServeFlag_fn, _getMcpServerConfiguration_fn, _startUnifiedMcpServer_fn, _findAllMcpSubCommands_fn, _parseMcpTransportOptions_fn, _ArgParser_instances, registerToolAsSubCommand_fn, _startSingleTransport_fn, processAsyncHandlerPromise_fn, _hasDate, _hasTime, _offset;
+var __flags, _throwForDuplicateFlags, _appName, _appCommandName, _subCommandName, _parameters, _handler, _throwForDuplicateFlags2, _description, _handleErrors, _autoExit, _parentParser, _lastParseResult, _inheritParentFlags, _subCommands, _flagManager, _dxtGenerator, _configurationManager, _fuzzyMode, _mcpResourcesManager, _mcpPromptsManager, _mcpNotificationsManager, _ArgParserBase_instances, _identifyCommandChainAndParsers_fn, _handleGlobalChecks_fn, _validateMandatoryFlags_fn, _applyDefaultValues_fn, _prepareAndExecuteHandler_fn, parseFlags_fn, _enableFuzzyMode_fn, displayErrorAndExit_fn, _printRecursiveToConsole_fn, _buildRecursiveString_fn, _buildRecursiveJson_fn, _handleSaveToEnvFlag_fn, _handleBuildDxtFlag_fn, _handleMcpServeFlag_fn, _resolveLoggerConfigForServe_fn, _getMcpServerConfiguration_fn, _startUnifiedMcpServer_fn, _findAllMcpSubCommands_fn, _parseMcpTransportOptions_fn, _ArgParser_instances, _resolveLoggerConfig_fn, registerToolAsSubCommand_fn, _startSingleTransport_fn, processAsyncHandlerPromise_fn, _hasDate, _hasTime, _offset;
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const fs = require("node:fs");
 const path = require("node:path");
 const magicRegexp = require("magic-regexp");
+const getTsconfig = require("get-tsconfig");
 const zod = require("zod");
 const simpleMcpLogger = require("@alcyone-labs/simple-mcp-logger");
 const process$1 = require("node:process");
 const node_crypto = require("node:crypto");
-const url = require("url");
+const node_url = require("node:url");
 var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
@@ -1084,7 +1085,7 @@ const zodFlagSchema = zod.z.object({
   allowMultiple: zod.z.boolean().default(false).describe(
     "Allow passing the same flag multiple times, e.g., `-f val1 -f val2` results in an array."
   ),
-  description: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).describe("Textual description for help messages."),
+  description: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional().describe("Textual description for help messages."),
   options: zod.z.array(zod.z.string().min(1)).min(1, "Flag must have at least one option (e.g., ['-f', '--flag'])").describe("Array of option strings, e.g., ['-f', '--flag']."),
   defaultValue: zod.z.any().optional().describe("Default value if the flag is not provided."),
   type: zod.z.union([
@@ -1105,7 +1106,10 @@ const zodFlagSchema = zod.z.object({
       // Native Object constructor
       message: "Must be Object constructor"
     }),
-    zod.z.function().args(zod.z.string()).returns(zod.z.union([zod.z.any(), zod.z.promise(zod.z.any())])),
+    zod.z.custom(
+      (val) => typeof val === "function",
+      "Must be a custom parser function"
+    ),
     // Custom parser function (value: string) => any | Promise<any>
     zod.z.string().refine(
       // String literal types
@@ -1119,24 +1123,26 @@ const zodFlagSchema = zod.z.object({
   ]).default("string").describe(
     "Expected data type (constructor or string literal) or a custom parser function. Defaults to 'string'."
   ),
-  mandatory: zod.z.union([zod.z.boolean(), zod.z.function().args(zod.z.any()).returns(zod.z.boolean())]).optional().describe(
+  mandatory: zod.z.union([
+    zod.z.boolean(),
+    zod.z.custom(
+      (val) => typeof val === "function",
+      "Must be a boolean or function"
+    )
+  ]).optional().describe(
     "Makes the flag mandatory, can be a boolean or a function conditional on other args."
   ),
   flagOnly: zod.z.boolean().default(false).describe(
     "If true, the flag's presence is noted (true/false), and any subsequent value is not consumed by this flag."
   ),
-  validate: zod.z.function().args(zod.z.any().optional(), zod.z.any().optional()).returns(
-    zod.z.union([
-      zod.z.boolean(),
-      zod.z.string(),
-      zod.z.void(),
-      zod.z.promise(zod.z.union([zod.z.boolean(), zod.z.string(), zod.z.void()]))
-    ])
-  ).optional().describe(
+  validate: zod.z.custom((val) => typeof val === "function", "Must be a validation function").optional().describe(
     "Custom validation function for the flag's value (receives value, parsedArgs)."
   ),
-  enum: zod.z.array(zod.z.any()).optional().describe("Array of allowed values for the flag.")
-}).passthrough().transform((obj) => {
+  enum: zod.z.array(zod.z.any()).optional().describe("Array of allowed values for the flag."),
+  env: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional().describe(
+    "Environment variables that should be set from this flag's value in DXT packages."
+  )
+}).transform((obj) => {
   const newObj = { ...obj };
   if ("default" in newObj && newObj["default"] !== void 0 && !("defaultValue" in newObj)) {
     newObj["defaultValue"] = newObj["default"];
@@ -1629,8 +1635,9 @@ class DxtGenerator {
           );
         }
         if (!fs__namespace.existsSync(logoPath)) {
+          const currentDir2 = typeof process !== "undefined" ? process.cwd() : "/test";
           logoPath = path__namespace.join(
-            process.cwd(),
+            currentDir2,
             "docs",
             "MCP",
             "icons",
@@ -1638,8 +1645,9 @@ class DxtGenerator {
           );
         }
         if (!fs__namespace.existsSync(logoPath)) {
+          const currentDir2 = typeof process !== "undefined" ? process.cwd() : "/test";
           logoPath = path__namespace.join(
-            process.cwd(),
+            currentDir2,
             "node_modules",
             "@alcyone-labs",
             "arg-parser",
@@ -1649,8 +1657,9 @@ class DxtGenerator {
           );
         }
         if (!fs__namespace.existsSync(logoPath)) {
+          const currentDir2 = typeof process !== "undefined" ? process.cwd() : "/test";
           logoPath = path__namespace.join(
-            process.cwd(),
+            currentDir2,
             "dist",
             "assets",
             "logo_1_small.jpg"
@@ -1685,12 +1694,12 @@ class DxtGenerator {
    * Builds a complete DXT package using TSDown CLI for autonomous execution
    */
   async buildDxtWithTsdown(entryPointFile, outputDir = "./dxt", withNodeModules = false) {
+    var _a, _b;
     try {
       console.log(simpleChalk.cyan("🔧 Building DXT package with TSDown..."));
       const projectRoot = this.findProjectRoot(entryPointFile);
       const absoluteEntryPath = path__namespace.resolve(entryPointFile);
       const relativeEntryPath = path__namespace.relative(projectRoot, absoluteEntryPath);
-      const entryFileName = path__namespace.basename(entryPointFile);
       console.log(simpleChalk.gray(`Entry point: ${entryPointFile}`));
       console.log(simpleChalk.gray(`Project root: ${projectRoot}`));
       console.log(simpleChalk.gray(`Relative entry path: ${relativeEntryPath}`));
@@ -1707,9 +1716,8 @@ class DxtGenerator {
       console.log(
         logoFilename ? simpleChalk.gray(`✓ Logo prepared: ${logoFilename}`) : simpleChalk.gray("⚠ No logo available")
       );
-      const originalCwd = process.cwd();
+      const originalCwd = typeof process !== "undefined" ? process.cwd() : "/test";
       try {
-        process.chdir(projectRoot);
         const { build } = await import("tsdown");
         console.log(simpleChalk.gray(`Building with TSDown: ${relativeEntryPath}`));
         console.log(
@@ -1717,23 +1725,51 @@ class DxtGenerator {
             `${withNodeModules ? "with node_modules" : "without node_modules"}`
           )
         );
+        const mcpConfig = (_b = (_a = this.argParserInstance).getMcpServerConfig) == null ? void 0 : _b.call(_a);
+        const entryDir = path__namespace.dirname(relativeEntryPath);
+        const preservedOutDir = entryDir !== "." && entryDir !== "" ? path__namespace.resolve(originalCwd, outputDir, entryDir) : path__namespace.resolve(originalCwd, outputDir);
         const buildConfig = {
           entry: [relativeEntryPath],
-          outDir: path__namespace.resolve(originalCwd, outputDir),
+          outDir: preservedOutDir,
           format: ["es"],
           target: "node22",
           define: {
             // Define any compile-time constants
-            NODE_ENV: '"production"'
+            NODE_ENV: "production"
           },
+          dts: true,
           minify: false,
           sourcemap: false,
           // Remove all output folders and artefacts
           clean: [outputDir, "./.dxtignore", `${outputDir}.dxt`],
           silent: process.env["NO_SILENCE"] !== "1",
-          external: (_, importer) => withNodeModules ? importer == null ? void 0 : importer.includes("node_modules") : false,
-          noExternal: (_, importer) => withNodeModules ? (importer == null ? void 0 : importer.includes("node_modules")) === false : true,
+          unbundle: true,
+          external: (id, importer) => {
+            const external = this.shouldModuleBeExternal(
+              id,
+              importer,
+              withNodeModules
+            );
+            if (Boolean(process.env["DEBUG"]))
+              console.log(
+                `[${simpleChalk.blue("External")}] ${simpleChalk.yellow(external ? "true" : "false")} for module: (${simpleChalk.green(id)}), path: '${simpleChalk.grey(importer ?? "")}'`
+              );
+            return external;
+          },
+          noExternal: (id, importer) => {
+            const external = this.shouldModuleBeExternal(
+              id,
+              importer,
+              withNodeModules
+            );
+            if (Boolean(process.env["DEBUG"]))
+              console.log(
+                `[${simpleChalk.yellow("noExternal")}] ${simpleChalk.yellow(external === false ? "true" : "false")} for module: (${simpleChalk.green(id)}), path: '${simpleChalk.grey(importer ?? "")}'`
+              );
+            return external === false;
+          },
           copy: async (options) => {
+            var _a2;
             const outputPaths = [
               "package.json"
             ];
@@ -1745,16 +1781,63 @@ class DxtGenerator {
               );
               outputPaths.push("node_modules");
             }
+            const dxtPackageRoot = entryDir !== "." && entryDir !== "" ? path__namespace.dirname(options.outDir) : options.outDir;
             if (logoFilename) {
-              const logoPath = path__namespace.join(process.cwd(), logoFilename);
+              const currentDir = typeof process !== "undefined" ? process.cwd() : "/test";
+              const logoPath = path__namespace.join(currentDir, logoFilename);
               if (fs__namespace.existsSync(logoPath)) {
                 console.log(simpleChalk.gray(`Adding logo from: ${logoPath}`));
                 outputPaths.push({
                   from: logoPath,
-                  to: path__namespace.join(options.outDir, logoFilename)
+                  to: path__namespace.join(dxtPackageRoot, logoFilename)
                 });
               }
             }
+            if ((_a2 = mcpConfig == null ? void 0 : mcpConfig.dxt) == null ? void 0 : _a2.include) {
+              console.log(
+                simpleChalk.gray(
+                  "📁 Including additional files from DXT configuration..."
+                )
+              );
+              for (const includeItem of mcpConfig.dxt.include) {
+                if (typeof includeItem === "string") {
+                  const sourcePath = path__namespace.resolve(projectRoot, includeItem);
+                  if (fs__namespace.existsSync(sourcePath)) {
+                    console.log(simpleChalk.gray(`  • ${includeItem}`));
+                    outputPaths.push({
+                      from: sourcePath,
+                      to: path__namespace.join(dxtPackageRoot, includeItem)
+                    });
+                  } else {
+                    console.warn(
+                      simpleChalk.yellow(
+                        `  ⚠ File not found: ${includeItem} (resolved to ${sourcePath})`
+                      )
+                    );
+                  }
+                } else {
+                  const sourcePath = path__namespace.resolve(
+                    projectRoot,
+                    includeItem.from
+                  );
+                  if (fs__namespace.existsSync(sourcePath)) {
+                    console.log(
+                      simpleChalk.gray(`  • ${includeItem.from} → ${includeItem.to}`)
+                    );
+                    outputPaths.push({
+                      from: sourcePath,
+                      to: path__namespace.join(dxtPackageRoot, includeItem.to)
+                    });
+                  } else {
+                    console.warn(
+                      simpleChalk.yellow(
+                        `  ⚠ File not found: ${includeItem.from} (resolved to ${sourcePath})`
+                      )
+                    );
+                  }
+                }
+              }
+            }
             return outputPaths;
           },
           platform: "node",
@@ -1787,7 +1870,7 @@ export default ${JSON.stringify(buildConfig, null, 2)};
         console.log(simpleChalk.green("✅ TSDown bundling completed"));
         const detectedOutputFile = this.detectTsdownOutputFile(
           outputDir,
-          entryFileName
+          relativeEntryPath.replace(/\.ts$/, ".js")
         );
         await this.setupDxtPackageFiles(
           entryPointFile,
@@ -1811,7 +1894,160 @@ export default ${JSON.stringify(buildConfig, null, 2)};
     }
   }
   /**
-   * Gets the path to the .dxtignore template file in assets
+   * Checks if a module ID is a Node.js built-in
+   */
+  isNodeBuiltin(id) {
+    const nodeBuiltins = [
+      "stream",
+      "fs",
+      "path",
+      "url",
+      "util",
+      "events",
+      "child_process",
+      "os",
+      "tty",
+      "process",
+      "crypto",
+      "http",
+      "https",
+      "net",
+      "zlib",
+      "fs/promises",
+      "timers",
+      "timers/promises",
+      "perf_hooks",
+      "async_hooks",
+      "inspector",
+      "v8",
+      "vm",
+      "assert",
+      "constants",
+      "module",
+      "repl",
+      "string_decoder",
+      "punycode",
+      "domain",
+      "querystring",
+      "readline",
+      "worker_threads",
+      "cluster",
+      "dgram",
+      "dns",
+      "buffer"
+    ];
+    return nodeBuiltins.includes(id) || id.startsWith("node:");
+  }
+  /**
+   * Determines if a module should be treated as external based on bundling configuration.
+   * This logic is shared between external and noExternal configurations.
+   *
+   * @param id - The module identifier (e.g., 'lodash', '@types/node', './utils')
+   * @param importer - The file path that is importing this module (undefined for entry points)
+   * @param withNodeModules - Whether to include node_modules in the bundle
+   * @returns true if the module should be external (not bundled), false if it should be bundled
+   *
+   * Logic flow:
+   * 1. Node built-ins (fs, path, etc.) are always external
+   * 2. If no importer (entry point), always bundle
+   * 3. If withNodeModules is false, bundle everything except Node built-ins
+   * 4. If withNodeModules is true:
+   *    - If importer is from node_modules, make external
+   *    - If module resolves to a project file (via TS paths or regular paths), bundle it
+   *    - Otherwise, make external (likely npm package)
+   *
+   * @example
+   * // Node built-in - always external
+   * shouldModuleBeExternal('fs', './src/main.ts', true) // returns true
+   *
+   * // Project file via TS paths or regular paths - bundle it
+   * shouldModuleBeExternal('@/utils', './src/main.ts', true) // returns false
+   *
+   * // NPM package - external when withNodeModules=true
+   * shouldModuleBeExternal('lodash', './src/main.ts', true) // returns true
+   */
+  shouldModuleBeExternal(id, importer, withNodeModules) {
+    if (this.isNodeBuiltin(id)) {
+      return true;
+    }
+    if (importer) {
+      if (withNodeModules) {
+        if (importer.includes("node_modules")) {
+          return true;
+        } else {
+          const resolvedPath = this.resolveModulePath(id, importer);
+          if (resolvedPath) {
+            return false;
+          } else {
+            return true;
+          }
+        }
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+  /**
+   * Checks if a package ID exists in the local node_modules folder.
+   * Only checks the folder or parent folder that contains the nearest package.json file.
+   * Returns false if no package.json file is found after 3 parent directory traversals.
+   *
+   * Alternative approach using require.resolve():
+   * ```ts
+   * public isNodeModulesPackageWithResolve(packageId: string): boolean {
+   *   try {
+   *     require.resolve(packageId);
+   *     return true;
+   *   } catch {
+   *     return false;
+   *   }
+   * }
+   * ```
+   *
+   * Filesystem approach is preferred for bundler context because:
+   * - Faster (no module resolution overhead)
+   * - No side effects during build
+   * - Predictable behavior in build vs runtime contexts
+   */
+  isNodeModulesPackage(packageId) {
+    try {
+      const currentDir = typeof process !== "undefined" ? process.cwd() : "/test";
+      let searchDir = currentDir;
+      let attempts = 0;
+      const maxAttempts = 3;
+      while (attempts < maxAttempts) {
+        const packageJsonPath = path__namespace.join(searchDir, "package.json");
+        if (fs__namespace.existsSync(packageJsonPath)) {
+          const nodeModulesPath = path__namespace.join(searchDir, "node_modules");
+          if (!fs__namespace.existsSync(nodeModulesPath)) {
+            return false;
+          }
+          const packagePath = path__namespace.join(nodeModulesPath, packageId);
+          if (fs__namespace.existsSync(packagePath)) {
+            const packagePackageJsonPath = path__namespace.join(
+              packagePath,
+              "package.json"
+            );
+            return fs__namespace.existsSync(packagePackageJsonPath);
+          }
+          return false;
+        }
+        const parentDir = path__namespace.dirname(searchDir);
+        if (parentDir === searchDir) {
+          break;
+        }
+        searchDir = parentDir;
+        attempts++;
+      }
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Get the path to the .dxtignore template file
    */
   getDxtIgnoreTemplatePath() {
     const possiblePaths = [
@@ -1824,7 +2060,7 @@ export default ${JSON.stringify(buildConfig, null, 2)};
       ),
       // 2. From node_modules/@alcyone-labs/arg-parser/dist/assets (when installed via npm)
       path__namespace.join(
-        process.cwd(),
+        typeof process !== "undefined" ? process.cwd() : "/test",
         "node_modules",
         "@alcyone-labs",
         "arg-parser",
@@ -1833,9 +2069,9 @@ export default ${JSON.stringify(buildConfig, null, 2)};
         ".dxtignore.template"
       ),
       // 3. From the root directory (development/local build)
-      path__namespace.join(process.cwd(), ".dxtignore.template"),
+      path__namespace.join(typeof process !== "undefined" ? process.cwd() : "/test", ".dxtignore.template"),
       // 4. From the library root (when using local file dependency)
-      path__namespace.join(process.cwd(), "..", "..", "..", ".dxtignore.template")
+      path__namespace.join(typeof process !== "undefined" ? process.cwd() : "/test", "..", "..", "..", ".dxtignore.template")
     ];
     for (const ignorePath of possiblePaths) {
       if (fs__namespace.existsSync(ignorePath)) {
@@ -1851,11 +2087,12 @@ export default ${JSON.stringify(buildConfig, null, 2)};
    */
   async setupDxtPackageFiles(entryPointFile, outputDir = "./dxt", actualOutputFilename, logoFilename = "logo.jpg") {
     var _a, _b, _c, _d, _e, _f;
-    const dxtDir = path__namespace.resolve(process.cwd(), outputDir);
+    const currentDir = typeof process !== "undefined" ? process.cwd() : "/test";
+    const dxtDir = path__namespace.resolve(currentDir, outputDir);
     if (!fs__namespace.existsSync(dxtDir)) {
       throw new Error(`TSDown output directory (${outputDir}) not found`);
     }
-    const packageJsonPath = path__namespace.join(process.cwd(), "package.json");
+    const packageJsonPath = path__namespace.join(currentDir, "package.json");
     let packageInfo = {};
     if (fs__namespace.existsSync(packageJsonPath)) {
       try {
@@ -1960,16 +2197,41 @@ export default ${JSON.stringify(buildConfig, null, 2)};
    */
   detectTsdownOutputFile(outputDir, expectedBaseName) {
     try {
-      const dxtDir = path__namespace.resolve(process.cwd(), outputDir);
+      let findJsFiles = function(dir, relativePath = "") {
+        const entries = fs__namespace.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path__namespace.join(dir, entry.name);
+          const relativeFilePath = path__namespace.join(relativePath, entry.name);
+          if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name.startsWith(".")) {
+              continue;
+            }
+            findJsFiles(fullPath, relativeFilePath);
+          } else if ((entry.name.endsWith(".js") || entry.name.endsWith(".mjs")) && !entry.name.includes("chunk-") && !entry.name.includes("dist-") && !entry.name.startsWith(".")) {
+            files.push(relativeFilePath);
+          }
+        }
+      };
+      const currentDir = typeof process !== "undefined" ? process.cwd() : "/test";
+      const dxtDir = path__namespace.resolve(currentDir, outputDir);
       if (!fs__namespace.existsSync(dxtDir)) {
         console.warn(
           simpleChalk.yellow(`⚠ Output directory (${outputDir}) not found`)
         );
         return null;
       }
-      const files = fs__namespace.readdirSync(dxtDir).filter(
-        (file) => (file.endsWith(".js") || file.endsWith(".mjs")) && !file.includes("chunk-") && !file.includes("dist-") && !file.startsWith(".")
-      );
+      const files = [];
+      findJsFiles(dxtDir);
+      const expectedJsFile = expectedBaseName.endsWith(".js") ? expectedBaseName : expectedBaseName.replace(/\.ts$/, ".js");
+      const expectedMjsFile = expectedBaseName.endsWith(".mjs") ? expectedBaseName : expectedBaseName.replace(/\.ts$/, ".mjs");
+      if (files.includes(expectedJsFile)) {
+        console.log(simpleChalk.gray(`✓ Detected TSDown output: ${expectedJsFile}`));
+        return expectedJsFile;
+      }
+      if (files.includes(expectedMjsFile)) {
+        console.log(simpleChalk.gray(`✓ Detected TSDown output: ${expectedMjsFile}`));
+        return expectedMjsFile;
+      }
       const baseNameWithoutExt = path__namespace.parse(expectedBaseName).name;
       for (const ext of [".js", ".mjs"]) {
         const exactMatch = `${baseNameWithoutExt}${ext}`;
@@ -2046,6 +2308,19 @@ export default ${JSON.stringify(buildConfig, null, 2)};
   generateEnvAndUserConfig() {
     const envVars = {};
     const userConfig = {};
+    const shouldBeRequired = (flag) => {
+      if (typeof flag.mandatory === "boolean") {
+        return flag.mandatory;
+      }
+      if (typeof flag.mandatory === "function") {
+        return false;
+      }
+      return false;
+    };
+    const shouldBeSensitive = (flag) => {
+      const envVar = flag.env || flag.envVar;
+      return !!envVar;
+    };
     const mainFlags = this.argParserInstance.flags;
     for (const flag of mainFlags) {
       const envVar = flag.env || flag.envVar;
@@ -2055,10 +2330,10 @@ export default ${JSON.stringify(buildConfig, null, 2)};
           type: "string",
           title: envVar.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()),
           description: flag.description || `${envVar} environment variable`,
-          required: true,
-          // Always require env vars in user_config for better UX
-          sensitive: true
-          // Assume env vars are sensitive
+          required: shouldBeRequired(flag),
+          // Respect the flag's mandatory setting
+          sensitive: shouldBeSensitive(flag)
+          // Set to sensitive if tied to ENV
         };
       }
     }
@@ -2074,10 +2349,10 @@ export default ${JSON.stringify(buildConfig, null, 2)};
               type: "string",
               title: envVar.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase()),
               description: flag.description || `${envVar} environment variable`,
-              required: true,
-              // Always require env vars in user_config for better UX
-              sensitive: true
-              // Assume env vars are sensitive
+              required: shouldBeRequired(flag),
+              // Respect the flag's mandatory setting
+              sensitive: shouldBeSensitive(flag)
+              // Set to sensitive if tied to ENV
             };
           }
         }
@@ -2085,6 +2360,176 @@ export default ${JSON.stringify(buildConfig, null, 2)};
     }
     return { envVars, userConfig };
   }
+  resolveModulePath(id, importer) {
+    var _a;
+    try {
+      if (Boolean(process.env["DEBUG"])) {
+        console.log(
+          `  <${simpleChalk.gray("module-resolve")}> Resolving '${simpleChalk.green(id)}' from '${simpleChalk.gray(importer)}'`
+        );
+      }
+      const tsconfig = getTsconfig.getTsconfig(importer);
+      if (!((_a = tsconfig == null ? void 0 : tsconfig.config.compilerOptions) == null ? void 0 : _a.paths)) {
+        if (Boolean(process.env["DEBUG"])) {
+          console.log(
+            `  <${simpleChalk.gray("ts-paths")}> No tsconfig or paths found for '${importer}'`
+          );
+        }
+      } else {
+        if (Boolean(process.env["DEBUG"])) {
+          const currentDir = typeof process !== "undefined" ? process.cwd() : "/test";
+          console.log(
+            `  <${simpleChalk.gray("ts-paths")}> Found tsconfig at '${path__namespace.relative(currentDir, tsconfig.path)}' with paths:`,
+            Object.keys(tsconfig.config.compilerOptions.paths)
+          );
+        }
+        const pathsMatcher = getTsconfig.createPathsMatcher(tsconfig);
+        if (!pathsMatcher) {
+          if (Boolean(process.env["DEBUG"])) {
+            console.log(
+              `  <${simpleChalk.gray("ts-paths")}> Failed to create paths matcher`
+            );
+          }
+        } else {
+          const possiblePaths = pathsMatcher(id);
+          if (Boolean(process.env["DEBUG"])) {
+            console.log(
+              `  <${simpleChalk.grey("ts-paths")}> Possible paths for '${id}':`,
+              possiblePaths
+            );
+          }
+          for (const possiblePath of possiblePaths) {
+            const resolvedPath = path__namespace.resolve(
+              path__namespace.dirname(tsconfig.path),
+              possiblePath
+            );
+            if (Boolean(process.env["DEBUG"])) {
+              console.log(
+                `  <${simpleChalk.grey("ts-paths")}> Trying resolved path: '${resolvedPath}'`
+              );
+            }
+            const extensions2 = [".ts", ".js", ".tsx", ".jsx", ".mjs", ".cjs"];
+            if (fs__namespace.existsSync(resolvedPath) && fs__namespace.statSync(resolvedPath).isFile()) {
+              if (Boolean(process.env["DEBUG"])) {
+                console.log(
+                  `  <${simpleChalk.grey("ts-paths")}> ✓ Resolved '${id}' to '${resolvedPath}'`
+                );
+              }
+              return resolvedPath;
+            }
+            if (resolvedPath.endsWith(".js")) {
+              const basePath = resolvedPath.slice(0, -3);
+              for (const ext of [".ts", ".tsx"]) {
+                const testPath2 = basePath + ext;
+                if (fs__namespace.existsSync(testPath2) && fs__namespace.statSync(testPath2).isFile()) {
+                  if (Boolean(process.env["DEBUG"])) {
+                    console.log(
+                      `  <${simpleChalk.grey("ts-paths")}> ✓ Resolved '${id}' to '${testPath2}' (replaced .js)`
+                    );
+                  }
+                  return testPath2;
+                }
+              }
+            }
+            for (const ext of extensions2) {
+              const testPath2 = resolvedPath + ext;
+              if (fs__namespace.existsSync(testPath2) && fs__namespace.statSync(testPath2).isFile()) {
+                if (Boolean(process.env["DEBUG"])) {
+                  console.log(
+                    `  <${simpleChalk.grey("ts-paths")}> ✓ Resolved '${id}' to '${testPath2}' (added extension)`
+                  );
+                }
+                return testPath2;
+              }
+            }
+            if (fs__namespace.existsSync(resolvedPath) && fs__namespace.statSync(resolvedPath).isDirectory()) {
+              for (const ext of extensions2) {
+                const indexPath = path__namespace.join(resolvedPath, `index${ext}`);
+                if (fs__namespace.existsSync(indexPath)) {
+                  if (Boolean(process.env["DEBUG"])) {
+                    console.log(
+                      `  <${simpleChalk.grey("ts-paths")}> ✓ Resolved '${id}' to '${indexPath}' (index)`
+                    );
+                  }
+                  return indexPath;
+                }
+              }
+            }
+          }
+        }
+      }
+      if (Boolean(process.env["DEBUG"])) {
+        console.log(
+          `  <${simpleChalk.gray("file-resolve")}> Trying regular file resolution for '${id}'`
+        );
+      }
+      let testPath;
+      if (path__namespace.isAbsolute(id)) {
+        testPath = id;
+      } else {
+        testPath = path__namespace.resolve(path__namespace.dirname(importer), id);
+      }
+      const extensions = [".ts", ".js", ".tsx", ".jsx", ".mjs", ".cjs"];
+      if (fs__namespace.existsSync(testPath) && fs__namespace.statSync(testPath).isFile()) {
+        if (Boolean(process.env["DEBUG"])) {
+          console.log(
+            `  <${simpleChalk.gray("file-resolve")}> ✓ Resolved '${id}' to '${testPath}'`
+          );
+        }
+        return testPath;
+      }
+      if (testPath.endsWith(".js")) {
+        const basePath = testPath.slice(0, -3);
+        for (const ext of [".ts", ".tsx"]) {
+          const tsPath = basePath + ext;
+          if (fs__namespace.existsSync(tsPath) && fs__namespace.statSync(tsPath).isFile()) {
+            if (Boolean(process.env["DEBUG"])) {
+              console.log(
+                `  <${simpleChalk.gray("file-resolve")}> ✓ Resolved '${id}' to '${tsPath}' (replaced .js)`
+              );
+            }
+            return tsPath;
+          }
+        }
+      }
+      for (const ext of extensions) {
+        const extPath = testPath + ext;
+        if (fs__namespace.existsSync(extPath) && fs__namespace.statSync(extPath).isFile()) {
+          if (Boolean(process.env["DEBUG"])) {
+            console.log(
+              `  <${simpleChalk.gray("file-resolve")}> ✓ Resolved '${id}' to '${extPath}' (added extension)`
+            );
+          }
+          return extPath;
+        }
+      }
+      if (fs__namespace.existsSync(testPath) && fs__namespace.statSync(testPath).isDirectory()) {
+        for (const ext of extensions) {
+          const indexPath = path__namespace.join(testPath, `index${ext}`);
+          if (fs__namespace.existsSync(indexPath)) {
+            if (Boolean(process.env["DEBUG"])) {
+              console.log(
+                `  <${simpleChalk.gray("file-resolve")}> ✓ Resolved '${id}' to '${indexPath}' (index)`
+              );
+            }
+            return indexPath;
+          }
+        }
+      }
+      if (Boolean(process.env["DEBUG"])) {
+        console.log(
+          `  <${simpleChalk.gray("module-resolve")}> ✗ Could not resolve '${id}'`
+        );
+      }
+    } catch (error) {
+      console.warn(
+        simpleChalk.yellow(
+          `Warning: Failed to resolve module path '${id}': ${error}`
+        )
+      );
+    }
+    return null;
+  }
 }
 class McpNotificationsManager {
   constructor() {
@@ -2556,6 +3001,61 @@ class McpResourcesManager {
     }
   }
 }
+const isDebugEnabled = () => {
+  try {
+    return Boolean(typeof process !== "undefined" && process.env && process.env["DEBUG"]);
+  } catch {
+    return false;
+  }
+};
+const debug = {
+  /**
+   * Log a debug message to stderr (only when DEBUG=true)
+   */
+  log: (...args) => {
+    if (isDebugEnabled()) {
+      console.error("[DEBUG]", ...args);
+    }
+  },
+  /**
+   * Log an error debug message to stderr (only when DEBUG=true)
+   */
+  error: (...args) => {
+    if (isDebugEnabled()) {
+      console.error("[DEBUG ERROR]", ...args);
+    }
+  },
+  /**
+   * Log a warning debug message to stderr (only when DEBUG=true)
+   */
+  warn: (...args) => {
+    if (isDebugEnabled()) {
+      console.error("[DEBUG WARN]", ...args);
+    }
+  },
+  /**
+   * Log an info debug message to stderr (only when DEBUG=true)
+   */
+  info: (...args) => {
+    if (isDebugEnabled()) {
+      console.error("[DEBUG INFO]", ...args);
+    }
+  },
+  /**
+   * Log a debug message with a custom prefix (only when DEBUG=true)
+   */
+  prefixed: (prefix, ...args) => {
+    if (isDebugEnabled()) {
+      console.error(`[DEBUG ${prefix}]`, ...args);
+    }
+  },
+  /**
+   * Check if debug mode is currently enabled
+   */
+  get enabled() {
+    return isDebugEnabled();
+  }
+};
 const _FlagManager = class _FlagManager {
   constructor(options = {}, initialFlags = []) {
     __privateAdd(this, __flags, /* @__PURE__ */ new Map());
@@ -2596,7 +3096,8 @@ const _FlagManager = class _FlagManager {
       type: resolvedType,
       validate: parsedFromZod["validate"],
       enum: parsedFromZod["enum"],
-      mandatory: parsedFromZod["mandatory"]
+      mandatory: parsedFromZod["mandatory"],
+      env: parsedFromZod["env"]
     };
   }
   addFlag(flag) {
@@ -2990,6 +3491,7 @@ const _ArgParserBase = class _ArgParserBase {
   }
   async parse(processArgs, options) {
     var _a, _b;
+    debug.log("ArgParserBase.parse() called with args:", processArgs);
     if (processArgs === void 0) {
       if (typeof process !== "undefined" && process.argv && Array.isArray(process.argv)) {
         processArgs = process.argv.slice(2);
@@ -3297,6 +3799,14 @@ ${indent(2)}${white(line)}`).join("")}
   hasFlag(name) {
     return __privateGet(this, _flagManager).hasFlag(name);
   }
+  /**
+   * Get flag definition by name
+   * @param name Flag name
+   * @returns Flag definition or undefined if not found
+   */
+  getFlagDefinition(name) {
+    return __privateGet(this, _flagManager).getFlag(name);
+  }
   getCommandChain() {
     const chain = [];
     let currentParser = this;
@@ -3532,11 +4042,15 @@ _handleGlobalChecks_fn = async function(processArgs, options) {
       return dxtResult === true ? true : dxtResult;
     }
   }
+  debug.log("Checking for --s-mcp-serve flag in args:", processArgs);
   const mcpServeIndex = processArgs.findIndex(
     (arg) => arg === "--s-mcp-serve"
   );
+  debug.log("mcpServeIndex:", mcpServeIndex);
   if (mcpServeIndex !== -1) {
+    debug.log("Found --s-mcp-serve flag, calling handler");
     const mcpServeResult = await __privateMethod(this, _ArgParserBase_instances, _handleMcpServeFlag_fn).call(this, processArgs, mcpServeIndex);
+    debug.log("MCP serve handler returned:", typeof mcpServeResult);
     if (mcpServeResult !== false) {
       return mcpServeResult === true ? true : mcpServeResult;
     }
@@ -4133,20 +4647,39 @@ _handleBuildDxtFlag_fn = async function(processArgs, buildDxtIndex) {
 };
 _handleMcpServeFlag_fn = async function(processArgs, _mcpServeIndex) {
   var _a;
+  debug.log("#_handleMcpServeFlag started");
   const transportOptions = __privateMethod(this, _ArgParserBase_instances, _parseMcpTransportOptions_fn).call(this, processArgs);
+  debug.log("Transport options parsed:", JSON.stringify(transportOptions));
   const mcpServerConfig = __privateMethod(this, _ArgParserBase_instances, _getMcpServerConfiguration_fn).call(this);
+  debug.log("Got MCP server config:", JSON.stringify(mcpServerConfig));
   const effectiveLogPath = transportOptions.logPath || (mcpServerConfig == null ? void 0 : mcpServerConfig.logPath) || "./logs/mcp.log";
+  debug.log("Effective log path:", effectiveLogPath);
   const resolvedLogPath = resolveLogPath(effectiveLogPath);
+  debug.log("Resolved log path:", resolvedLogPath);
   let mcpLogger;
+  debug.log("About to import simple-mcp-logger");
   try {
     const mcpLoggerModule = await import("@alcyone-labs/simple-mcp-logger");
-    mcpLogger = mcpLoggerModule.createMcpLogger("MCP Serve", resolvedLogPath);
+    debug.log("Successfully imported simple-mcp-logger");
+    const loggerConfig = __privateMethod(this, _ArgParserBase_instances, _resolveLoggerConfigForServe_fn).call(this, mcpServerConfig, resolvedLogPath);
+    if (typeof loggerConfig === "string") {
+      mcpLogger = mcpLoggerModule.createMcpLogger("MCP Serve", loggerConfig);
+    } else {
+      mcpLogger = mcpLoggerModule.createMcpLogger(
+        loggerConfig.prefix || "MCP Serve",
+        loggerConfig.logToFile
+      );
+    }
+    debug.log("Created MCP logger, about to hijack console");
     globalThis.console = mcpLogger;
+    debug.log("Console hijacked successfully");
   } catch {
+    debug.log("Failed to import simple-mcp-logger, using fallback");
     mcpLogger = {
       mcpError: (message) => console.error(`[MCP Serve] ${message}`)
     };
   }
+  debug.log("MCP logger setup complete, starting MCP serve handler");
   try {
     mcpLogger.mcpError(
       "Starting --s-mcp-serve system flag handler - console hijacked for MCP safety"
@@ -4169,11 +4702,13 @@ _handleMcpServeFlag_fn = async function(processArgs, _mcpServeIndex) {
       `Transport options: ${JSON.stringify(transportOptions)}`
     );
     try {
+      debug.log("About to call #_startUnifiedMcpServer");
       mcpLogger.mcpError("Starting unified MCP server with all tools");
       await __privateMethod(this, _ArgParserBase_instances, _startUnifiedMcpServer_fn).call(this, mcpServerConfig, {
         ...transportOptions,
         logPath: resolvedLogPath
       });
+      debug.log("#_startUnifiedMcpServer completed");
       mcpLogger.mcpError("Successfully started unified MCP server");
     } catch (error) {
       mcpLogger.mcpError(
@@ -4204,6 +4739,36 @@ _handleMcpServeFlag_fn = async function(processArgs, _mcpServeIndex) {
     );
   }
 };
+/**
+ * Resolve logger configuration for MCP serve with proper priority
+ * @param mcpServerConfig MCP server configuration
+ * @param resolvedLogPath Resolved log path from CLI flags
+ * @returns Logger configuration object or string path
+ */
+_resolveLoggerConfigForServe_fn = function(mcpServerConfig, resolvedLogPath) {
+  if (mcpServerConfig == null ? void 0 : mcpServerConfig.log) {
+    if (typeof mcpServerConfig.log === "string") {
+      return {
+        prefix: "MCP Serve",
+        logToFile: resolvedLogPath,
+        level: "error",
+        // Default level for backward compatibility
+        mcpMode: true
+      };
+    } else {
+      return {
+        prefix: "MCP Serve",
+        level: "error",
+        // Default level for backward compatibility
+        mcpMode: true,
+        ...mcpServerConfig.log,
+        // Use CLI-resolved path if available, otherwise use config path
+        logToFile: resolvedLogPath
+      };
+    }
+  }
+  return resolvedLogPath;
+};
 /**
  * Get MCP server configuration from withMcp() or fallback to addMcpSubCommand()
  */
@@ -4394,6 +4959,26 @@ _parseMcpTransportOptions_fn = function(processArgs) {
   return options;
 };
 let ArgParserBase = _ArgParserBase;
+function sanitizeMcpToolName(name) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Tool name must be a non-empty string");
+  }
+  let sanitized = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+  if (!sanitized || /^_+$/.test(sanitized)) {
+    sanitized = "tool";
+  }
+  if (sanitized.length > 64) {
+    sanitized = sanitized.substring(0, 64);
+  }
+  return sanitized;
+}
+function isValidMcpToolName(name) {
+  if (!name || typeof name !== "string") {
+    return false;
+  }
+  const mcpNamePattern = /^[a-zA-Z0-9_-]{1,64}$/;
+  return mcpNamePattern.test(name);
+}
 function createMcpSuccessResponse(data2) {
   return {
     content: [
@@ -4652,7 +5237,7 @@ function generateMcpToolsFromArgParser(rootParser, options) {
       } else {
         toolName = effectiveCommandName || "cmd";
       }
-      toolName = toolName.replace(/[^a-zA-Z0-9_-]/g, "_");
+      toolName = sanitizeMcpToolName(toolName);
     }
     if (!toolName)
       toolName = currentParser === rootParser && appName ? appName : "cmd";
@@ -4694,7 +5279,7 @@ function generateMcpToolsFromArgParser(rootParser, options) {
         inputSchema,
         outputSchema,
         async execute(mcpInputArgs) {
-          var _a;
+          var _a, _b, _c, _d, _e, _f;
           if (process.env["MCP_DEBUG"]) {
             console.error(
               `[MCP Execute] Starting execution for tool '${toolName}'`
@@ -4816,12 +5401,32 @@ function generateMcpToolsFromArgParser(rootParser, options) {
                       JSON.stringify(mcpInputArgs, null, 2)
                     );
                   }
+                  const getFlag = (name) => {
+                    if (mcpInputArgs && mcpInputArgs[name] !== void 0) {
+                      return mcpInputArgs[name];
+                    }
+                    if (rootParser) {
+                      const flagDef = rootParser.getFlagDefinition(name);
+                      if (flagDef) {
+                        const envVar = flagDef["env"];
+                        if (envVar) {
+                          const envKey = Array.isArray(envVar) ? envVar[0] : envVar;
+                          if (envKey && process.env[envKey]) {
+                            return process.env[envKey];
+                          }
+                        }
+                        return flagDef["defaultValue"];
+                      }
+                    }
+                    return void 0;
+                  };
                   const handlerContext = {
                     args: mcpInputArgs,
                     commandChain: [toolName],
                     parser: rootParser,
                     parentArgs: void 0,
-                    isMcp: true
+                    isMcp: true,
+                    getFlag
                   };
                   const handlerResult = await toolConfig.handler(handlerContext);
                   if (process.env["MCP_DEBUG"]) {
@@ -4887,49 +5492,67 @@ function generateMcpToolsFromArgParser(rootParser, options) {
                   error: errPayload.message,
                   message: errPayload.message
                 };
-                if (outputSchema && typeof outputSchema === "object" && outputSchema !== null && outputSchema._def) {
-                  const zodSchema = outputSchema;
-                  if (process.env["MCP_DEBUG"]) {
-                    console.error(
-                      `[MCP Debug] Output schema type:`,
-                      zodSchema._def.typeName
-                    );
-                  }
-                  if (zodSchema._def.typeName === "ZodObject") {
-                    const shapeGetter = zodSchema._def.shape;
-                    const shape = typeof shapeGetter === "function" ? shapeGetter() : shapeGetter;
+                try {
+                  if (outputSchema && typeof outputSchema === "object" && outputSchema !== null && outputSchema._def) {
+                    const zodSchema = outputSchema;
                     if (process.env["MCP_DEBUG"]) {
                       console.error(
-                        `[MCP Debug] Schema shape keys:`,
-                        Object.keys(shape)
+                        `[MCP Debug] Output schema type:`,
+                        ((_b = zodSchema._def) == null ? void 0 : _b.typeName) || ((_c = zodSchema._def) == null ? void 0 : _c.type)
                       );
                     }
-                    Object.keys(shape).forEach((key) => {
-                      if (!(key in structuredError)) {
-                        const fieldSchema = shape[key];
-                        if (fieldSchema && fieldSchema._def) {
-                          switch (fieldSchema._def.typeName) {
-                            case "ZodString":
-                              structuredError[key] = "";
-                              break;
-                            case "ZodNumber":
-                              structuredError[key] = 0;
-                              break;
-                            case "ZodBoolean":
-                              structuredError[key] = false;
-                              break;
-                            case "ZodArray":
-                              structuredError[key] = [];
-                              break;
-                            case "ZodObject":
-                              structuredError[key] = {};
-                              break;
-                            default:
-                              structuredError[key] = null;
+                    if (((_d = zodSchema._def) == null ? void 0 : _d.typeName) === "ZodObject" || ((_e = zodSchema._def) == null ? void 0 : _e.type) === "object") {
+                      const shapeGetter = (_f = zodSchema._def) == null ? void 0 : _f.shape;
+                      if (shapeGetter) {
+                        const shape = typeof shapeGetter === "function" ? shapeGetter() : shapeGetter;
+                        if (shape && typeof shape === "object") {
+                          if (process.env["MCP_DEBUG"]) {
+                            console.error(
+                              `[MCP Debug] Schema shape keys:`,
+                              Object.keys(shape)
+                            );
                           }
+                          Object.keys(shape).forEach((key) => {
+                            if (!(key in structuredError)) {
+                              const fieldSchema = shape[key];
+                              if (fieldSchema && fieldSchema._def) {
+                                switch (fieldSchema._def.typeName || fieldSchema._def.type) {
+                                  case "ZodString":
+                                  case "string":
+                                    structuredError[key] = "";
+                                    break;
+                                  case "ZodNumber":
+                                  case "number":
+                                    structuredError[key] = 0;
+                                    break;
+                                  case "ZodBoolean":
+                                  case "boolean":
+                                    structuredError[key] = false;
+                                    break;
+                                  case "ZodArray":
+                                  case "array":
+                                    structuredError[key] = [];
+                                    break;
+                                  case "ZodObject":
+                                  case "object":
+                                    structuredError[key] = {};
+                                    break;
+                                  default:
+                                    structuredError[key] = null;
+                                }
+                              }
+                            }
+                          });
                         }
                       }
-                    });
+                    }
+                  }
+                } catch (schemaError) {
+                  if (process.env["MCP_DEBUG"]) {
+                    console.error(
+                      `[MCP Debug] Error processing output schema for structured error:`,
+                      schemaError
+                    );
                   }
                 }
                 if (process.env["MCP_DEBUG"]) {
@@ -5019,12 +5642,32 @@ function generateMcpToolsFromArgParser(rootParser, options) {
                 const handlerToCall = finalHandler;
                 const cleanArgs = { ...mcpInputArgs };
                 delete cleanArgs["help"];
+                const getFlag = (name) => {
+                  if (cleanArgs && cleanArgs[name] !== void 0) {
+                    return cleanArgs[name];
+                  }
+                  if (finalParser) {
+                    const flagDef = finalParser.getFlagDefinition(name);
+                    if (flagDef) {
+                      const envVar = flagDef["env"];
+                      if (envVar) {
+                        const envKey = Array.isArray(envVar) ? envVar[0] : envVar;
+                        if (envKey && process.env[envKey]) {
+                          return process.env[envKey];
+                        }
+                      }
+                      return flagDef["defaultValue"];
+                    }
+                  }
+                  return void 0;
+                };
                 const handlerContext = {
                   args: cleanArgs,
                   commandChain: chain,
                   parser: finalParser,
                   parentArgs: resolvedParentArgs,
-                  isMcp: true
+                  isMcp: true,
+                  getFlag
                 };
                 try {
                   handlerResponse = await handlerToCall(handlerContext);
@@ -5133,27 +5776,27 @@ function generateMcpToolsFromArgParser(rootParser, options) {
               };
               if (outputSchema && typeof outputSchema === "object" && outputSchema !== null && outputSchema._def) {
                 const zodSchema = outputSchema;
-                if (zodSchema._def.typeName === "ZodObject") {
+                if (zodSchema._def.type === "object") {
                   const shapeGetter = zodSchema._def.shape;
                   const shape = typeof shapeGetter === "function" ? shapeGetter() : shapeGetter;
                   Object.keys(shape).forEach((key) => {
                     if (!(key in structuredError)) {
                       const fieldSchema = shape[key];
                       if (fieldSchema && fieldSchema._def) {
-                        switch (fieldSchema._def.typeName) {
-                          case "ZodString":
+                        switch (fieldSchema._def.type) {
+                          case "string":
                             structuredError[key] = "";
                             break;
-                          case "ZodNumber":
+                          case "number":
                             structuredError[key] = 0;
                             break;
-                          case "ZodBoolean":
+                          case "boolean":
                             structuredError[key] = false;
                             break;
-                          case "ZodArray":
+                          case "array":
                             structuredError[key] = [];
                             break;
-                          case "ZodObject":
+                          case "object":
                             structuredError[key] = {};
                             break;
                           default:
@@ -5215,18 +5858,61 @@ function compareVersions(v1, v2) {
   if (v1 === v2) return 0;
   return v1 < v2 ? -1 : 1;
 }
-const _ArgParser = class _ArgParser extends ArgParserBase {
-  constructor() {
-    super(...arguments);
-    __privateAdd(this, _ArgParser_instances);
-    this._mcpTools = /* @__PURE__ */ new Map();
-    this._tools = /* @__PURE__ */ new Map();
-    this._outputSchemaMap = /* @__PURE__ */ new Map();
-    this._mcpProtocolVersion = CURRENT_MCP_PROTOCOL_VERSION;
+function debugSchemaStructure(schema, label = "Schema") {
+  var _a, _b, _c;
+  if (process.env["MCP_DEBUG"]) {
+    console.error(`[Zod Compatibility Debug] ${label} structure:`);
+    console.error(`  - Type: ${typeof schema}`);
+    console.error(`  - Constructor: ${(_a = schema == null ? void 0 : schema.constructor) == null ? void 0 : _a.name}`);
+    console.error(`  - Has shape: ${!!(schema == null ? void 0 : schema.shape)}`);
+    console.error(`  - Has _def: ${!!(schema == null ? void 0 : schema._def)}`);
+    console.error(`  - _def.typeName: ${(_b = schema == null ? void 0 : schema._def) == null ? void 0 : _b.typeName}`);
+    console.error(`  - _def.type: ${(_c = schema == null ? void 0 : schema._def) == null ? void 0 : _c.type}`);
+    console.error(`  - Has parse: ${typeof (schema == null ? void 0 : schema.parse)}`);
+    console.error(`  - Has safeParse: ${typeof (schema == null ? void 0 : schema.safeParse)}`);
+    if (schema == null ? void 0 : schema.shape) {
+      console.error(`  - Shape keys: ${Object.keys(schema.shape)}`);
+    }
   }
-  /**
-   * Get the stored MCP server configuration
-   * @returns MCP server configuration if set via withMcp(), undefined otherwise
+}
+function validateMcpSchemaCompatibility(schema) {
+  var _a, _b;
+  try {
+    if (typeof (schema == null ? void 0 : schema.parse) !== "function") {
+      console.warn("[Zod Compatibility] Schema missing parse method");
+      return false;
+    }
+    if (typeof (schema == null ? void 0 : schema.safeParse) !== "function") {
+      console.warn("[Zod Compatibility] Schema missing safeParse method");
+      return false;
+    }
+    if ((((_a = schema == null ? void 0 : schema._def) == null ? void 0 : _a.typeName) === "ZodObject" || ((_b = schema == null ? void 0 : schema._def) == null ? void 0 : _b.type) === "object") && !(schema == null ? void 0 : schema.shape)) {
+      console.warn(
+        "[Zod Compatibility] ZodObject schema missing shape property"
+      );
+      return false;
+    }
+    return true;
+  } catch (error) {
+    console.error(
+      "[Zod Compatibility] Error validating schema compatibility:",
+      error
+    );
+    return false;
+  }
+}
+const _ArgParser = class _ArgParser extends ArgParserBase {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _ArgParser_instances);
+    this._mcpTools = /* @__PURE__ */ new Map();
+    this._tools = /* @__PURE__ */ new Map();
+    this._outputSchemaMap = /* @__PURE__ */ new Map();
+    this._mcpProtocolVersion = CURRENT_MCP_PROTOCOL_VERSION;
+  }
+  /**
+   * Get the stored MCP server configuration
+   * @returns MCP server configuration if set via withMcp(), undefined otherwise
    */
   getMcpServerConfig() {
     return this._mcpServerConfig;
@@ -5285,19 +5971,33 @@ const _ArgParser = class _ArgParser extends ArgParserBase {
    * @returns This ArgParser instance for chaining
    */
   addTool(toolConfig) {
-    if (this._tools.has(toolConfig.name)) {
-      throw new Error(`Tool with name '${toolConfig.name}' already exists`);
-    }
+    var _a;
     if (!toolConfig.name || typeof toolConfig.name !== "string") {
       throw new Error("Tool name is required and must be a string");
     }
     if (!toolConfig.handler || typeof toolConfig.handler !== "function") {
       throw new Error("Tool handler is required and must be a function");
     }
+    const sanitizedName = sanitizeMcpToolName(toolConfig.name);
+    if (sanitizedName !== toolConfig.name) {
+      const isMcpMode = (_a = globalThis.console) == null ? void 0 : _a.mcpError;
+      if (!isMcpMode) {
+        console.warn(
+          `[ArgParser] Tool name '${toolConfig.name}' was sanitized to '${sanitizedName}' for MCP compatibility`
+        );
+      }
+    }
+    if (this._tools.has(sanitizedName)) {
+      throw new Error(`Tool with name '${sanitizedName}' already exists`);
+    }
     if (!Array.isArray(toolConfig.flags)) {
       throw new Error("Tool flags must be an array");
     }
-    this._tools.set(toolConfig.name, toolConfig);
+    const sanitizedToolConfig = {
+      ...toolConfig,
+      name: sanitizedName
+    };
+    this._tools.set(sanitizedName, sanitizedToolConfig);
     __privateMethod(this, _ArgParser_instances, registerToolAsSubCommand_fn).call(this, toolConfig);
     return this;
   }
@@ -5308,13 +6008,40 @@ const _ArgParser = class _ArgParser extends ArgParserBase {
    * @returns This ArgParser instance for chaining
    */
   addMcpTool(toolConfig) {
-    console.warn(`[DEPRECATED] addMcpTool() is deprecated and will be removed in v2.0.
+    var _a;
+    try {
+      if (typeof process !== "undefined" && process.stderr) {
+        process.stderr.write(`[DEPRECATED] addMcpTool() is deprecated and will be removed in v2.0.
+Please use addTool() instead for a unified CLI/MCP experience.
+Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-MIGRATION.md
+`);
+      } else {
+        console.warn(`[DEPRECATED] addMcpTool() is deprecated and will be removed in v2.0.
+Please use addTool() instead for a unified CLI/MCP experience.
+Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-MIGRATION.md`);
+      }
+    } catch {
+      console.warn(`[DEPRECATED] addMcpTool() is deprecated and will be removed in v2.0.
 Please use addTool() instead for a unified CLI/MCP experience.
 Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-MIGRATION.md`);
-    if (this._mcpTools.has(toolConfig.name)) {
-      throw new Error(`MCP tool with name '${toolConfig.name}' already exists`);
     }
-    this._mcpTools.set(toolConfig.name, toolConfig);
+    const sanitizedName = sanitizeMcpToolName(toolConfig.name);
+    if (sanitizedName !== toolConfig.name) {
+      const isMcpMode = (_a = globalThis.console) == null ? void 0 : _a.mcpError;
+      if (!isMcpMode) {
+        console.warn(
+          `[ArgParser] Tool name '${toolConfig.name}' was sanitized to '${sanitizedName}' for MCP compatibility`
+        );
+      }
+    }
+    if (this._mcpTools.has(sanitizedName)) {
+      throw new Error(`MCP tool with name '${sanitizedName}' already exists`);
+    }
+    const sanitizedToolConfig = {
+      ...toolConfig,
+      name: sanitizedName
+    };
+    this._mcpTools.set(sanitizedName, sanitizedToolConfig);
     return this;
   }
   /**
@@ -5586,7 +6313,7 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
     ).map((toolConfig) => ({
       name: toolConfig.name,
       description: toolConfig.description || `Executes the ${toolConfig.name} tool.`,
-      inputSchema: toolConfig.inputSchema || { type: "object", properties: {} },
+      inputSchema: toolConfig.inputSchema || zod.z.object({}),
       outputSchema: toolConfig.outputSchema,
       execute: async (args) => {
         try {
@@ -5646,16 +6373,18 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
    * Create an MCP server with tools generated from this ArgParser
    * @param serverInfo Server configuration
    * @param toolOptions Optional MCP tool generation options
+   * @param logPath Optional log path (deprecated, use log config in withMcp instead)
    * @returns Configured MCP server instance
    */
   async createMcpServer(serverInfo, toolOptions, logPath) {
-    var _a, _b;
-    const resolvedLogPath = resolveLogPath(
-      logPath || ((_a = this._mcpServerConfig) == null ? void 0 : _a.logPath) || "./logs/mcp.log"
+    var _a, _b, _c;
+    const loggerConfig = __privateMethod(this, _ArgParser_instances, _resolveLoggerConfig_fn).call(this, logPath);
+    const logger = typeof loggerConfig === "string" ? simpleMcpLogger.createMcpLogger("MCP Server Creation", loggerConfig) : simpleMcpLogger.createMcpLogger(
+      loggerConfig.prefix || "MCP Server Creation",
+      loggerConfig.logToFile
     );
-    const logger = simpleMcpLogger.createMcpLogger("MCP Server Creation", resolvedLogPath);
     try {
-      const effectiveServerInfo = serverInfo || ((_b = this._mcpServerConfig) == null ? void 0 : _b.serverInfo);
+      const effectiveServerInfo = serverInfo || ((_a = this._mcpServerConfig) == null ? void 0 : _a.serverInfo);
       if (!effectiveServerInfo) {
         throw new Error(
           "No MCP server configuration found. Use withMcp() to configure server info or provide serverInfo parameter."
@@ -5664,8 +6393,10 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
       logger.mcpError(
         `Creating MCP server: ${effectiveServerInfo.name} v${effectiveServerInfo.version}`
       );
-      const { McpServer: McpServer2 } = await Promise.resolve().then(() => mcp);
-      logger.mcpError("Successfully imported McpServer from SDK");
+      const { McpServer: McpServer2, ResourceTemplate: ResourceTemplate2 } = await Promise.resolve().then(() => mcp);
+      logger.mcpError(
+        "Successfully imported McpServer and ResourceTemplate from SDK"
+      );
       const server = new McpServer2({
         id: effectiveServerInfo.name,
         version: effectiveServerInfo.version,
@@ -5673,6 +6404,61 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
         description: effectiveServerInfo.description
       });
       logger.mcpError("Successfully created McpServer instance");
+      const isInMcpServeMode = process.argv.includes("--s-mcp-serve");
+      if (((_b = this._mcpServerConfig) == null ? void 0 : _b.lifecycle) && !isInMcpServeMode) {
+        const { McpLifecycleManager: McpLifecycleManager2 } = await Promise.resolve().then(() => mcpLifecycle);
+        const lifecycleManager = new McpLifecycleManager2(
+          this._mcpServerConfig.lifecycle,
+          logger,
+          effectiveServerInfo,
+          this
+        );
+        try {
+          const filteredArgs = process.argv.slice(2).filter(
+            (arg) => !arg.startsWith("--s-mcp-") && arg !== "--s-mcp-serve"
+          );
+          const parsedResult = await this.parse(filteredArgs, {
+            skipHandlerExecution: true,
+            isMcp: true
+          });
+          const parsedArgs = (parsedResult == null ? void 0 : parsedResult.args) || parsedResult || {};
+          lifecycleManager.setParsedArgs(parsedArgs);
+          logger.mcpError(`Lifecycle manager initialized with parsed args: ${Object.keys(parsedArgs).join(", ")}`);
+        } catch (parseError) {
+          logger.mcpError(`Warning: Could not parse arguments for lifecycle manager: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+        }
+        const originalConnect = server.connect.bind(server);
+        server.connect = async (transport) => {
+          logger.mcpError("MCP server connecting with lifecycle events...");
+          const result = await originalConnect(transport);
+          try {
+            await lifecycleManager.handleInitialize(
+              { name: "mcp-client", version: "1.0.0" },
+              // Default client info
+              "2024-11-05",
+              // Default protocol version
+              {}
+              // Default capabilities
+            );
+            setTimeout(async () => {
+              try {
+                await lifecycleManager.handleInitialized();
+              } catch (error) {
+                logger.mcpError(
+                  `Lifecycle onInitialized error: ${error instanceof Error ? error.message : String(error)}`
+                );
+              }
+            }, 100);
+          } catch (error) {
+            logger.mcpError(
+              `Lifecycle onInitialize error: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+          return result;
+        };
+        server._lifecycleManager = lifecycleManager;
+        logger.mcpError("Successfully set up MCP lifecycle manager");
+      }
       logger.mcpError(
         "MCP server will register actual resources and prompts for full capability support"
       );
@@ -5689,29 +6475,122 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
         `After deduplication: ${uniqueTools.length} unique tools`
       );
       uniqueTools.forEach((tool) => {
+        var _a2, _b2, _c2, _d, _e, _f;
         logger.mcpError(`Registering tool: ${tool.name}`);
-        let inputSchema;
-        if (tool.inputSchema === null || tool.inputSchema === void 0) {
-          inputSchema = {};
-        } else if (tool.inputSchema && typeof tool.inputSchema === "object" && tool.inputSchema !== null && tool.inputSchema._def) {
-          const zodObjectSchema = tool.inputSchema;
-          if (zodObjectSchema._def.typeName === "ZodObject") {
-            const shapeGetter = zodObjectSchema._def.shape;
-            const shape = typeof shapeGetter === "function" ? shapeGetter() : shapeGetter;
-            inputSchema = shape;
-          } else {
-            inputSchema = tool.inputSchema;
-          }
+        let zodSchema;
+        const toolFromUnified = Array.from(this._tools.values()).find(
+          (t) => t.name === tool.name
+        );
+        const toolFromLegacy = Array.from(this._mcpTools.values()).find(
+          (t) => t.name === tool.name
+        );
+        if (toolFromUnified && toolFromUnified.flags) {
+          zodSchema = convertFlagsToZodSchema(toolFromUnified.flags);
+        } else if (toolFromLegacy && toolFromLegacy.inputSchema) {
+          zodSchema = toolFromLegacy.inputSchema;
         } else {
-          inputSchema = tool.inputSchema || {};
+          zodSchema = zod.z.object({});
+        }
+        let mcpCompatibleSchema;
+        try {
+          if (process.env["MCP_DEBUG"]) {
+            console.error(`[MCP Debug] Preparing schema for tool ${tool.name}`);
+            console.error(`[MCP Debug] Input zodSchema:`, zodSchema);
+          }
+          mcpCompatibleSchema = zodSchema;
+          if (process.env["MCP_DEBUG"]) {
+            console.error(
+              `[MCP Debug] Successfully prepared schema for tool ${tool.name}`
+            );
+          }
+        } catch (schemaError) {
+          console.error(
+            `[MCP Debug] Error preparing schema for tool ${tool.name}:`,
+            schemaError
+          );
+          throw schemaError;
+        }
+        if (process.env["MCP_DEBUG"]) {
+          console.error(
+            `[MCP Debug] Prepared mcpCompatibleSchema for tool ${tool.name}:`,
+            JSON.stringify(mcpCompatibleSchema, null, 2)
+          );
+          console.error(
+            `[MCP Debug] Schema properties:`,
+            Object.keys(mcpCompatibleSchema || {})
+          );
+          console.error(
+            `[MCP Debug] Schema def:`,
+            mcpCompatibleSchema == null ? void 0 : mcpCompatibleSchema.def
+          );
+          console.error(
+            `[MCP Debug] Schema shape:`,
+            mcpCompatibleSchema == null ? void 0 : mcpCompatibleSchema.shape
+          );
+          console.error(
+            `[MCP Debug] Schema parse function:`,
+            typeof (mcpCompatibleSchema == null ? void 0 : mcpCompatibleSchema.parse)
+          );
+        }
+        if (process.env["MCP_DEBUG"]) {
+          console.error(
+            `[MCP Debug] About to prepare schema for tool ${tool.name}`
+          );
+          console.error(`[MCP Debug] zodSchema type:`, typeof zodSchema);
+          console.error(`[MCP Debug] zodSchema:`, zodSchema);
+          console.error(
+            `[MCP Debug] zodSchema constructor:`,
+            (_a2 = zodSchema == null ? void 0 : zodSchema.constructor) == null ? void 0 : _a2.name
+          );
+        }
+        debugSchemaStructure(mcpCompatibleSchema, `Tool ${tool.name} schema`);
+        if (!validateMcpSchemaCompatibility(mcpCompatibleSchema)) {
+          logger.mcpError(
+            `Warning: Schema for tool ${tool.name} may not be fully compatible with MCP SDK`
+          );
         }
         const toolConfig = {
           title: tool.name,
           // MCP SDK requires title field
           description: tool.description || "No description provided.",
-          inputSchema
-          // Use Zod shape directly for MCP SDK compatibility
+          inputSchema: mcpCompatibleSchema
+          // Use Zod v3 compatible schema for MCP SDK
         };
+        if (process.env["MCP_DEBUG"]) {
+          console.error(
+            `[MCP Debug] Final toolConfig for ${tool.name}:`,
+            JSON.stringify(toolConfig, null, 2)
+          );
+          console.error(
+            `[MCP Debug] toolConfig.inputSchema type:`,
+            typeof toolConfig.inputSchema
+          );
+          console.error(
+            `[MCP Debug] toolConfig.inputSchema constructor:`,
+            (_c2 = (_b2 = toolConfig.inputSchema) == null ? void 0 : _b2.constructor) == null ? void 0 : _c2.name
+          );
+          console.error(
+            `[MCP Debug] toolConfig.inputSchema._def:`,
+            (_d = toolConfig.inputSchema) == null ? void 0 : _d._def
+          );
+          console.error(
+            `[MCP Debug] toolConfig.inputSchema.shape:`,
+            (_e = toolConfig.inputSchema) == null ? void 0 : _e.shape
+          );
+          console.error(
+            `[MCP Debug] toolConfig.inputSchema._zod:`,
+            (_f = toolConfig.inputSchema) == null ? void 0 : _f._zod
+          );
+          console.error(
+            `[MCP Debug] Schema keys:`,
+            Object.keys(mcpCompatibleSchema || {})
+          );
+          console.error(`[MCP Debug] About to call server.registerTool with:`, {
+            name: tool.name,
+            description: tool.description,
+            inputSchema: mcpCompatibleSchema
+          });
+        }
         const simpleExecute = async (args) => {
           if (process.env["MCP_DEBUG"]) {
             console.error(
@@ -5761,37 +6640,194 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
       });
       logger.mcpError("Successfully registered all tools with MCP server");
       const resources = this.getMcpResources();
-      logger.mcpError(
-        `Found ${resources.length} MCP resources (registration temporarily disabled)`
-      );
-      if (resources.length > 0) {
-        logger.mcpError(
-          "Resource registration is temporarily disabled due to MCP SDK type compatibility"
-        );
-        logger.mcpError(
-          "Resources are stored and will be available once SDK integration is completed"
-        );
-      }
-      logger.mcpError(
-        "Resource registration step completed (temporarily disabled)"
-      );
+      logger.mcpError(`Registering ${resources.length} MCP resources`);
+      resources.forEach((resource) => {
+        try {
+          const resourceConfig = {
+            title: resource.title || resource.name,
+            description: resource.description || `Resource: ${resource.name}`,
+            mimeType: resource.mimeType || "application/json"
+          };
+          if (resource.uriTemplate.includes("{")) {
+            const resourceTemplate = new ResourceTemplate2(
+              resource.uriTemplate,
+              { list: void 0 }
+            );
+            const templateHandler = async (uri, params = {}) => {
+              try {
+                const result = await resource.handler(
+                  new URL(uri.href || uri),
+                  params
+                );
+                return {
+                  contents: result.contents.map((content) => {
+                    const mcpContent = {
+                      uri: content.uri
+                    };
+                    if (content.text !== void 0) {
+                      mcpContent.text = content.text;
+                    }
+                    if (content.blob !== void 0) {
+                      mcpContent.blob = content.blob;
+                    }
+                    if (content.mimeType !== void 0) {
+                      mcpContent.mimeType = content.mimeType;
+                    }
+                    return mcpContent;
+                  })
+                };
+              } catch (error) {
+                logger.mcpError(
+                  `Resource template handler error for ${resource.name}: ${error instanceof Error ? error.message : String(error)}`
+                );
+                throw error;
+              }
+            };
+            server.registerResource(
+              resource.name,
+              resourceTemplate,
+              resourceConfig,
+              templateHandler
+            );
+          } else {
+            const resourceHandler = async (uri) => {
+              try {
+                const result = await resource.handler(
+                  new URL(uri.href || uri),
+                  {}
+                );
+                return {
+                  contents: result.contents.map((content) => {
+                    const mcpContent = {
+                      uri: content.uri
+                    };
+                    if (content.text !== void 0) {
+                      mcpContent.text = content.text;
+                    }
+                    if (content.blob !== void 0) {
+                      mcpContent.blob = content.blob;
+                    }
+                    if (content.mimeType !== void 0) {
+                      mcpContent.mimeType = content.mimeType;
+                    }
+                    return mcpContent;
+                  })
+                };
+              } catch (error) {
+                logger.mcpError(
+                  `Resource handler error for ${resource.name}: ${error instanceof Error ? error.message : String(error)}`
+                );
+                throw error;
+              }
+            };
+            server.registerResource(
+              resource.name,
+              resource.uriTemplate,
+              resourceConfig,
+              resourceHandler
+            );
+          }
+          logger.mcpError(`Successfully registered resource: ${resource.name}`);
+        } catch (error) {
+          logger.mcpError(
+            `Failed to register resource ${resource.name}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      });
+      logger.mcpError("Successfully registered all resources with MCP server");
       const prompts = this.getMcpPrompts();
-      logger.mcpError(
-        `Found ${prompts.length} MCP prompts (registration temporarily disabled)`
-      );
-      if (prompts.length > 0) {
-        logger.mcpError(
-          "Prompt registration is temporarily disabled due to MCP SDK type compatibility"
-        );
-        logger.mcpError(
-          "Prompts are stored and will be available once SDK integration is completed"
-        );
-      }
-      logger.mcpError(
-        "Prompt registration step completed (temporarily disabled)"
-      );
+      logger.mcpError(`Registering ${prompts.length} MCP prompts`);
+      prompts.forEach((prompt) => {
+        try {
+          let mcpCompatibleSchema;
+          try {
+            if (process.env["MCP_DEBUG"]) {
+              console.error(
+                `[MCP Debug] Preparing schema for prompt ${prompt.name}`
+              );
+              console.error(`[MCP Debug] Input argsSchema:`, prompt.argsSchema);
+            }
+            mcpCompatibleSchema = prompt.argsSchema;
+            if (process.env["MCP_DEBUG"]) {
+              console.error(
+                `[MCP Debug] Successfully prepared schema for prompt ${prompt.name}`
+              );
+            }
+          } catch (schemaError) {
+            console.error(
+              `[MCP Debug] Error preparing schema for prompt ${prompt.name}:`,
+              schemaError
+            );
+            throw schemaError;
+          }
+          if (!validateMcpSchemaCompatibility(mcpCompatibleSchema)) {
+            throw new Error(
+              `Schema validation failed for prompt ${prompt.name}`
+            );
+          }
+          if (process.env["MCP_DEBUG"]) {
+            debugSchemaStructure(mcpCompatibleSchema, `prompt ${prompt.name}`);
+          }
+          const promptConfig = {
+            title: prompt.title || prompt.name,
+            // MCP SDK requires title field
+            description: prompt.description || "No description provided.",
+            argsSchema: mcpCompatibleSchema
+            // Use Zod v3 compatible schema for MCP SDK
+          };
+          const promptHandler = async (args) => {
+            try {
+              const validatedArgs = prompt.argsSchema.parse(args);
+              const result = await prompt.handler(validatedArgs);
+              if (process.env["MCP_DEBUG"]) {
+                console.error(
+                  `[MCP Debug] Prompt '${prompt.name}' executed successfully`
+                );
+              }
+              return result;
+            } catch (error) {
+              if (process.env["MCP_DEBUG"]) {
+                console.error(
+                  `[MCP Debug] Prompt '${prompt.name}' execution error:`,
+                  error
+                );
+              }
+              throw error;
+            }
+          };
+          server.registerPrompt(
+            prompt.name,
+            promptConfig,
+            promptHandler
+          );
+          logger.mcpError(`Successfully registered prompt: ${prompt.name}`);
+        } catch (error) {
+          logger.mcpError(
+            `Failed to register prompt ${prompt.name}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      });
+      logger.mcpError("Successfully registered all prompts with MCP server");
       this.setupMcpChangeNotifications(server);
       logger.mcpError("Successfully set up MCP change notifications");
+      if (server._lifecycleManager) {
+        const originalClose = (_c = server.close) == null ? void 0 : _c.bind(server);
+        server.close = async () => {
+          logger.mcpError("MCP server shutdown initiated");
+          try {
+            await server._lifecycleManager.handleShutdown(
+              "server_shutdown"
+            );
+          } catch (error) {
+            logger.mcpError(
+              `Error during lifecycle shutdown: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+          if (originalClose) {
+            await originalClose();
+          }
+        };
+      }
       return server;
     } catch (error) {
       logger.mcpError(
@@ -5861,11 +6897,14 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
     }, logPath);
   }
   async parse(processArgs, options) {
+    debug.log("ArgParser.parse() called with args:", processArgs);
+    debug.log("About to call ArgParserBase.prototype.parse.call()");
     let result = await ArgParserBase.prototype.parse.call(
       this,
       processArgs,
       options
     );
+    debug.log("ArgParserBase.prototype.parse.call() returned:", typeof result);
     const anyResult = result;
     if (anyResult._fuzzyModePreventedExecution) {
       return result;
@@ -6100,6 +7139,63 @@ Migration guide: https://github.com/alcyone-labs/arg-parser/blob/main/docs/MCP-M
   }
 };
 _ArgParser_instances = new WeakSet();
+/**
+ * Resolve logger configuration from various sources with proper priority
+ * @param logPathOverride Optional log path override parameter
+ * @returns Logger configuration object for createMcpLogger
+ */
+_resolveLoggerConfig_fn = function(logPathOverride) {
+  const mcpConfig = this._mcpServerConfig;
+  if (logPathOverride) {
+    const resolvedPath = resolveLogPath(logPathOverride);
+    return {
+      prefix: "MCP Server Creation",
+      logToFile: resolvedPath,
+      level: "error",
+      // Default level for backward compatibility
+      mcpMode: true
+    };
+  }
+  const hasLogConfig = mcpConfig == null ? void 0 : mcpConfig.log;
+  const hasLogPath = mcpConfig == null ? void 0 : mcpConfig.logPath;
+  if (hasLogConfig || hasLogPath) {
+    let config = {
+      prefix: "MCP Server Creation",
+      level: "error",
+      // Default level for backward compatibility
+      mcpMode: true
+    };
+    if (hasLogConfig && mcpConfig.log) {
+      if (typeof mcpConfig.log === "string") {
+        config.logToFile = resolveLogPath(mcpConfig.log);
+      } else {
+        config = {
+          ...config,
+          ...mcpConfig.log,
+          // Resolve logToFile path if provided in log config
+          ...mcpConfig.log.logToFile && {
+            logToFile: resolveLogPath(mcpConfig.log.logToFile)
+          }
+        };
+      }
+    }
+    if (hasLogPath && mcpConfig.logPath && !config.logToFile) {
+      config.logToFile = resolveLogPath(mcpConfig.logPath);
+    }
+    if (hasLogPath && mcpConfig.logPath && hasLogConfig && mcpConfig.log && typeof mcpConfig.log === "object" && mcpConfig.log.logToFile) {
+      config.logToFile = resolveLogPath(mcpConfig.logPath);
+    }
+    return config;
+  }
+  const defaultPath = resolveLogPath("./logs/mcp.log");
+  return {
+    prefix: "MCP Server Creation",
+    logToFile: defaultPath,
+    level: "error",
+    // Default level for backward compatibility
+    mcpMode: true
+  };
+};
 /**
  * Register a tool as a CLI subcommand
  * @private
@@ -6873,53 +7969,62 @@ const SUPPORTED_PROTOCOL_VERSIONS = [
 const JSONRPC_VERSION = "2.0";
 const ProgressTokenSchema = zod.z.union([zod.z.string(), zod.z.number().int()]);
 const CursorSchema = zod.z.string();
-const RequestMetaSchema = zod.z.object({
+const RequestMetaSchema = zod.z.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: zod.z.optional(ProgressTokenSchema)
-}).passthrough();
-const BaseRequestParamsSchema = zod.z.object({
+});
+const BaseRequestParamsSchema = zod.z.looseObject({
   _meta: zod.z.optional(RequestMetaSchema)
-}).passthrough();
+});
 const RequestSchema = zod.z.object({
   method: zod.z.string(),
   params: zod.z.optional(BaseRequestParamsSchema)
 });
-const BaseNotificationParamsSchema = zod.z.object({
+const BaseNotificationParamsSchema = zod.z.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: zod.z.optional(zod.z.object({}).passthrough())
-}).passthrough();
+  _meta: zod.z.optional(zod.z.looseObject({}))
+});
 const NotificationSchema = zod.z.object({
   method: zod.z.string(),
   params: zod.z.optional(BaseNotificationParamsSchema)
 });
-const ResultSchema = zod.z.object({
+const ResultSchema = zod.z.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: zod.z.optional(zod.z.object({}).passthrough())
-}).passthrough();
+  _meta: zod.z.optional(zod.z.looseObject({}))
+});
 const RequestIdSchema = zod.z.union([zod.z.string(), zod.z.number().int()]);
-const JSONRPCRequestSchema = zod.z.object({
+const JSONRPCRequestSchema = zod.z.strictObject({
   jsonrpc: zod.z.literal(JSONRPC_VERSION),
   id: RequestIdSchema
-}).merge(RequestSchema).strict();
-const isJSONRPCRequest = (value) => JSONRPCRequestSchema.safeParse(value).success;
-const JSONRPCNotificationSchema = zod.z.object({
+}).extend(RequestSchema.shape);
+const isJSONRPCRequest = (value) => {
+  const result = JSONRPCRequestSchema.safeParse(value);
+  return result.success;
+};
+const JSONRPCNotificationSchema = zod.z.strictObject({
   jsonrpc: zod.z.literal(JSONRPC_VERSION)
-}).merge(NotificationSchema).strict();
-const isJSONRPCNotification = (value) => JSONRPCNotificationSchema.safeParse(value).success;
-const JSONRPCResponseSchema = zod.z.object({
+}).extend(NotificationSchema.shape);
+const isJSONRPCNotification = (value) => {
+  const result = JSONRPCNotificationSchema.safeParse(value);
+  return result.success;
+};
+const JSONRPCResponseSchema = zod.z.strictObject({
   jsonrpc: zod.z.literal(JSONRPC_VERSION),
   id: RequestIdSchema,
   result: ResultSchema
-}).strict();
-const isJSONRPCResponse = (value) => JSONRPCResponseSchema.safeParse(value).success;
+});
+const isJSONRPCResponse = (value) => {
+  const result = JSONRPCResponseSchema.safeParse(value);
+  return result.success;
+};
 var ErrorCode;
 (function(ErrorCode2) {
   ErrorCode2[ErrorCode2["ConnectionClosed"] = -32e3] = "ConnectionClosed";
@@ -6930,7 +8035,7 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["InvalidParams"] = -32602] = "InvalidParams";
   ErrorCode2[ErrorCode2["InternalError"] = -32603] = "InternalError";
 })(ErrorCode || (ErrorCode = {}));
-const JSONRPCErrorSchema = zod.z.object({
+const JSONRPCErrorSchema = zod.z.strictObject({
   jsonrpc: zod.z.literal(JSONRPC_VERSION),
   id: RequestIdSchema,
   error: zod.z.object({
@@ -6947,15 +8052,18 @@ const JSONRPCErrorSchema = zod.z.object({
      */
     data: zod.z.optional(zod.z.unknown())
   })
-}).strict();
-const isJSONRPCError = (value) => JSONRPCErrorSchema.safeParse(value).success;
+});
+const isJSONRPCError = (value) => {
+  const result = JSONRPCErrorSchema.safeParse(value);
+  return result.success;
+};
 const JSONRPCMessageSchema = zod.z.union([
   JSONRPCRequestSchema,
   JSONRPCNotificationSchema,
   JSONRPCResponseSchema,
   JSONRPCErrorSchema
 ]);
-const EmptyResultSchema = ResultSchema.strict();
+const EmptyResultSchema = zod.z.strictObject({}).extend(ResultSchema.shape);
 const CancelledNotificationSchema = NotificationSchema.extend({
   method: zod.z.literal("notifications/cancelled"),
   params: BaseNotificationParamsSchema.extend({
@@ -6971,19 +8079,19 @@ const CancelledNotificationSchema = NotificationSchema.extend({
     reason: zod.z.string().optional()
   })
 });
-const BaseMetadataSchema = zod.z.object({
+const BaseMetadataSchema = zod.z.looseObject({
   /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
   name: zod.z.string(),
   /**
-  * Intended for UI and end-user contexts — optimized to be human-readable and easily understood,
-  * even by those unfamiliar with domain-specific terminology.
-  *
-  * If not provided, the name should be used for display (except for Tool,
-  * where `annotations.title` should be given precedence over using `name`,
-  * if present).
-  */
+   * Intended for UI and end-user contexts — optimized to be human-readable and easily understood,
+   * even by those unfamiliar with domain-specific terminology.
+   *
+   * If not provided, the name should be used for display (except for Tool,
+   * where `annotations.title` should be given precedence over using `name`,
+   * if present).
+   */
   title: zod.z.optional(zod.z.string())
-}).passthrough();
+});
 const ImplementationSchema = BaseMetadataSchema.extend({
   version: zod.z.string()
 });
@@ -7021,7 +8129,10 @@ const InitializeRequestSchema = RequestSchema.extend({
     clientInfo: ImplementationSchema
   })
 });
-const isInitializeRequest = (value) => InitializeRequestSchema.safeParse(value).success;
+const isInitializeRequest = (value) => {
+  const result = InitializeRequestSchema.safeParse(value);
+  return result.success;
+};
 const ServerCapabilitiesSchema = zod.z.object({
   /**
    * Experimental, non-standard capabilities that the server supports.
@@ -7103,7 +8214,8 @@ const ProgressSchema = zod.z.object({
 }).passthrough();
 const ProgressNotificationSchema = NotificationSchema.extend({
   method: zod.z.literal("notifications/progress"),
-  params: BaseNotificationParamsSchema.merge(ProgressSchema).extend({
+  params: BaseNotificationParamsSchema.extend({
+    ...ProgressSchema.shape,
     /**
      * The progress token which was given in the initial request, used to associate this notification with the request that is proceeding.
      */
@@ -7126,7 +8238,7 @@ const PaginatedResultSchema = ResultSchema.extend({
    */
   nextCursor: zod.z.optional(CursorSchema)
 });
-const ResourceContentsSchema = zod.z.object({
+const ResourceContentsSchema = zod.z.looseObject({
   /**
    * The URI of this resource.
    */
@@ -7139,19 +8251,27 @@ const ResourceContentsSchema = zod.z.object({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: zod.z.optional(zod.z.object({}).passthrough())
-}).passthrough();
+  _meta: zod.z.optional(zod.z.looseObject({}))
+});
 const TextResourceContentsSchema = ResourceContentsSchema.extend({
   /**
    * The text of the item. This must only be set if the item can actually be represented as text (not binary data).
    */
   text: zod.z.string()
 });
+const Base64Schema = zod.z.string().refine((val) => {
+  try {
+    atob(val);
+    return true;
+  } catch (_a) {
+    return false;
+  }
+}, { message: "Invalid Base64 string" });
 const BlobResourceContentsSchema = ResourceContentsSchema.extend({
   /**
    * A base64-encoded string representing the binary data of the item.
    */
-  blob: zod.z.string().base64()
+  blob: Base64Schema
 });
 const ResourceSchema = BaseMetadataSchema.extend({
   /**
@@ -7249,7 +8369,7 @@ const ResourceUpdatedNotificationSchema = NotificationSchema.extend({
     uri: zod.z.string()
   })
 });
-const PromptArgumentSchema = zod.z.object({
+const PromptArgumentSchema = zod.z.looseObject({
   /**
    * The name of the argument.
    */
@@ -7259,10 +8379,10 @@ const PromptArgumentSchema = zod.z.object({
    */
   description: zod.z.optional(zod.z.string()),
   /**
-   * Whether this argument must be provided.
+   * Whether this argument is required.
    */
   required: zod.z.optional(zod.z.boolean())
-}).passthrough();
+});
 const PromptSchema = BaseMetadataSchema.extend({
   /**
    * An optional description of what this prompt provides
@@ -7294,10 +8414,10 @@ const GetPromptRequestSchema = RequestSchema.extend({
     /**
      * Arguments to use for templating the prompt.
      */
-    arguments: zod.z.optional(zod.z.record(zod.z.string()))
+    arguments: zod.z.optional(zod.z.record(zod.z.string(), zod.z.string()))
   })
 });
-const TextContentSchema = zod.z.object({
+const TextContentSchema = zod.z.looseObject({
   type: zod.z.literal("text"),
   /**
    * The text content of the message.
@@ -7307,14 +8427,14 @@ const TextContentSchema = zod.z.object({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: zod.z.optional(zod.z.object({}).passthrough())
-}).passthrough();
-const ImageContentSchema = zod.z.object({
+  _meta: zod.z.optional(zod.z.looseObject({}))
+});
+const ImageContentSchema = zod.z.looseObject({
   type: zod.z.literal("image"),
   /**
    * The base64-encoded image data.
    */
-  data: zod.z.string().base64(),
+  data: Base64Schema,
   /**
    * The MIME type of the image. Different providers may support different image types.
    */
@@ -7323,14 +8443,14 @@ const ImageContentSchema = zod.z.object({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: zod.z.optional(zod.z.object({}).passthrough())
-}).passthrough();
-const AudioContentSchema = zod.z.object({
+  _meta: zod.z.optional(zod.z.looseObject({}))
+});
+const AudioContentSchema = zod.z.looseObject({
   type: zod.z.literal("audio"),
   /**
    * The base64-encoded audio data.
    */
-  data: zod.z.string().base64(),
+  data: Base64Schema,
   /**
    * The MIME type of the audio. Different providers may support different audio types.
    */
@@ -7339,17 +8459,17 @@ const AudioContentSchema = zod.z.object({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: zod.z.optional(zod.z.object({}).passthrough())
-}).passthrough();
-const EmbeddedResourceSchema = zod.z.object({
+  _meta: zod.z.optional(zod.z.looseObject({}))
+});
+const EmbeddedResourceSchema = zod.z.looseObject({
   type: zod.z.literal("resource"),
   resource: zod.z.union([TextResourceContentsSchema, BlobResourceContentsSchema]),
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: zod.z.optional(zod.z.object({}).passthrough())
-}).passthrough();
+  _meta: zod.z.optional(zod.z.looseObject({}))
+});
 const ResourceLinkSchema = ResourceSchema.extend({
   type: zod.z.literal("resource_link")
 });
@@ -7360,10 +8480,10 @@ const ContentBlockSchema = zod.z.union([
   ResourceLinkSchema,
   EmbeddedResourceSchema
 ]);
-const PromptMessageSchema = zod.z.object({
+const PromptMessageSchema = zod.z.looseObject({
   role: zod.z.enum(["user", "assistant"]),
   content: ContentBlockSchema
-}).passthrough();
+});
 const GetPromptResultSchema = ResultSchema.extend({
   /**
    * An optional description for the prompt.
@@ -7423,18 +8543,18 @@ const ToolSchema = BaseMetadataSchema.extend({
    */
   inputSchema: zod.z.object({
     type: zod.z.literal("object"),
-    properties: zod.z.optional(zod.z.object({}).passthrough()),
+    properties: zod.z.optional(zod.z.looseObject({})),
     required: zod.z.optional(zod.z.array(zod.z.string()))
-  }).passthrough(),
+  }),
   /**
    * An optional JSON Schema object defining the structure of the tool's output returned in
    * the structuredContent field of a CallToolResult.
    */
-  outputSchema: zod.z.optional(zod.z.object({
+  outputSchema: zod.z.optional(zod.z.looseObject({
     type: zod.z.literal("object"),
-    properties: zod.z.optional(zod.z.object({}).passthrough()),
+    properties: zod.z.optional(zod.z.looseObject({})),
     required: zod.z.optional(zod.z.array(zod.z.string()))
-  }).passthrough()),
+  })),
   /**
    * Optional additional tool information.
    */
@@ -7464,7 +8584,7 @@ const CallToolResultSchema = ResultSchema.extend({
    *
    * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
    */
-  structuredContent: zod.z.object({}).passthrough().optional(),
+  structuredContent: zod.z.looseObject({}).optional(),
   /**
    * Whether the tool call ended in an error.
    *
@@ -7488,7 +8608,7 @@ const CallToolRequestSchema = RequestSchema.extend({
   method: zod.z.literal("tools/call"),
   params: BaseRequestParamsSchema.extend({
     name: zod.z.string(),
-    arguments: zod.z.optional(zod.z.record(zod.z.unknown()))
+    arguments: zod.z.optional(zod.z.record(zod.z.string(), zod.z.unknown()))
   })
 });
 const ToolListChangedNotificationSchema = NotificationSchema.extend({
@@ -7530,34 +8650,34 @@ const LoggingMessageNotificationSchema = NotificationSchema.extend({
     data: zod.z.unknown()
   })
 });
-const ModelHintSchema = zod.z.object({
+const ModelHintSchema = zod.z.looseObject({
   /**
    * A hint for a model name.
    */
   name: zod.z.string().optional()
-}).passthrough();
-const ModelPreferencesSchema = zod.z.object({
+});
+const ModelPreferencesSchema = zod.z.looseObject({
   /**
-   * Optional hints to use for model selection.
+   * Optional hints to use for model selection. If multiple models are supported, the client MAY choose how to prioritize these hints to pick a model.
    */
   hints: zod.z.optional(zod.z.array(ModelHintSchema)),
   /**
-   * How much to prioritize cost when selecting a model.
+   * A hint for the model's cost priority. 0 = highest cost, 1 = lowest cost. The client MAY use this to decide which model to use.
    */
   costPriority: zod.z.optional(zod.z.number().min(0).max(1)),
   /**
-   * How much to prioritize sampling speed (latency) when selecting a model.
+   * A hint for the model's speed priority. 0 = slowest, 1 = fastest. The client MAY use this to decide which model to use.
    */
   speedPriority: zod.z.optional(zod.z.number().min(0).max(1)),
   /**
-   * How much to prioritize intelligence and capabilities when selecting a model.
+   * A hint for the model's intelligence priority. 0 = least intelligent, 1 = most intelligent. The client MAY use this to decide which model to use.
    */
   intelligencePriority: zod.z.optional(zod.z.number().min(0).max(1))
-}).passthrough();
-const SamplingMessageSchema = zod.z.object({
+});
+const SamplingMessageSchema = zod.z.looseObject({
   role: zod.z.enum(["user", "assistant"]),
   content: zod.z.union([TextContentSchema, ImageContentSchema, AudioContentSchema])
-}).passthrough();
+});
 const CreateMessageRequestSchema = RequestSchema.extend({
   method: zod.z.literal("sampling/createMessage"),
   params: BaseRequestParamsSchema.extend({
@@ -7579,7 +8699,7 @@ const CreateMessageRequestSchema = RequestSchema.extend({
     /**
      * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.
      */
-    metadata: zod.z.optional(zod.z.object({}).passthrough()),
+    metadata: zod.z.optional(zod.z.looseObject({})),
     /**
      * The server's preferences for which model to select.
      */
@@ -7602,12 +8722,12 @@ const CreateMessageResultSchema = ResultSchema.extend({
     AudioContentSchema
   ])
 });
-const BooleanSchemaSchema = zod.z.object({
+const BooleanSchemaSchema = zod.z.looseObject({
   type: zod.z.literal("boolean"),
   title: zod.z.optional(zod.z.string()),
   description: zod.z.optional(zod.z.string()),
   default: zod.z.optional(zod.z.boolean())
-}).passthrough();
+});
 const StringSchemaSchema = zod.z.object({
   type: zod.z.literal("string"),
   title: zod.z.optional(zod.z.string()),
@@ -7646,11 +8766,11 @@ const ElicitRequestSchema = RequestSchema.extend({
     /**
      * The schema for the requested user input.
      */
-    requestedSchema: zod.z.object({
+    requestedSchema: zod.z.looseObject({
       type: zod.z.literal("object"),
       properties: zod.z.record(zod.z.string(), PrimitiveSchemaDefinitionSchema),
       required: zod.z.optional(zod.z.array(zod.z.string()))
-    }).passthrough()
+    })
   })
 });
 const ElicitResultSchema = ResultSchema.extend({
@@ -7733,7 +8853,7 @@ const RootSchema = zod.z.object({
    */
   _meta: zod.z.optional(zod.z.object({}).passthrough())
 }).passthrough();
-const ListRootsRequestSchema = RequestSchema.extend({
+const ListRootsRequestSchema = PaginatedRequestSchema.extend({
   method: zod.z.literal("roots/list")
 });
 const ListRootsResultSchema = ResultSchema.extend({
@@ -7898,6 +9018,10 @@ class Protocol {
     this._responseHandlers = /* @__PURE__ */ new Map();
     this._progressHandlers.clear();
     this._pendingDebouncedNotifications.clear();
+    for (const info of this._timeoutInfo.values()) {
+      clearTimeout(info.timeoutId);
+    }
+    this._timeoutInfo.clear();
     this._transport = void 0;
     (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
     const error = new McpError(ErrorCode.ConnectionClosed, "Connection closed");
@@ -7938,7 +9062,10 @@ class Protocol {
       sessionId: (_c = this._transport) === null || _c === void 0 ? void 0 : _c.sessionId,
       _meta: (_d = request.params) === null || _d === void 0 ? void 0 : _d._meta,
       sendNotification: (notification) => this.notification(notification, { relatedRequestId: request.id }),
-      sendRequest: (r, resultSchema, options) => this.request(r, resultSchema, { ...options, relatedRequestId: request.id }),
+      sendRequest: (r, resultSchema, options) => this.request(r, resultSchema, {
+        ...options,
+        relatedRequestId: request.id
+      }),
       authInfo: extra === null || extra === void 0 ? void 0 : extra.authInfo,
       requestId: request.id,
       requestInfo: extra === null || extra === void 0 ? void 0 : extra.requestInfo
@@ -8014,8 +9141,13 @@ class Protocol {
    * Closes the connection.
    */
   async close() {
-    var _a;
-    await ((_a = this._transport) === null || _a === void 0 ? void 0 : _a.close());
+    const transport = this._transport;
+    if (transport) {
+      await transport.close();
+      if (this._transport === transport) {
+        this._onclose();
+      }
+    }
   }
   /**
    * Sends a request and wait for a response.
@@ -8085,9 +9217,15 @@ class Protocol {
         cancel((_a2 = options === null || options === void 0 ? void 0 : options.signal) === null || _a2 === void 0 ? void 0 : _a2.reason);
       });
       const timeout = (_e = options === null || options === void 0 ? void 0 : options.timeout) !== null && _e !== void 0 ? _e : DEFAULT_REQUEST_TIMEOUT_MSEC;
-      const timeoutHandler = () => cancel(new McpError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
+      const timeoutHandler = () => cancel(new McpError(ErrorCode.RequestTimeout, "Request timed out", {
+        timeout
+      }));
       this._setupTimeout(messageId, timeout, options === null || options === void 0 ? void 0 : options.maxTotalTimeout, timeoutHandler, (_f = options === null || options === void 0 ? void 0 : options.resetTimeoutOnProgress) !== null && _f !== void 0 ? _f : false);
-      this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => {
+      this._transport.send(jsonrpcRequest, {
+        relatedRequestId,
+        resumptionToken,
+        onresumptiontoken
+      }).catch((error) => {
         this._cleanupTimeout(messageId);
         reject(error);
       });
@@ -13890,7 +15028,7 @@ function requireAjv() {
   Ajv2.prototype.validateSchema = validateSchema;
   Ajv2.prototype.getSchema = getSchema;
   Ajv2.prototype.removeSchema = removeSchema;
-  Ajv2.prototype.addFormat = addFormat2;
+  Ajv2.prototype.addFormat = addFormat;
   Ajv2.prototype.errorsText = errorsText;
   Ajv2.prototype._addSchema = _addSchema;
   Ajv2.prototype._compile = _compile;
@@ -14160,7 +15298,7 @@ function requireAjv() {
     }
     return text.slice(0, -separator.length);
   }
-  function addFormat2(name, format2) {
+  function addFormat(name, format2) {
     if (typeof format2 == "string") format2 = new RegExp(format2);
     this._formats[name] = format2;
     return this;
@@ -14403,1288 +15541,390 @@ class Server extends Protocol {
     return this.notification({ method: "notifications/prompts/list_changed" });
   }
 }
-const ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
-const defaultOptions = {
-  name: void 0,
-  $refStrategy: "root",
-  basePath: ["#"],
-  effectStrategy: "input",
-  pipeStrategy: "all",
-  dateStrategy: "format:date-time",
-  mapStrategy: "entries",
-  removeAdditionalStrategy: "passthrough",
-  allowedAdditionalProperties: true,
-  rejectedAdditionalProperties: false,
-  definitionPath: "definitions",
-  target: "jsonSchema7",
-  strictUnions: false,
-  definitions: {},
-  errorMessages: false,
-  markdownDescription: false,
-  patternStrategy: "escape",
-  applyRegexFlags: false,
-  emailStrategy: "format:email",
-  base64Strategy: "contentEncoding:base64",
-  nameStrategy: "ref",
-  openAiAnyTypeName: "OpenAiAnyType"
-};
-const getDefaultOptions = (options) => typeof options === "string" ? {
-  ...defaultOptions,
-  name: options
-} : {
-  ...defaultOptions,
-  ...options
-};
-const getRefs = (options) => {
-  const _options = getDefaultOptions(options);
-  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
-  return {
-    ..._options,
-    flags: { hasReferencedOpenAiAnyType: false },
-    currentPath,
-    propertyPath: void 0,
-    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
-      def._def,
-      {
-        def: def._def,
-        path: [..._options.basePath, _options.definitionPath, name],
-        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
-        jsonSchema: void 0
-      }
-    ]))
-  };
-};
-function addErrorMessage(res, key, errorMessage, refs) {
-  if (!(refs == null ? void 0 : refs.errorMessages))
-    return;
-  if (errorMessage) {
-    res.errorMessage = {
-      ...res.errorMessage,
-      [key]: errorMessage
+var McpZodTypeKind;
+(function(McpZodTypeKind2) {
+  McpZodTypeKind2["Completable"] = "McpCompletable";
+})(McpZodTypeKind || (McpZodTypeKind = {}));
+class Completable {
+  // ZodType compatibility properties
+  get _output() {
+    return this._wrappedType._output;
+  }
+  get _input() {
+    return this._wrappedType._input;
+  }
+  get def() {
+    return this._wrappedType.def;
+  }
+  get type() {
+    return this._wrappedType.type;
+  }
+  get _zod() {
+    return this._wrappedType._zod;
+  }
+  get "~standard"() {
+    return this._wrappedType["~standard"];
+  }
+  constructor(type2, complete) {
+    this._wrappedType = type2;
+    this._def = {
+      type: type2._def.type,
+      complete,
+      typeName: McpZodTypeKind.Completable,
+      wrappedType: type2
     };
   }
-}
-function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
-  res[key] = value;
-  addErrorMessage(res, key, errorMessage, refs);
-}
-const getRelativePath = (pathA, pathB) => {
-  let i = 0;
-  for (; i < pathA.length && i < pathB.length; i++) {
-    if (pathA[i] !== pathB[i])
-      break;
+  // Core parsing methods
+  parse(input) {
+    return this._wrappedType.parse(input);
   }
-  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
-};
-function parseAnyDef(refs) {
-  if (refs.target !== "openAi") {
-    return {};
-  }
-  const anyDefinitionPath = [
-    ...refs.basePath,
-    refs.definitionPath,
-    refs.openAiAnyTypeName
-  ];
-  refs.flags.hasReferencedOpenAiAnyType = true;
-  return {
-    $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
-  };
-}
-function parseArrayDef(def, refs) {
-  var _a, _b, _c;
-  const res = {
-    type: "array"
-  };
-  if (((_a = def.type) == null ? void 0 : _a._def) && ((_c = (_b = def.type) == null ? void 0 : _b._def) == null ? void 0 : _c.typeName) !== zod.ZodFirstPartyTypeKind.ZodAny) {
-    res.items = parseDef(def.type._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "items"]
-    });
+  safeParse(input) {
+    return this._wrappedType.safeParse(input);
   }
-  if (def.minLength) {
-    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+  parseAsync(input) {
+    return this._wrappedType.parseAsync(input);
   }
-  if (def.maxLength) {
-    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+  safeParseAsync(input) {
+    return this._wrappedType.safeParseAsync(input);
   }
-  if (def.exactLength) {
-    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
-    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+  // Schema manipulation methods
+  optional() {
+    return new Completable(this._wrappedType.optional(), this._def.complete);
   }
-  return res;
-}
-function parseBigintDef(def, refs) {
-  const res = {
-    type: "integer",
-    format: "int64"
-  };
-  if (!def.checks)
-    return res;
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "min":
-        if (refs.target === "jsonSchema7") {
-          if (check.inclusive) {
-            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
-          }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMinimum = true;
-          }
-          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-        }
-        break;
-      case "max":
-        if (refs.target === "jsonSchema7") {
-          if (check.inclusive) {
-            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
-          }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMaximum = true;
-          }
-          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-        }
-        break;
-      case "multipleOf":
-        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
-        break;
-    }
+  nullable() {
+    return new Completable(this._wrappedType.nullable(), this._def.complete);
+  }
+  nullish() {
+    return new Completable(this._wrappedType.nullish(), this._def.complete);
+  }
+  nonoptional() {
+    return new Completable(this._wrappedType.nonoptional(), this._def.complete);
+  }
+  array() {
+    return this._wrappedType.array();
+  }
+  or(schema) {
+    return this._wrappedType.or(schema);
+  }
+  and(schema) {
+    return this._wrappedType.and(schema);
+  }
+  // Transformation methods
+  transform(transformer) {
+    return this._wrappedType.transform(transformer);
+  }
+  default(defaultValue) {
+    return new Completable(this._wrappedType.default(defaultValue), this._def.complete);
+  }
+  catch(catchValue) {
+    return new Completable(this._wrappedType.catch(catchValue), this._def.complete);
+  }
+  pipe(schema) {
+    return this._wrappedType.pipe(schema);
+  }
+  // Additional ZodType v4 methods
+  register(registry, ...meta) {
+    return this._wrappedType.register(registry, ...meta);
+  }
+  spa(input) {
+    return this._wrappedType.spa(input);
+  }
+  overwrite(overrides) {
+    return new Completable(this._wrappedType.overwrite(overrides), this._def.complete);
+  }
+  prefault(prefaultValue) {
+    return new Completable(this._wrappedType.prefault(prefaultValue), this._def.complete);
+  }
+  // Refinement methods
+  refine(refinement, message) {
+    return this._wrappedType.refine(refinement, message);
+  }
+  superRefine(refinement) {
+    return this._wrappedType.superRefine(refinement);
+  }
+  // Utility methods
+  readonly() {
+    return this._wrappedType.readonly();
+  }
+  describe(description2) {
+    return new Completable(this._wrappedType.describe(description2), this._def.complete);
+  }
+  meta(meta) {
+    return this._wrappedType.meta(meta);
+  }
+  brand() {
+    return this._wrappedType.brand();
+  }
+  check(check) {
+    return this._wrappedType.check(check);
+  }
+  clone() {
+    return new Completable(this._wrappedType.clone(), this._def.complete);
+  }
+  // Status check methods
+  isOptional() {
+    return this._wrappedType.isOptional();
+  }
+  isNullable() {
+    return this._wrappedType.isNullable();
+  }
+  // Utility getters
+  get description() {
+    return this._wrappedType.description;
+  }
+  // Completable-specific methods
+  unwrap() {
+    return this._def.wrappedType;
+  }
+  async complete(value, context) {
+    return this._def.complete(value, context);
   }
-  return res;
-}
-function parseBooleanDef() {
-  return {
-    type: "boolean"
-  };
-}
-function parseBrandedDef(_def, refs) {
-  return parseDef(_def.type._def, refs);
 }
-const parseCatchDef = (def, refs) => {
-  return parseDef(def.innerType._def, refs);
+Completable.create = (type2, complete) => {
+  return new Completable(type2, complete);
 };
-function parseDateDef(def, refs, overrideDateStrategy) {
-  const strategy = overrideDateStrategy ?? refs.dateStrategy;
-  if (Array.isArray(strategy)) {
-    return {
-      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
-    };
+const MAX_TEMPLATE_LENGTH = 1e6;
+const MAX_VARIABLE_LENGTH = 1e6;
+const MAX_TEMPLATE_EXPRESSIONS = 1e4;
+const MAX_REGEX_LENGTH = 1e6;
+class UriTemplate {
+  /**
+   * Returns true if the given string contains any URI template expressions.
+   * A template expression is a sequence of characters enclosed in curly braces,
+   * like {foo} or {?bar}.
+   */
+  static isTemplate(str) {
+    return /\{[^}\s]+\}/.test(str);
   }
-  switch (strategy) {
-    case "string":
-    case "format:date-time":
-      return {
-        type: "string",
-        format: "date-time"
-      };
-    case "format:date":
-      return {
-        type: "string",
-        format: "date"
-      };
-    case "integer":
-      return integerDateParser(def, refs);
+  static validateLength(str, max, context) {
+    if (str.length > max) {
+      throw new Error(`${context} exceeds maximum length of ${max} characters (got ${str.length})`);
+    }
   }
-}
-const integerDateParser = (def, refs) => {
-  const res = {
-    type: "integer",
-    format: "unix-time"
-  };
-  if (refs.target === "openApi3") {
-    return res;
+  get variableNames() {
+    return this.parts.flatMap((part) => typeof part === "string" ? [] : part.names);
   }
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "min":
-        setResponseValueAndErrors(
-          res,
-          "minimum",
-          check.value,
-          // This is in milliseconds
-          check.message,
-          refs
-        );
+  constructor(template) {
+    UriTemplate.validateLength(template, MAX_TEMPLATE_LENGTH, "Template");
+    this.template = template;
+    this.parts = this.parse(template);
+  }
+  toString() {
+    return this.template;
+  }
+  parse(template) {
+    const parts = [];
+    let currentText = "";
+    let i = 0;
+    let expressionCount = 0;
+    while (i < template.length) {
+      if (template[i] === "{") {
+        if (currentText) {
+          parts.push(currentText);
+          currentText = "";
+        }
+        const end = template.indexOf("}", i);
+        if (end === -1)
+          throw new Error("Unclosed template expression");
+        expressionCount++;
+        if (expressionCount > MAX_TEMPLATE_EXPRESSIONS) {
+          throw new Error(`Template contains too many expressions (max ${MAX_TEMPLATE_EXPRESSIONS})`);
+        }
+        const expr = template.slice(i + 1, end);
+        const operator = this.getOperator(expr);
+        const exploded = expr.includes("*");
+        const names = this.getNames(expr);
+        const name = names[0];
+        for (const name2 of names) {
+          UriTemplate.validateLength(name2, MAX_VARIABLE_LENGTH, "Variable name");
+        }
+        parts.push({ name, operator, names, exploded });
+        i = end + 1;
+      } else {
+        currentText += template[i];
+        i++;
+      }
+    }
+    if (currentText) {
+      parts.push(currentText);
+    }
+    return parts;
+  }
+  getOperator(expr) {
+    const operators = ["+", "#", ".", "/", "?", "&"];
+    return operators.find((op) => expr.startsWith(op)) || "";
+  }
+  getNames(expr) {
+    const operator = this.getOperator(expr);
+    return expr.slice(operator.length).split(",").map((name) => name.replace("*", "").trim()).filter((name) => name.length > 0);
+  }
+  encodeValue(value, operator) {
+    UriTemplate.validateLength(value, MAX_VARIABLE_LENGTH, "Variable value");
+    if (operator === "+" || operator === "#") {
+      return encodeURI(value);
+    }
+    return encodeURIComponent(value);
+  }
+  expandPart(part, variables) {
+    if (part.operator === "?" || part.operator === "&") {
+      const pairs = part.names.map((name) => {
+        const value2 = variables[name];
+        if (value2 === void 0)
+          return "";
+        const encoded2 = Array.isArray(value2) ? value2.map((v) => this.encodeValue(v, part.operator)).join(",") : this.encodeValue(value2.toString(), part.operator);
+        return `${name}=${encoded2}`;
+      }).filter((pair) => pair.length > 0);
+      if (pairs.length === 0)
+        return "";
+      const separator = part.operator === "?" ? "?" : "&";
+      return separator + pairs.join("&");
+    }
+    if (part.names.length > 1) {
+      const values2 = part.names.map((name) => variables[name]).filter((v) => v !== void 0);
+      if (values2.length === 0)
+        return "";
+      return values2.map((v) => Array.isArray(v) ? v[0] : v).join(",");
+    }
+    const value = variables[part.name];
+    if (value === void 0)
+      return "";
+    const values = Array.isArray(value) ? value : [value];
+    const encoded = values.map((v) => this.encodeValue(v, part.operator));
+    switch (part.operator) {
+      case "":
+        return encoded.join(",");
+      case "+":
+        return encoded.join(",");
+      case "#":
+        return "#" + encoded.join(",");
+      case ".":
+        return "." + encoded.join(".");
+      case "/":
+        return "/" + encoded.join("/");
+      default:
+        return encoded.join(",");
+    }
+  }
+  expand(variables) {
+    let result = "";
+    let hasQueryParam = false;
+    for (const part of this.parts) {
+      if (typeof part === "string") {
+        result += part;
+        continue;
+      }
+      const expanded = this.expandPart(part, variables);
+      if (!expanded)
+        continue;
+      if ((part.operator === "?" || part.operator === "&") && hasQueryParam) {
+        result += expanded.replace("?", "&");
+      } else {
+        result += expanded;
+      }
+      if (part.operator === "?" || part.operator === "&") {
+        hasQueryParam = true;
+      }
+    }
+    return result;
+  }
+  escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  partToRegExp(part) {
+    const patterns = [];
+    for (const name2 of part.names) {
+      UriTemplate.validateLength(name2, MAX_VARIABLE_LENGTH, "Variable name");
+    }
+    if (part.operator === "?" || part.operator === "&") {
+      for (let i = 0; i < part.names.length; i++) {
+        const name2 = part.names[i];
+        const prefix = i === 0 ? "\\" + part.operator : "&";
+        patterns.push({
+          pattern: prefix + this.escapeRegExp(name2) + "=([^&]+)",
+          name: name2
+        });
+      }
+      return patterns;
+    }
+    let pattern2;
+    const name = part.name;
+    switch (part.operator) {
+      case "":
+        pattern2 = part.exploded ? "([^/]+(?:,[^/]+)*)" : "([^/,]+)";
         break;
-      case "max":
-        setResponseValueAndErrors(
-          res,
-          "maximum",
-          check.value,
-          // This is in milliseconds
-          check.message,
-          refs
-        );
+      case "+":
+      case "#":
+        pattern2 = "(.+)";
         break;
+      case ".":
+        pattern2 = "\\.([^/,]+)";
+        break;
+      case "/":
+        pattern2 = "/" + (part.exploded ? "([^/]+(?:,[^/]+)*)" : "([^/,]+)");
+        break;
+      default:
+        pattern2 = "([^/]+)";
     }
+    patterns.push({ pattern: pattern2, name });
+    return patterns;
   }
-  return res;
-};
-function parseDefaultDef(_def, refs) {
-  return {
-    ...parseDef(_def.innerType._def, refs),
-    default: _def.defaultValue()
-  };
-}
-function parseEffectsDef(_def, refs) {
-  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
-}
-function parseEnumDef(def) {
-  return {
-    type: "string",
-    enum: Array.from(def.values)
-  };
-}
-const isJsonSchema7AllOfType = (type2) => {
-  if ("type" in type2 && type2.type === "string")
-    return false;
-  return "allOf" in type2;
-};
-function parseIntersectionDef(def, refs) {
-  const allOf2 = [
-    parseDef(def.left._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "allOf", "0"]
-    }),
-    parseDef(def.right._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "allOf", "1"]
-    })
-  ].filter((x) => !!x);
-  let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
-  const mergedAllOf = [];
-  allOf2.forEach((schema) => {
-    if (isJsonSchema7AllOfType(schema)) {
-      mergedAllOf.push(...schema.allOf);
-      if (schema.unevaluatedProperties === void 0) {
-        unevaluatedProperties = void 0;
+  match(uri) {
+    UriTemplate.validateLength(uri, MAX_TEMPLATE_LENGTH, "URI");
+    let pattern2 = "^";
+    const names = [];
+    for (const part of this.parts) {
+      if (typeof part === "string") {
+        pattern2 += this.escapeRegExp(part);
+      } else {
+        const patterns = this.partToRegExp(part);
+        for (const { pattern: partPattern, name } of patterns) {
+          pattern2 += partPattern;
+          names.push({ name, exploded: part.exploded });
+        }
       }
-    } else {
-      let nestedSchema = schema;
-      if ("additionalProperties" in schema && schema.additionalProperties === false) {
-        const { additionalProperties: additionalProperties2, ...rest } = schema;
-        nestedSchema = rest;
+    }
+    pattern2 += "$";
+    UriTemplate.validateLength(pattern2, MAX_REGEX_LENGTH, "Generated regex pattern");
+    const regex = new RegExp(pattern2);
+    const match = uri.match(regex);
+    if (!match)
+      return null;
+    const result = {};
+    for (let i = 0; i < names.length; i++) {
+      const { name, exploded } = names[i];
+      const value = match[i + 1];
+      const cleanName = name.replace("*", "");
+      if (exploded && value.includes(",")) {
+        result[cleanName] = value.split(",");
       } else {
-        unevaluatedProperties = void 0;
+        result[cleanName] = value;
       }
-      mergedAllOf.push(nestedSchema);
     }
-  });
-  return mergedAllOf.length ? {
-    allOf: mergedAllOf,
-    ...unevaluatedProperties
-  } : void 0;
-}
-function parseLiteralDef(def, refs) {
-  const parsedType = typeof def.value;
-  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
-    return {
-      type: Array.isArray(def.value) ? "array" : "object"
-    };
-  }
-  if (refs.target === "openApi3") {
-    return {
-      type: parsedType === "bigint" ? "integer" : parsedType,
-      enum: [def.value]
-    };
+    return result;
   }
-  return {
-    type: parsedType === "bigint" ? "integer" : parsedType,
-    const: def.value
-  };
 }
-let emojiRegex = void 0;
-const zodPatterns = {
-  /**
-   * `c` was changed to `[cC]` to replicate /i flag
-   */
-  cuid: /^[cC][^\s-]{8,}$/,
-  cuid2: /^[0-9a-z]+$/,
-  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
-  /**
-   * `a-z` was added to replicate /i flag
-   */
-  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+class McpServer {
+  constructor(serverInfo, options) {
+    this._registeredResources = {};
+    this._registeredResourceTemplates = {};
+    this._registeredTools = {};
+    this._registeredPrompts = {};
+    this._toolHandlersInitialized = false;
+    this._completionHandlerInitialized = false;
+    this._resourceHandlersInitialized = false;
+    this._promptHandlersInitialized = false;
+    this.server = new Server(serverInfo, options);
+  }
   /**
-   * Constructed a valid Unicode RegExp
-   *
-   * Lazily instantiate since this type of regex isn't supported
-   * in all envs (e.g. React Native).
+   * Attaches to the given transport, starts it, and starts listening for messages.
    *
-   * See:
-   * https://github.com/colinhacks/zod/issues/2433
-   * Fix in Zod:
-   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
-   */
-  emoji: () => {
-    if (emojiRegex === void 0) {
-      emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
-    }
-    return emojiRegex;
-  },
-  /**
-   * Unused
-   */
-  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
-  /**
-   * Unused
+   * The `server` object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
    */
-  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
-  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+  async connect(transport) {
+    return await this.server.connect(transport);
+  }
   /**
-   * Unused
-   */
-  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
-  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
-  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
-  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
-  nanoid: /^[a-zA-Z0-9_-]{21}$/,
-  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
-};
-function parseStringDef(def, refs) {
-  const res = {
-    type: "string"
-  };
-  if (def.checks) {
-    for (const check of def.checks) {
-      switch (check.kind) {
-        case "min":
-          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
-          break;
-        case "max":
-          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
-          break;
-        case "email":
-          switch (refs.emailStrategy) {
-            case "format:email":
-              addFormat(res, "email", check.message, refs);
-              break;
-            case "format:idn-email":
-              addFormat(res, "idn-email", check.message, refs);
-              break;
-            case "pattern:zod":
-              addPattern(res, zodPatterns.email, check.message, refs);
-              break;
-          }
-          break;
-        case "url":
-          addFormat(res, "uri", check.message, refs);
-          break;
-        case "uuid":
-          addFormat(res, "uuid", check.message, refs);
-          break;
-        case "regex":
-          addPattern(res, check.regex, check.message, refs);
-          break;
-        case "cuid":
-          addPattern(res, zodPatterns.cuid, check.message, refs);
-          break;
-        case "cuid2":
-          addPattern(res, zodPatterns.cuid2, check.message, refs);
-          break;
-        case "startsWith":
-          addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
-          break;
-        case "endsWith":
-          addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
-          break;
-        case "datetime":
-          addFormat(res, "date-time", check.message, refs);
-          break;
-        case "date":
-          addFormat(res, "date", check.message, refs);
-          break;
-        case "time":
-          addFormat(res, "time", check.message, refs);
-          break;
-        case "duration":
-          addFormat(res, "duration", check.message, refs);
-          break;
-        case "length":
-          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
-          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
-          break;
-        case "includes": {
-          addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
-          break;
-        }
-        case "ip": {
-          if (check.version !== "v6") {
-            addFormat(res, "ipv4", check.message, refs);
-          }
-          if (check.version !== "v4") {
-            addFormat(res, "ipv6", check.message, refs);
-          }
-          break;
-        }
-        case "base64url":
-          addPattern(res, zodPatterns.base64url, check.message, refs);
-          break;
-        case "jwt":
-          addPattern(res, zodPatterns.jwt, check.message, refs);
-          break;
-        case "cidr": {
-          if (check.version !== "v6") {
-            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
-          }
-          if (check.version !== "v4") {
-            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
-          }
-          break;
-        }
-        case "emoji":
-          addPattern(res, zodPatterns.emoji(), check.message, refs);
-          break;
-        case "ulid": {
-          addPattern(res, zodPatterns.ulid, check.message, refs);
-          break;
-        }
-        case "base64": {
-          switch (refs.base64Strategy) {
-            case "format:binary": {
-              addFormat(res, "binary", check.message, refs);
-              break;
-            }
-            case "contentEncoding:base64": {
-              setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
-              break;
-            }
-            case "pattern:zod": {
-              addPattern(res, zodPatterns.base64, check.message, refs);
-              break;
-            }
-          }
-          break;
-        }
-        case "nanoid": {
-          addPattern(res, zodPatterns.nanoid, check.message, refs);
-        }
-      }
-    }
-  }
-  return res;
-}
-function escapeLiteralCheckValue(literal, refs) {
-  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
-}
-const ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
-function escapeNonAlphaNumeric(source) {
-  let result = "";
-  for (let i = 0; i < source.length; i++) {
-    if (!ALPHA_NUMERIC.has(source[i])) {
-      result += "\\";
-    }
-    result += source[i];
-  }
-  return result;
-}
-function addFormat(schema, value, message, refs) {
-  var _a;
-  if (schema.format || ((_a = schema.anyOf) == null ? void 0 : _a.some((x) => x.format))) {
-    if (!schema.anyOf) {
-      schema.anyOf = [];
-    }
-    if (schema.format) {
-      schema.anyOf.push({
-        format: schema.format,
-        ...schema.errorMessage && refs.errorMessages && {
-          errorMessage: { format: schema.errorMessage.format }
-        }
-      });
-      delete schema.format;
-      if (schema.errorMessage) {
-        delete schema.errorMessage.format;
-        if (Object.keys(schema.errorMessage).length === 0) {
-          delete schema.errorMessage;
-        }
-      }
-    }
-    schema.anyOf.push({
-      format: value,
-      ...message && refs.errorMessages && { errorMessage: { format: message } }
-    });
-  } else {
-    setResponseValueAndErrors(schema, "format", value, message, refs);
-  }
-}
-function addPattern(schema, regex, message, refs) {
-  var _a;
-  if (schema.pattern || ((_a = schema.allOf) == null ? void 0 : _a.some((x) => x.pattern))) {
-    if (!schema.allOf) {
-      schema.allOf = [];
-    }
-    if (schema.pattern) {
-      schema.allOf.push({
-        pattern: schema.pattern,
-        ...schema.errorMessage && refs.errorMessages && {
-          errorMessage: { pattern: schema.errorMessage.pattern }
-        }
-      });
-      delete schema.pattern;
-      if (schema.errorMessage) {
-        delete schema.errorMessage.pattern;
-        if (Object.keys(schema.errorMessage).length === 0) {
-          delete schema.errorMessage;
-        }
-      }
-    }
-    schema.allOf.push({
-      pattern: stringifyRegExpWithFlags(regex, refs),
-      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
-    });
-  } else {
-    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
-  }
-}
-function stringifyRegExpWithFlags(regex, refs) {
-  var _a;
-  if (!refs.applyRegexFlags || !regex.flags) {
-    return regex.source;
-  }
-  const flags = {
-    i: regex.flags.includes("i"),
-    m: regex.flags.includes("m"),
-    s: regex.flags.includes("s")
-    // `.` matches newlines
-  };
-  const source = flags.i ? regex.source.toLowerCase() : regex.source;
-  let pattern2 = "";
-  let isEscaped = false;
-  let inCharGroup = false;
-  let inCharRange = false;
-  for (let i = 0; i < source.length; i++) {
-    if (isEscaped) {
-      pattern2 += source[i];
-      isEscaped = false;
-      continue;
-    }
-    if (flags.i) {
-      if (inCharGroup) {
-        if (source[i].match(/[a-z]/)) {
-          if (inCharRange) {
-            pattern2 += source[i];
-            pattern2 += `${source[i - 2]}-${source[i]}`.toUpperCase();
-            inCharRange = false;
-          } else if (source[i + 1] === "-" && ((_a = source[i + 2]) == null ? void 0 : _a.match(/[a-z]/))) {
-            pattern2 += source[i];
-            inCharRange = true;
-          } else {
-            pattern2 += `${source[i]}${source[i].toUpperCase()}`;
-          }
-          continue;
-        }
-      } else if (source[i].match(/[a-z]/)) {
-        pattern2 += `[${source[i]}${source[i].toUpperCase()}]`;
-        continue;
-      }
-    }
-    if (flags.m) {
-      if (source[i] === "^") {
-        pattern2 += `(^|(?<=[\r
-]))`;
-        continue;
-      } else if (source[i] === "$") {
-        pattern2 += `($|(?=[\r
-]))`;
-        continue;
-      }
-    }
-    if (flags.s && source[i] === ".") {
-      pattern2 += inCharGroup ? `${source[i]}\r
-` : `[${source[i]}\r
-]`;
-      continue;
-    }
-    pattern2 += source[i];
-    if (source[i] === "\\") {
-      isEscaped = true;
-    } else if (inCharGroup && source[i] === "]") {
-      inCharGroup = false;
-    } else if (!inCharGroup && source[i] === "[") {
-      inCharGroup = true;
-    }
-  }
-  try {
-    new RegExp(pattern2);
-  } catch {
-    console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
-    return regex.source;
-  }
-  return pattern2;
-}
-function parseRecordDef(def, refs) {
-  var _a, _b, _c, _d, _e, _f;
-  if (refs.target === "openAi") {
-    console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
-  }
-  if (refs.target === "openApi3" && ((_a = def.keyType) == null ? void 0 : _a._def.typeName) === zod.ZodFirstPartyTypeKind.ZodEnum) {
-    return {
-      type: "object",
-      required: def.keyType._def.values,
-      properties: def.keyType._def.values.reduce((acc, key) => ({
-        ...acc,
-        [key]: parseDef(def.valueType._def, {
-          ...refs,
-          currentPath: [...refs.currentPath, "properties", key]
-        }) ?? parseAnyDef(refs)
-      }), {}),
-      additionalProperties: refs.rejectedAdditionalProperties
-    };
-  }
-  const schema = {
-    type: "object",
-    additionalProperties: parseDef(def.valueType._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    }) ?? refs.allowedAdditionalProperties
-  };
-  if (refs.target === "openApi3") {
-    return schema;
-  }
-  if (((_b = def.keyType) == null ? void 0 : _b._def.typeName) === zod.ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? void 0 : _c.length)) {
-    const { type: type2, ...keyType } = parseStringDef(def.keyType._def, refs);
-    return {
-      ...schema,
-      propertyNames: keyType
-    };
-  } else if (((_d = def.keyType) == null ? void 0 : _d._def.typeName) === zod.ZodFirstPartyTypeKind.ZodEnum) {
-    return {
-      ...schema,
-      propertyNames: {
-        enum: def.keyType._def.values
-      }
-    };
-  } else if (((_e = def.keyType) == null ? void 0 : _e._def.typeName) === zod.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === zod.ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? void 0 : _f.length)) {
-    const { type: type2, ...keyType } = parseBrandedDef(def.keyType._def, refs);
-    return {
-      ...schema,
-      propertyNames: keyType
-    };
-  }
-  return schema;
-}
-function parseMapDef(def, refs) {
-  if (refs.mapStrategy === "record") {
-    return parseRecordDef(def, refs);
-  }
-  const keys = parseDef(def.keyType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items", "items", "0"]
-  }) || parseAnyDef(refs);
-  const values = parseDef(def.valueType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items", "items", "1"]
-  }) || parseAnyDef(refs);
-  return {
-    type: "array",
-    maxItems: 125,
-    items: {
-      type: "array",
-      items: [keys, values],
-      minItems: 2,
-      maxItems: 2
-    }
-  };
-}
-function parseNativeEnumDef(def) {
-  const object = def.values;
-  const actualKeys = Object.keys(def.values).filter((key) => {
-    return typeof object[object[key]] !== "number";
-  });
-  const actualValues = actualKeys.map((key) => object[key]);
-  const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
-  return {
-    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
-    enum: actualValues
-  };
-}
-function parseNeverDef(refs) {
-  return refs.target === "openAi" ? void 0 : {
-    not: parseAnyDef({
-      ...refs,
-      currentPath: [...refs.currentPath, "not"]
-    })
-  };
-}
-function parseNullDef(refs) {
-  return refs.target === "openApi3" ? {
-    enum: ["null"],
-    nullable: true
-  } : {
-    type: "null"
-  };
-}
-const primitiveMappings = {
-  ZodString: "string",
-  ZodNumber: "number",
-  ZodBigInt: "integer",
-  ZodBoolean: "boolean",
-  ZodNull: "null"
-};
-function parseUnionDef(def, refs) {
-  if (refs.target === "openApi3")
-    return asAnyOf(def, refs);
-  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
-  if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
-    const types = options.reduce((types2, x) => {
-      const type2 = primitiveMappings[x._def.typeName];
-      return type2 && !types2.includes(type2) ? [...types2, type2] : types2;
-    }, []);
-    return {
-      type: types.length > 1 ? types : types[0]
-    };
-  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    const types = options.reduce((acc, x) => {
-      const type2 = typeof x._def.value;
-      switch (type2) {
-        case "string":
-        case "number":
-        case "boolean":
-          return [...acc, type2];
-        case "bigint":
-          return [...acc, "integer"];
-        case "object":
-          if (x._def.value === null)
-            return [...acc, "null"];
-        case "symbol":
-        case "undefined":
-        case "function":
-        default:
-          return acc;
-      }
-    }, []);
-    if (types.length === options.length) {
-      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
-      return {
-        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
-        enum: options.reduce((acc, x) => {
-          return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
-        }, [])
-      };
-    }
-  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
-    return {
-      type: "string",
-      enum: options.reduce((acc, x) => [
-        ...acc,
-        ...x._def.values.filter((x2) => !acc.includes(x2))
-      ], [])
-    };
-  }
-  return asAnyOf(def, refs);
-}
-const asAnyOf = (def, refs) => {
-  const anyOf2 = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", `${i}`]
-  })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
-  return anyOf2.length ? { anyOf: anyOf2 } : void 0;
-};
-function parseNullableDef(def, refs) {
-  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
-    if (refs.target === "openApi3") {
-      return {
-        type: primitiveMappings[def.innerType._def.typeName],
-        nullable: true
-      };
-    }
-    return {
-      type: [
-        primitiveMappings[def.innerType._def.typeName],
-        "null"
-      ]
-    };
-  }
-  if (refs.target === "openApi3") {
-    const base2 = parseDef(def.innerType._def, {
-      ...refs,
-      currentPath: [...refs.currentPath]
-    });
-    if (base2 && "$ref" in base2)
-      return { allOf: [base2], nullable: true };
-    return base2 && { ...base2, nullable: true };
-  }
-  const base = parseDef(def.innerType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", "0"]
-  });
-  return base && { anyOf: [base, { type: "null" }] };
-}
-function parseNumberDef(def, refs) {
-  const res = {
-    type: "number"
-  };
-  if (!def.checks)
-    return res;
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "int":
-        res.type = "integer";
-        addErrorMessage(res, "type", check.message, refs);
-        break;
-      case "min":
-        if (refs.target === "jsonSchema7") {
-          if (check.inclusive) {
-            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
-          }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMinimum = true;
-          }
-          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-        }
-        break;
-      case "max":
-        if (refs.target === "jsonSchema7") {
-          if (check.inclusive) {
-            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
-          }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMaximum = true;
-          }
-          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-        }
-        break;
-      case "multipleOf":
-        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
-        break;
-    }
-  }
-  return res;
-}
-function parseObjectDef(def, refs) {
-  const forceOptionalIntoNullable = refs.target === "openAi";
-  const result = {
-    type: "object",
-    properties: {}
-  };
-  const required2 = [];
-  const shape = def.shape();
-  for (const propName in shape) {
-    let propDef = shape[propName];
-    if (propDef === void 0 || propDef._def === void 0) {
-      continue;
-    }
-    let propOptional = safeIsOptional(propDef);
-    if (propOptional && forceOptionalIntoNullable) {
-      if (propDef._def.typeName === "ZodOptional") {
-        propDef = propDef._def.innerType;
-      }
-      if (!propDef.isNullable()) {
-        propDef = propDef.nullable();
-      }
-      propOptional = false;
-    }
-    const parsedDef = parseDef(propDef._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "properties", propName],
-      propertyPath: [...refs.currentPath, "properties", propName]
-    });
-    if (parsedDef === void 0) {
-      continue;
-    }
-    result.properties[propName] = parsedDef;
-    if (!propOptional) {
-      required2.push(propName);
-    }
-  }
-  if (required2.length) {
-    result.required = required2;
-  }
-  const additionalProperties2 = decideAdditionalProperties(def, refs);
-  if (additionalProperties2 !== void 0) {
-    result.additionalProperties = additionalProperties2;
-  }
-  return result;
-}
-function decideAdditionalProperties(def, refs) {
-  if (def.catchall._def.typeName !== "ZodNever") {
-    return parseDef(def.catchall._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    });
-  }
-  switch (def.unknownKeys) {
-    case "passthrough":
-      return refs.allowedAdditionalProperties;
-    case "strict":
-      return refs.rejectedAdditionalProperties;
-    case "strip":
-      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
-  }
-}
-function safeIsOptional(schema) {
-  try {
-    return schema.isOptional();
-  } catch {
-    return true;
-  }
-}
-const parseOptionalDef = (def, refs) => {
-  var _a;
-  if (refs.currentPath.toString() === ((_a = refs.propertyPath) == null ? void 0 : _a.toString())) {
-    return parseDef(def.innerType._def, refs);
-  }
-  const innerSchema = parseDef(def.innerType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", "1"]
-  });
-  return innerSchema ? {
-    anyOf: [
-      {
-        not: parseAnyDef(refs)
-      },
-      innerSchema
-    ]
-  } : parseAnyDef(refs);
-};
-const parsePipelineDef = (def, refs) => {
-  if (refs.pipeStrategy === "input") {
-    return parseDef(def.in._def, refs);
-  } else if (refs.pipeStrategy === "output") {
-    return parseDef(def.out._def, refs);
-  }
-  const a = parseDef(def.in._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "allOf", "0"]
-  });
-  const b = parseDef(def.out._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
-  });
-  return {
-    allOf: [a, b].filter((x) => x !== void 0)
-  };
-};
-function parsePromiseDef(def, refs) {
-  return parseDef(def.type._def, refs);
-}
-function parseSetDef(def, refs) {
-  const items2 = parseDef(def.valueType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items"]
-  });
-  const schema = {
-    type: "array",
-    uniqueItems: true,
-    items: items2
-  };
-  if (def.minSize) {
-    setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
-  }
-  if (def.maxSize) {
-    setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
-  }
-  return schema;
-}
-function parseTupleDef(def, refs) {
-  if (def.rest) {
-    return {
-      type: "array",
-      minItems: def.items.length,
-      items: def.items.map((x, i) => parseDef(x._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", `${i}`]
-      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
-      additionalItems: parseDef(def.rest._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "additionalItems"]
-      })
-    };
-  } else {
-    return {
-      type: "array",
-      minItems: def.items.length,
-      maxItems: def.items.length,
-      items: def.items.map((x, i) => parseDef(x._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", `${i}`]
-      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
-    };
-  }
-}
-function parseUndefinedDef(refs) {
-  return {
-    not: parseAnyDef(refs)
-  };
-}
-function parseUnknownDef(refs) {
-  return parseAnyDef(refs);
-}
-const parseReadonlyDef = (def, refs) => {
-  return parseDef(def.innerType._def, refs);
-};
-const selectParser = (def, typeName, refs) => {
-  switch (typeName) {
-    case zod.ZodFirstPartyTypeKind.ZodString:
-      return parseStringDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodNumber:
-      return parseNumberDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodObject:
-      return parseObjectDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodBigInt:
-      return parseBigintDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodBoolean:
-      return parseBooleanDef();
-    case zod.ZodFirstPartyTypeKind.ZodDate:
-      return parseDateDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodUndefined:
-      return parseUndefinedDef(refs);
-    case zod.ZodFirstPartyTypeKind.ZodNull:
-      return parseNullDef(refs);
-    case zod.ZodFirstPartyTypeKind.ZodArray:
-      return parseArrayDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodUnion:
-    case zod.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-      return parseUnionDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodIntersection:
-      return parseIntersectionDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodTuple:
-      return parseTupleDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodRecord:
-      return parseRecordDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodLiteral:
-      return parseLiteralDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodEnum:
-      return parseEnumDef(def);
-    case zod.ZodFirstPartyTypeKind.ZodNativeEnum:
-      return parseNativeEnumDef(def);
-    case zod.ZodFirstPartyTypeKind.ZodNullable:
-      return parseNullableDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodOptional:
-      return parseOptionalDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodMap:
-      return parseMapDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodSet:
-      return parseSetDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodLazy:
-      return () => def.getter()._def;
-    case zod.ZodFirstPartyTypeKind.ZodPromise:
-      return parsePromiseDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodNaN:
-    case zod.ZodFirstPartyTypeKind.ZodNever:
-      return parseNeverDef(refs);
-    case zod.ZodFirstPartyTypeKind.ZodEffects:
-      return parseEffectsDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodAny:
-      return parseAnyDef(refs);
-    case zod.ZodFirstPartyTypeKind.ZodUnknown:
-      return parseUnknownDef(refs);
-    case zod.ZodFirstPartyTypeKind.ZodDefault:
-      return parseDefaultDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodBranded:
-      return parseBrandedDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodReadonly:
-      return parseReadonlyDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodCatch:
-      return parseCatchDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodPipeline:
-      return parsePipelineDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodFunction:
-    case zod.ZodFirstPartyTypeKind.ZodVoid:
-    case zod.ZodFirstPartyTypeKind.ZodSymbol:
-      return void 0;
-    default:
-      return /* @__PURE__ */ ((_) => void 0)();
-  }
-};
-function parseDef(def, refs, forceResolution = false) {
-  var _a;
-  const seenItem = refs.seen.get(def);
-  if (refs.override) {
-    const overrideResult = (_a = refs.override) == null ? void 0 : _a.call(refs, def, refs, seenItem, forceResolution);
-    if (overrideResult !== ignoreOverride) {
-      return overrideResult;
-    }
-  }
-  if (seenItem && !forceResolution) {
-    const seenSchema = get$ref(seenItem, refs);
-    if (seenSchema !== void 0) {
-      return seenSchema;
-    }
-  }
-  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
-  refs.seen.set(def, newItem);
-  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
-  const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
-  if (jsonSchema) {
-    addMeta(def, refs, jsonSchema);
-  }
-  if (refs.postProcess) {
-    const postProcessResult = refs.postProcess(jsonSchema, def, refs);
-    newItem.jsonSchema = jsonSchema;
-    return postProcessResult;
-  }
-  newItem.jsonSchema = jsonSchema;
-  return jsonSchema;
-}
-const get$ref = (item, refs) => {
-  switch (refs.$refStrategy) {
-    case "root":
-      return { $ref: item.path.join("/") };
-    case "relative":
-      return { $ref: getRelativePath(refs.currentPath, item.path) };
-    case "none":
-    case "seen": {
-      if (item.path.length < refs.currentPath.length && item.path.every((value, index2) => refs.currentPath[index2] === value)) {
-        console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
-        return parseAnyDef(refs);
-      }
-      return refs.$refStrategy === "seen" ? parseAnyDef(refs) : void 0;
-    }
-  }
-};
-const addMeta = (def, refs, jsonSchema) => {
-  if (def.description) {
-    jsonSchema.description = def.description;
-    if (refs.markdownDescription) {
-      jsonSchema.markdownDescription = def.description;
-    }
-  }
-  return jsonSchema;
-};
-const zodToJsonSchema = (schema, options) => {
-  const refs = getRefs(options);
-  let definitions2 = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({
-    ...acc,
-    [name2]: parseDef(schema2._def, {
-      ...refs,
-      currentPath: [...refs.basePath, refs.definitionPath, name2]
-    }, true) ?? parseAnyDef(refs)
-  }), {}) : void 0;
-  const name = typeof options === "string" ? options : (options == null ? void 0 : options.nameStrategy) === "title" ? void 0 : options == null ? void 0 : options.name;
-  const main = parseDef(schema._def, name === void 0 ? refs : {
-    ...refs,
-    currentPath: [...refs.basePath, refs.definitionPath, name]
-  }, false) ?? parseAnyDef(refs);
-  const title2 = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
-  if (title2 !== void 0) {
-    main.title = title2;
-  }
-  if (refs.flags.hasReferencedOpenAiAnyType) {
-    if (!definitions2) {
-      definitions2 = {};
-    }
-    if (!definitions2[refs.openAiAnyTypeName]) {
-      definitions2[refs.openAiAnyTypeName] = {
-        // Skipping "object" as no properties can be defined and additionalProperties must be "false"
-        type: ["string", "number", "integer", "boolean", "array", "null"],
-        items: {
-          $ref: refs.$refStrategy === "relative" ? "1" : [
-            ...refs.basePath,
-            refs.definitionPath,
-            refs.openAiAnyTypeName
-          ].join("/")
-        }
-      };
-    }
-  }
-  const combined = name === void 0 ? definitions2 ? {
-    ...main,
-    [refs.definitionPath]: definitions2
-  } : main : {
-    $ref: [
-      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
-      refs.definitionPath,
-      name
-    ].join("/"),
-    [refs.definitionPath]: {
-      ...definitions2,
-      [name]: main
-    }
-  };
-  if (refs.target === "jsonSchema7") {
-    combined.$schema = "http://json-schema.org/draft-07/schema#";
-  } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
-    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
-  }
-  if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
-    console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
-  }
-  return combined;
-};
-var McpZodTypeKind;
-(function(McpZodTypeKind2) {
-  McpZodTypeKind2["Completable"] = "McpCompletable";
-})(McpZodTypeKind || (McpZodTypeKind = {}));
-class Completable extends zod.ZodType {
-  _parse(input) {
-    const { ctx } = this._processInputParams(input);
-    const data2 = ctx.data;
-    return this._def.type._parse({
-      data: data2,
-      path: ctx.path,
-      parent: ctx
-    });
-  }
-  unwrap() {
-    return this._def.type;
-  }
-}
-Completable.create = (type2, params) => {
-  return new Completable({
-    type: type2,
-    typeName: McpZodTypeKind.Completable,
-    complete: params.complete,
-    ...processCreateParams(params)
-  });
-};
-function processCreateParams(params) {
-  if (!params)
-    return {};
-  const { errorMap, invalid_type_error, required_error, description: description2 } = params;
-  if (errorMap && (invalid_type_error || required_error)) {
-    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
-  }
-  if (errorMap)
-    return { errorMap, description: description2 };
-  const customMap = (iss, ctx) => {
-    var _a, _b;
-    const { message } = params;
-    if (iss.code === "invalid_enum_value") {
-      return { message: message !== null && message !== void 0 ? message : ctx.defaultError };
-    }
-    if (typeof ctx.data === "undefined") {
-      return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError };
-    }
-    if (iss.code !== "invalid_type")
-      return { message: ctx.defaultError };
-    return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError };
-  };
-  return { errorMap: customMap, description: description2 };
-}
-class McpServer {
-  constructor(serverInfo, options) {
-    this._registeredResources = {};
-    this._registeredResourceTemplates = {};
-    this._registeredTools = {};
-    this._registeredPrompts = {};
-    this._toolHandlersInitialized = false;
-    this._completionHandlerInitialized = false;
-    this._resourceHandlersInitialized = false;
-    this._promptHandlersInitialized = false;
-    this.server = new Server(serverInfo, options);
-  }
-  /**
-   * Attaches to the given transport, starts it, and starts listening for messages.
-   *
-   * The `server` object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
-   */
-  async connect(transport) {
-    return await this.server.connect(transport);
-  }
-  /**
-   * Closes the connection.
+   * Closes the connection.
    */
   async close() {
     await this.server.close();
@@ -15706,13 +15946,11 @@ class McpServer {
           name,
           title: tool.title,
           description: tool.description,
-          inputSchema: tool.inputSchema ? zodToJsonSchema(tool.inputSchema, {
-            strictUnions: true
-          }) : EMPTY_OBJECT_JSON_SCHEMA,
+          inputSchema: tool.inputSchema ? safeToJSONSchema(tool.inputSchema) : EMPTY_OBJECT_JSON_SCHEMA,
           annotations: tool.annotations
         };
         if (tool.outputSchema) {
-          toolDefinition.outputSchema = zodToJsonSchema(tool.outputSchema, { strictUnions: true });
+          toolDefinition.outputSchema = safeToJSONSchema(tool.outputSchema);
         }
         return toolDefinition;
       })
@@ -15810,8 +16048,17 @@ class McpServer {
     if (!(field instanceof Completable)) {
       return EMPTY_COMPLETION_RESULT;
     }
-    const def = field._def;
-    const suggestions = await def.complete(request.params.argument.value, request.params.context);
+    const suggestions = await field.complete(request.params.argument.value, request.params.context);
+    return createCompletionResult(suggestions);
+  }
+  async getFieldCompletions(field, request) {
+    if (!field) {
+      return EMPTY_COMPLETION_RESULT;
+    }
+    if (!(field instanceof Completable)) {
+      return EMPTY_COMPLETION_RESULT;
+    }
+    const suggestions = await field.complete(request.params.argument.value, request.params.context);
     return createCompletionResult(suggestions);
   }
   async handleResourceCompletion(request, ref2) {
@@ -16079,8 +16326,8 @@ class McpServer {
     const registeredTool = {
       title: title2,
       description: description2,
-      inputSchema: inputSchema === void 0 ? void 0 : zod.z.object(inputSchema),
-      outputSchema: outputSchema === void 0 ? void 0 : zod.z.object(outputSchema),
+      inputSchema: inputSchema === void 0 ? void 0 : isZodTypeLike(inputSchema) ? inputSchema : zod.z.object(inputSchema),
+      outputSchema: outputSchema === void 0 ? void 0 : isZodTypeLike(outputSchema) ? outputSchema : zod.z.object(outputSchema),
       annotations,
       callback,
       enabled: true,
@@ -16214,32 +16461,72 @@ class McpServer {
     }
   }
 }
+class ResourceTemplate {
+  constructor(uriTemplate, _callbacks) {
+    this._callbacks = _callbacks;
+    this._uriTemplate = typeof uriTemplate === "string" ? new UriTemplate(uriTemplate) : uriTemplate;
+  }
+  /**
+   * Gets the URI template pattern.
+   */
+  get uriTemplate() {
+    return this._uriTemplate;
+  }
+  /**
+   * Gets the list callback, if one was provided.
+   */
+  get listCallback() {
+    return this._callbacks.list;
+  }
+  /**
+   * Gets the callback for completing a specific URI template variable, if one was provided.
+   */
+  completeCallback(variable) {
+    var _a;
+    return (_a = this._callbacks.complete) === null || _a === void 0 ? void 0 : _a[variable];
+  }
+}
 const EMPTY_OBJECT_JSON_SCHEMA = {
   type: "object",
   properties: {}
 };
+function safeToJSONSchema(schema) {
+  try {
+    if (!schema)
+      return EMPTY_OBJECT_JSON_SCHEMA;
+    return zod.z.toJSONSchema(schema);
+  } catch (error) {
+    console.error("JSON Schema generation failed:", error);
+    return EMPTY_OBJECT_JSON_SCHEMA;
+  }
+}
 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);
+  const filteredValues = Object.entries(obj).filter(([key]) => key !== "~standard").map(([, value]) => value);
+  return isEmptyObject || filteredValues.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 promptArgumentsFromSchema(schema) {
-  return Object.entries(schema.shape).map(([name, field]) => ({
-    name,
-    description: field.description,
-    required: !field.isOptional()
-  }));
+  return Object.entries(schema.shape).map(([name, field]) => {
+    var _a, _b, _c;
+    return {
+      name,
+      description: field.description,
+      required: !((_c = (_b = (_a = field).isOptional) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : false)
+    };
+  });
 }
 function createCompletionResult(suggestions) {
+  const filteredSuggestions = suggestions.filter((s) => s !== void 0);
   return {
     completion: {
-      values: suggestions.slice(0, 100),
-      total: suggestions.length,
-      hasMore: suggestions.length > 100
+      values: filteredSuggestions.slice(0, 100),
+      total: filteredSuggestions.length,
+      hasMore: filteredSuggestions.length > 100
     }
   };
 }
@@ -16251,7 +16538,152 @@ const EMPTY_COMPLETION_RESULT = {
 };
 const mcp = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  McpServer
+  McpServer,
+  ResourceTemplate
+}, Symbol.toStringTag, { value: "Module" }));
+class McpLifecycleManager {
+  constructor(events, logger, serverInfo, argParser) {
+    this.events = events;
+    this.logger = logger;
+    this.serverInfo = serverInfo;
+    this.argParser = argParser;
+    this.state = {
+      initialized: false,
+      ready: false,
+      shuttingDown: false
+    };
+    this.parsedArgs = {};
+  }
+  /**
+   * Set the parsed arguments for flag access
+   */
+  setParsedArgs(parsedArgs) {
+    this.parsedArgs = parsedArgs;
+  }
+  /**
+   * Get a flag value from parsed arguments or environment variables
+   */
+  getFlag(name) {
+    if (this.parsedArgs && this.parsedArgs[name] !== void 0) {
+      return this.parsedArgs[name];
+    }
+    if (this.argParser) {
+      const flagDef = this.argParser.getFlagDefinition(name);
+      if (flagDef) {
+        if (flagDef.env && process.env[flagDef.env]) {
+          return process.env[flagDef.env];
+        }
+        return flagDef.defaultValue;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Handle the initialize request
+   */
+  async handleInitialize(clientInfo, protocolVersion, clientCapabilities) {
+    if (this.state.initialized) {
+      this.logger.mcpError("Initialize called multiple times");
+      return;
+    }
+    this.state.clientInfo = clientInfo;
+    this.state.protocolVersion = protocolVersion;
+    this.state.clientCapabilities = clientCapabilities;
+    this.state.initialized = true;
+    if (this.events.onInitialize) {
+      const context = {
+        getFlag: (name) => this.getFlag(name),
+        logger: this.logger,
+        serverInfo: this.serverInfo,
+        clientInfo,
+        protocolVersion,
+        clientCapabilities
+      };
+      try {
+        await this.events.onInitialize(context);
+        this.logger.mcpError("Lifecycle onInitialize completed successfully");
+      } catch (error) {
+        this.logger.mcpError(
+          `Lifecycle onInitialize failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+        throw error;
+      }
+    }
+  }
+  /**
+   * Handle the initialized notification
+   */
+  async handleInitialized() {
+    if (!this.state.initialized) {
+      this.logger.mcpError("Initialized called before initialize");
+      return;
+    }
+    if (this.state.ready) {
+      this.logger.mcpError("Initialized called multiple times");
+      return;
+    }
+    this.state.ready = true;
+    if (this.events.onInitialized && this.state.clientInfo) {
+      const context = {
+        getFlag: (name) => this.getFlag(name),
+        logger: this.logger,
+        serverInfo: this.serverInfo,
+        clientInfo: this.state.clientInfo,
+        protocolVersion: this.state.protocolVersion
+      };
+      try {
+        await this.events.onInitialized(context);
+        this.logger.mcpError("Lifecycle onInitialized completed successfully");
+      } catch (error) {
+        this.logger.mcpError(
+          `Lifecycle onInitialized failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+        throw error;
+      }
+    }
+  }
+  /**
+   * Handle server shutdown
+   */
+  async handleShutdown(reason, error) {
+    if (this.state.shuttingDown) {
+      return;
+    }
+    this.state.shuttingDown = true;
+    if (this.events.onShutdown) {
+      const context = {
+        getFlag: (name) => this.getFlag(name),
+        logger: this.logger,
+        serverInfo: this.serverInfo,
+        reason,
+        error
+      };
+      try {
+        await this.events.onShutdown(context);
+        this.logger.mcpError("Lifecycle onShutdown completed successfully");
+      } catch (shutdownError) {
+        this.logger.mcpError(
+          `Lifecycle onShutdown failed: ${shutdownError instanceof Error ? shutdownError.message : String(shutdownError)}`
+        );
+      }
+    }
+  }
+  /**
+   * Get current lifecycle state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Check if the server is ready for operations
+   */
+  isReady() {
+    return this.state.ready && !this.state.shuttingDown;
+  }
+}
+const mcpLifecycle = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  McpLifecycleManager
 }, Symbol.toStringTag, { value: "Module" }));
 class ReadBuffer {
   append(chunk) {
@@ -22829,7 +23261,7 @@ class SSEServerTransport {
       Connection: "keep-alive"
     });
     const dummyBase = "http://localhost";
-    const endpointUrl = new url.URL(this._endpoint, dummyBase);
+    const endpointUrl = new node_url.URL(this._endpoint, dummyBase);
     endpointUrl.searchParams.set("sessionId", this._sessionId);
     const relativeUrlWithSession = endpointUrl.pathname + endpointUrl.search + endpointUrl.hash;
     this.res.write(`event: endpoint
@@ -24541,6 +24973,7 @@ exports.createTomlPluginAsync = createTomlPluginAsync;
 exports.createYamlPlugin = createYamlPlugin;
 exports.createYamlPluginAsync = createYamlPluginAsync;
 exports.cwdRelative = cwdRelative;
+exports.debug = debug;
 exports.detectEntryPoint = detectEntryPoint;
 exports.enableConfigPlugins = enableConfigPlugins;
 exports.enableOptionalConfigPlugins = enableOptionalConfigPlugins;
@@ -24551,7 +24984,9 @@ exports.generateMcpToolsFromArgParser = generateMcpToolsFromArgParser;
 exports.getEntryPointFromImportMeta = getEntryPointFromImportMeta;
 exports.getJsonSchemaTypeFromFlag = getJsonSchemaTypeFromFlag;
 exports.globalConfigPluginRegistry = globalConfigPluginRegistry;
+exports.isValidMcpToolName = isValidMcpToolName;
 exports.legacyCwdPath = legacyCwdPath;
 exports.resolveLogPath = resolveLogPath;
+exports.sanitizeMcpToolName = sanitizeMcpToolName;
 exports.zodFlagSchema = zodFlagSchema;
 //# sourceMappingURL=index.cjs.map