@runpod/mcp-server 3.2.0 → 3.4.0

package/dist/stdio.cjs

@@ -45,32 +45,138 @@ function hostedServerConfig(strategy, serverProperty, url) {
   }
   return serverProperty === "servers" ? { type: "http", url } : { url };
 }
-function upsertJsonServer(configPath, serverProperty, value) {
+function describeDialect(dialect) {
+  return dialect === "json" ? "JSON" : "JSONC";
+}
+function parseFailure(content, dialect) {
+  if (dialect === "json") {
+    try {
+      JSON.parse(content);
+      return void 0;
+    } catch (error) {
+      return errMessage(error);
+    }
+  }
+  const errors = [];
+  jsonc.parse(content, errors, { allowTrailingComma: true });
+  return errors.length > 0 ? `JSONC parse error at offset ${errors[0].offset}` : void 0;
+}
+function parseAsClient(content, dialect) {
+  if (dialect !== "json") {
+    return jsonc.parse(content, [], { allowTrailingComma: true });
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+}
+function readBackEntry(content, serverProperty, dialect) {
+  const parsed = parseAsClient(content, dialect);
+  if (typeof parsed !== "object" || parsed === null) return void 0;
+  const servers = parsed[serverProperty];
+  if (typeof servers !== "object" || servers === null) return void 0;
+  return servers[SERVER_NAME2];
+}
+function reliesOnLeniency(content) {
+  if (content.trim() === "") return false;
+  try {
+    JSON.parse(content);
+    return false;
+  } catch {
+    return parseFailure(content, "jsonc") === void 0;
+  }
+}
+function upsertJsonServer(configPath, serverProperty, value, dialect) {
+  if (!path.isAbsolute(configPath)) {
+    return {
+      success: false,
+      message: `refusing to write "${configPath}": not an absolute path, so it would resolve against the current directory. This usually means an environment variable (APPDATA, XDG_CONFIG_HOME) is set to an empty or relative value.`
+    };
+  }
   try {
     fs.mkdirSync(path.dirname(configPath), { recursive: true });
     const content = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf8") : "";
     const edits = jsonc.modify(content, [serverProperty, SERVER_NAME2], value, {
       formattingOptions: { tabSize: 2, insertSpaces: true }
     });
-    fs.writeFileSync(configPath, jsonc.applyEdits(content, edits), "utf8");
+    const updated = jsonc.applyEdits(content, edits).replace(/^\uFEFF/, "");
+    const failure = parseFailure(updated, dialect);
+    if (failure) {
+      const wasAlreadyBroken = content.trim() !== "" && parseFailure(content, dialect) !== void 0;
+      return {
+        success: false,
+        message: wasAlreadyBroken ? `${configPath} could not be parsed as ${describeDialect(dialect)} before this change either (${failure}), so it was left untouched \u2014 this client would not load the entry. Fix the file (or move it aside) and re-run.` : `writing to ${configPath} would leave it unparseable (${failure}), so it was left untouched.`
+      };
+    }
+    const landed = readBackEntry(updated, serverProperty, dialect);
+    if (JSON.stringify(landed) !== JSON.stringify(value)) {
+      return {
+        success: false,
+        message: `${configPath} was left untouched: the entry would have been written where this client does not read it, so it would have had no effect. This usually means "${serverProperty}" appears more than once in the file \u2014 the last one wins, so merge them into a single block and re-run.`
+      };
+    }
+    fs.writeFileSync(configPath, updated, { encoding: "utf8", mode: 384 });
+    if (dialect === "unverified" && reliesOnLeniency(updated)) {
+      return {
+        success: true,
+        message: "written, but this config uses comments or trailing commas and whether this client accepts them is unverified \u2014 if the Runpod server does not appear, remove them"
+      };
+    }
     return { success: true };
   } catch (error) {
     return { success: false, message: errMessage(error) };
   }
 }
-function removeJsonServer(configPath, serverProperty) {
+function removeJsonServer(configPath, serverProperty, dialect) {
+  if (!path.isAbsolute(configPath)) {
+    return {
+      success: false,
+      message: `refusing to touch "${configPath}": not an absolute path. Check APPDATA / XDG_CONFIG_HOME.`
+    };
+  }
   try {
     if (!fs.existsSync(configPath)) {
       return { success: true, message: "nothing to remove" };
     }
     const content = fs.readFileSync(configPath, "utf8");
-    const edits = jsonc.modify(
-      content,
-      [serverProperty, SERVER_NAME2],
-      void 0,
-      { formattingOptions: { tabSize: 2, insertSpaces: true } }
-    );
-    fs.writeFileSync(configPath, jsonc.applyEdits(content, edits), "utf8");
+    if (content.trim() === "") {
+      return { success: true, message: "nothing to remove" };
+    }
+    const existingFailure = parseFailure(content, dialect);
+    if (existingFailure !== void 0) {
+      return {
+        success: false,
+        message: `could not safely remove the Runpod entry from ${configPath}: the existing config is not valid ${describeDialect(dialect)} (${existingFailure}). The original file was left unchanged; repair it or delete the entry by hand.`
+      };
+    }
+    let edits;
+    try {
+      edits = jsonc.modify(content, [serverProperty, SERVER_NAME2], void 0, {
+        formattingOptions: { tabSize: 2, insertSpaces: true }
+      });
+    } catch (error) {
+      if (/empty document/i.test(errMessage(error))) {
+        return { success: true, message: "nothing to remove" };
+      }
+      throw error;
+    }
+    if (edits.length === 0) {
+      return readBackEntry(content, serverProperty, dialect) === void 0 ? { success: true, message: "nothing to remove" } : {
+        success: false,
+        message: `the Runpod entry is still present in ${configPath} and could not be removed automatically \u2014 "${serverProperty}" appears more than once, so the edit targeted a block this client does not read. Delete the entry by hand.`
+      };
+    }
+    const updated = jsonc.applyEdits(content, edits);
+    const brokeIt = parseFailure(updated, dialect) !== void 0;
+    const stillThere = readBackEntry(updated, serverProperty, dialect) !== void 0;
+    if (brokeIt || stillThere) {
+      return {
+        success: false,
+        message: `could not remove the Runpod entry from ${configPath} without ${brokeIt ? "making the config unparseable" : "leaving the entry present"}. The original file was left unchanged so its comments and formatting are preserved; delete the Runpod entry by hand.`
+      };
+    }
+    fs.writeFileSync(configPath, updated, "utf8");
     return { success: true };
   } catch (error) {
     return { success: false, message: errMessage(error) };
@@ -98,56 +204,461 @@ function jsonClient(opts) {
     add: (mode) => {
       const value = mode.kind === "local" ? localServerConfig(mode.apiKey, serverProperty) : hostedServerConfig(hostedStrategy, serverProperty, mode.url);
       return Promise.resolve(
-        upsertJsonServer(opts.configPath(), serverProperty, value)
+        upsertJsonServer(opts.configPath(), serverProperty, value, opts.dialect)
       );
     },
-    remove: () => Promise.resolve(removeJsonServer(opts.configPath(), serverProperty)),
+    dialect: opts.dialect,
+    remove: () => Promise.resolve(
+      removeJsonServer(opts.configPath(), serverProperty, opts.dialect)
+    ),
     describeTarget: () => opts.configPath()
   };
 }
-function findClaudeBinary() {
-  const candidates = [
-    path.join(os.homedir(), ".claude", "local", "claude"),
-    "/usr/local/bin/claude",
-    "/opt/homebrew/bin/claude"
+function claudeCandidates(platform, homedir2, appdata) {
+  if (platform === "win32") {
+    const win = path.win32;
+    const defaultAppdata = win.join(homedir2, "AppData", "Roaming");
+    return [
+      {
+        path: win.join(homedir2, ".local", "bin", "claude.exe"),
+        trustedRoot: homedir2
+      },
+      // npm -g installs a .cmd shim. runClaude bypasses it and resolves the real
+      // native or JavaScript target from the installed package manifest.
+      //
+      // absoluteEnvDir, not `?? `: an empty or relative APPDATA yielded the relative
+      // `npm\claude.cmd`. Candidates are probed before any lookup, so a relative
+      // candidate would resolve against the current directory and receive the live
+      // API key.
+      {
+        path: win.join(
+          absoluteEnvDir(appdata, () => defaultAppdata),
+          "npm",
+          "claude.cmd"
+        ),
+        trustedRoot: defaultAppdata
+      }
+    ];
+  }
+  return [
+    // Where the current native installer puts it (verified on a real install:
+    // ~/.local/bin/claude -> versions/2.1.220). Same reasoning as the Windows
+    // .local\bin\claude.exe entry — it also covers an install whose PATH entry is
+    // missing, which the lookup can never find. Without it, POSIX detection depended
+    // entirely on PATH.
+    {
+      path: path.posix.join(homedir2, ".local", "bin", "claude"),
+      trustedRoot: homedir2
+    },
+    {
+      path: path.posix.join(homedir2, ".claude", "local", "claude"),
+      trustedRoot: homedir2
+    },
+    { path: "/usr/local/bin/claude", trustedRoot: "/usr/local" },
+    { path: "/opt/homebrew/bin/claude", trustedRoot: "/opt/homebrew" }
   ];
+}
+function pathIsInside(candidate, directory, pathApi) {
+  const relative = pathApi.relative(
+    pathApi.resolve(directory),
+    pathApi.resolve(candidate)
+  );
+  return relative === "" || !relative.startsWith(`..${pathApi.sep}`) && relative !== ".." && !pathApi.isAbsolute(relative);
+}
+function isNodeModulesBin(candidate) {
+  return /(^|[\\/])node_modules[\\/]\.bin([\\/]|$)/i.test(candidate);
+}
+function pickClaudeBinary(stdout, platform, cwd) {
+  if (platform === "win32") return null;
+  const hits = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  return hits.find(
+    (hit) => path.posix.isAbsolute(hit) && !isNodeModulesBin(hit) && (cwd === void 0 || !pathIsInside(hit, cwd, path.posix))
+  ) ?? null;
+}
+function projectBoundary(cwd, home2) {
+  let current = cwd;
+  let boundary = null;
+  while (true) {
+    if (current === home2) return boundary;
+    if (PROJECT_BOUNDARY_MARKERS.some(
+      (marker) => exists(path.join(current, marker))
+    )) {
+      boundary = current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return boundary;
+    current = parent;
+  }
+}
+function trustedClaudeBinary(binary, cwd, home2, requiredRoot) {
+  try {
+    const canonicalBinary = fs.realpathSync.native(binary);
+    const canonicalCwd = fs.realpathSync.native(cwd);
+    let canonicalHome;
+    if (home2 !== void 0) {
+      try {
+        canonicalHome = fs.realpathSync.native(home2);
+      } catch {
+        canonicalHome = void 0;
+      }
+    }
+    const projectRoot = projectBoundary(canonicalCwd, canonicalHome);
+    const canonicalRequiredRoot = requiredRoot === void 0 ? void 0 : fs.realpathSync.native(requiredRoot);
+    if (isNodeModulesBin(canonicalBinary) || canonicalRequiredRoot !== void 0 && !pathIsInside(canonicalBinary, canonicalRequiredRoot, path) || projectRoot !== null && pathIsInside(canonicalBinary, projectRoot, path)) {
+      return null;
+    }
+    return canonicalBinary;
+  } catch {
+    return null;
+  }
+}
+function findClaudeBinary(options = {}) {
+  const platform = options.platform ?? process.platform;
+  let homedir2 = options.homedir;
+  if (homedir2 === void 0) {
+    try {
+      homedir2 = os.userInfo().homedir;
+    } catch {
+      homedir2 = null;
+    }
+  }
+  const appdata = options.appdata ?? process.env.APPDATA;
+  const cwd = options.cwd ?? process.cwd();
+  const candidates = homedir2 == null ? [] : claudeCandidates(platform, homedir2, appdata);
   for (const candidate of candidates) {
-    if (exists(candidate)) return candidate;
+    if (!path.isAbsolute(candidate.path) && !path.win32.isAbsolute(candidate.path))
+      continue;
+    if (exists(candidate.path)) {
+      const trusted = trustedClaudeBinary(
+        candidate.path,
+        cwd,
+        homedir2 ?? void 0,
+        candidate.trustedRoot
+      );
+      if (trusted !== null) return trusted;
+    }
   }
   try {
-    (0, import_child_process.execSync)("command -v claude", { stdio: "pipe" });
-    return "claude";
+    if (platform === "win32") return null;
+    const out = (0, import_child_process.execSync)("command -v claude", {
+      stdio: ["ignore", "pipe", "ignore"],
+      encoding: "utf8"
+    });
+    const binary = pickClaudeBinary(out, platform);
+    return binary === null ? null : trustedClaudeBinary(binary, cwd, homedir2 ?? void 0);
   } catch {
     return null;
   }
 }
-function runClaude(binary, args) {
+function describeCommand(binary, args) {
+  const quote = (s) => /\s/.test(s) || CMD_META.test(s) ? `"${s}"` : s;
+  return [binary, ...args].map(quote).join(" ");
+}
+function describeCommandRedacted(binary, args) {
+  return describeCommand(
+    binary,
+    args.map(
+      (arg) => arg.startsWith("RUNPOD_API_KEY=") ? `RUNPOD_API_KEY=${KEY_PLACEHOLDER}` : arg
+    )
+  );
+}
+function redactSecret(text, secret) {
+  if (!secret) return text;
+  return text.split(secret).join(KEY_PLACEHOLDER);
+}
+function sanitizedClaudeEnv() {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
+    if (["path", "comspec", "pathext", "node_options", "node_path"].includes(
+      key.toLowerCase()
+    )) {
+      delete env[key];
+    }
+  }
+  if (process.platform === "win32") {
+    env.Path = path.dirname(process.execPath);
+  } else {
+    env.PATH = [
+      path.dirname(process.execPath),
+      "/usr/local/bin",
+      "/opt/homebrew/bin",
+      "/usr/bin",
+      "/bin"
+    ].join(path.delimiter);
+  }
+  return env;
+}
+function windowsNpmClaudeTarget(binary) {
+  if (process.platform !== "win32" || !binary.toLowerCase().endsWith(".cmd")) {
+    return null;
+  }
   try {
-    (0, import_child_process.execFileSync)(binary, args, { stdio: "pipe" });
-    return { success: true };
-  } catch (error) {
-    const message = errMessage(error);
-    if (message.includes("already exists")) {
-      return { success: true, message: "already configured" };
+    const npmRoot = fs.realpathSync.native(path.dirname(binary));
+    const packageRoot = fs.realpathSync.native(
+      path.join(npmRoot, "node_modules", "@anthropic-ai", "claude-code")
+    );
+    if (!pathIsInside(packageRoot, npmRoot, path)) return null;
+    const manifestPath = fs.realpathSync.native(
+      path.join(packageRoot, "package.json")
+    );
+    if (!pathIsInside(manifestPath, packageRoot, path)) return null;
+    const manifest = JSON.parse(
+      fs.readFileSync(manifestPath, "utf8")
+    );
+    if (manifest === null || typeof manifest !== "object") return null;
+    const bin = manifest.bin;
+    const target = typeof bin === "string" ? bin : bin !== null && typeof bin === "object" ? bin.claude : void 0;
+    if (typeof target !== "string" || target.trim() === "") return null;
+    const entrypoint = fs.realpathSync.native(
+      path.resolve(packageRoot, target)
+    );
+    if (!pathIsInside(entrypoint, packageRoot, path)) return null;
+    if (/\.(?:exe|com)$/i.test(entrypoint)) {
+      return { command: entrypoint, argsPrefix: [] };
+    }
+    if (/\.(?:c?js|mjs)$/i.test(entrypoint)) {
+      return { command: process.execPath, argsPrefix: [entrypoint] };
     }
-    return { success: false, message };
+    return null;
+  } catch {
+    return null;
+  }
+}
+function runClaude(binary, args, secret) {
+  const isWindowsCmd = process.platform === "win32" && binary.toLowerCase().endsWith(".cmd");
+  const npmTarget = windowsNpmClaudeTarget(binary);
+  if (isWindowsCmd && npmTarget === null) {
+    return {
+      success: false,
+      refused: true,
+      message: `could not locate a trusted Claude Code npm entrypoint beside ${binary}. Run the shim yourself, substituting your key:
+    ${describeCommandRedacted(binary, args)}`
+    };
+  }
+  const command = npmTarget?.command ?? binary;
+  const commandArgs = [...npmTarget?.argsPrefix ?? [], ...args];
+  const result = (0, import_child_process.spawnSync)(command, commandArgs, {
+    stdio: "pipe",
+    encoding: "utf8",
+    env: sanitizedClaudeEnv()
+  });
+  if (result.error)
+    return {
+      success: false,
+      message: redactSecret(errMessage(result.error), secret)
+    };
+  const stdio = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+  if (result.status === 0) return { success: true, output: stdio };
+  if (result.status === null) {
+    return { success: false, message: `killed by ${result.signal}` };
+  }
+  if (stdio.includes("already exists")) {
+    return {
+      success: true,
+      // Deliberately not "to replace the API key": this branch is also reached in
+      // hosted mode, where there is no key — and the pre-existing entry may be of the
+      // other kind entirely, which is exactly what the user needs to know.
+      message: `already configured, existing entry left unchanged \u2014 it was NOT updated to what you just chose (to replace it, run \`${describeCommand(binary, ["mcp", "remove", SERVER_NAME2, "--scope", "user"])}\` first, then re-run this wizard)`
+    };
   }
+  return {
+    success: false,
+    message: redactSecret(
+      stdio.trim() || `${path.basename(binary)} exited with code ${result.status}`,
+      secret
+    )
+  };
+}
+function absoluteEnvDir(value, fallback) {
+  if (!value || !value.trim()) return fallback();
+  if (!path.isAbsolute(value) && !path.win32.isAbsolute(value))
+    return fallback();
+  return value;
+}
+function claudeUserConfigPath() {
+  const configured = process.env.CLAUDE_CONFIG_DIR;
+  return path.join(
+    configured ? path.resolve(configured) : os.homedir(),
+    ".claude.json"
+  );
+}
+function readClaudeConfigState(configPath) {
+  const unknown = {
+    configPath,
+    userScope: void 0,
+    localScopeDirs: []
+  };
+  if (!path.isAbsolute(configPath)) return unknown;
+  let raw;
+  try {
+    if (!fs.existsSync(configPath)) {
+      return { configPath, userScope: false, localScopeDirs: [] };
+    }
+    raw = fs.readFileSync(configPath, "utf8");
+  } catch {
+    return unknown;
+  }
+  const errors = [];
+  const parsed = jsonc.parse(raw.replace(/^\uFEFF/, ""), errors, {
+    allowTrailingComma: true
+  });
+  if (errors.length > 0 || typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return unknown;
+  }
+  const has = (servers) => typeof servers === "object" && servers !== null && Object.prototype.hasOwnProperty.call(servers, SERVER_NAME2);
+  const own = (key) => Object.prototype.hasOwnProperty.call(parsed, key) ? parsed[key] : void 0;
+  const projects = own("projects");
+  const localScopeDirs = typeof projects === "object" && projects !== null && !Array.isArray(projects) ? Object.entries(projects).filter(([, project]) => has(project?.mcpServers)).map(([dir]) => dir) : [];
+  return { configPath, userScope: has(own("mcpServers")), localScopeDirs };
+}
+function describeDirs(dirs) {
+  if (dirs.length === 1) return dirs[0];
+  return `${dirs.length} project directories (${dirs.slice(0, 3).join(", ")}${dirs.length > 3 ? ", \u2026" : ""})`;
+}
+function interpretRemoveResult(result, state, binary = "claude") {
+  if (result.refused) return result;
+  const alsoElsewhere = state.localScopeDirs.length > 0 ? ` A separate local-scope ${SERVER_NAME2} entry (which may carry its own API key) also exists in ${describeDirs(state.localScopeDirs)} \u2014 this wizard does not touch those. Remove with \`${describeCommand(binary, ["mcp", "remove", SERVER_NAME2, "--scope", "local"])}\` from each.` : "";
+  if (state.userScope === true) {
+    return {
+      success: false,
+      message: `the ${SERVER_NAME2} entry is STILL in Claude Code's user config (${state.configPath}), so your API key is still on disk. ${result.success ? "Most likely that file is not writable \u2014 the CLI reports success anyway." : `The removal command itself failed: ${result.message ?? "no output"}`}${alsoElsewhere}`
+    };
+  }
+  if (state.userScope === false) {
+    return {
+      success: true,
+      message: (result.success ? "removed from your user config" : "nothing to remove in your user config") + alsoElsewhere
+    };
+  }
+  if (result.success) {
+    return {
+      success: true,
+      message: `removal reported success, but ${state.configPath} could not be read to confirm it`
+    };
+  }
+  return { success: false, message: result.message };
+}
+function interpretAddResult(result, state, binary) {
+  if (result.refused || !result.success) return result;
+  if (state.userScope === false) {
+    return {
+      success: false,
+      message: `Claude Code reported success but no ${SERVER_NAME2} entry is in its user config afterwards (${state.configPath}) \u2014 that file is most likely not writable. Nothing was configured.`
+    };
+  }
+  if (state.userScope === true && state.localScopeDirs.length > 0) {
+    return {
+      success: true,
+      message: `${result.message ? `${result.message}; ` : ""}note a local-scope ${SERVER_NAME2} entry also exists in ${describeDirs(state.localScopeDirs)} and takes precedence over the user config there, so Claude Code will keep using it in those projects \u2014 remove it with \`${describeCommand(binary, ["mcp", "remove", SERVER_NAME2, "--scope", "local"])}\` run from each`
+    };
+  }
+  if (state.userScope === void 0) {
+    return {
+      success: true,
+      message: `${result.message ? `${result.message}; ` : ""}could not read ${state.configPath} to confirm the entry landed`
+    };
+  }
+  return { success: true, message: result.message };
+}
+function createClaudeCodeClient(resolveBinary, readState = () => readClaudeConfigState(claudeUserConfigPath())) {
+  return {
+    id: "claude-code",
+    name: "Claude Code",
+    detect: () => Promise.resolve(resolveBinary() !== null),
+    add: (mode) => {
+      const args = mode.kind === "local" ? [
+        "mcp",
+        "add",
+        SERVER_NAME2,
+        "--scope",
+        "user",
+        "-e",
+        `RUNPOD_API_KEY=${mode.apiKey}`,
+        "--",
+        "npx",
+        "-y",
+        NPM_PACKAGE
+      ] : [
+        "mcp",
+        "add",
+        "--transport",
+        "http",
+        "--scope",
+        "user",
+        SERVER_NAME2,
+        mode.url
+      ];
+      const binary = resolveBinary();
+      if (!binary) {
+        return Promise.resolve({
+          success: false,
+          message: `claude CLI not found in the standard install locations. If Claude Code is installed somewhere custom, register it yourself${mode.kind === "local" ? ", substituting your key" : ""}:
+    ${describeCommandRedacted("claude", args)}`
+        });
+      }
+      const result = runClaude(
+        binary,
+        args,
+        mode.kind === "local" ? mode.apiKey : void 0
+      );
+      if (!result.success) return Promise.resolve(result);
+      return Promise.resolve(interpretAddResult(result, readState(), binary));
+    },
+    remove: () => {
+      const binary = resolveBinary();
+      if (!binary) {
+        return Promise.resolve({
+          success: false,
+          message: `claude CLI not found in the standard install locations. If Claude Code is installed somewhere custom, remove the entry yourself:
+    ${describeCommand("claude", ["mcp", "remove", SERVER_NAME2, "--scope", "user"])}`
+        });
+      }
+      const result = runClaude(binary, [
+        "mcp",
+        "remove",
+        "--scope",
+        "user",
+        SERVER_NAME2
+      ]);
+      if (result.refused) return Promise.resolve(result);
+      return Promise.resolve(
+        interpretRemoveResult(result, readState(), binary)
+      );
+    },
+    describeTarget: () => "Claude Code user config (via `claude mcp` CLI)"
+  };
+}
+function appDataDir() {
+  return absoluteEnvDir(
+    process.env.APPDATA,
+    () => path.join(home, "AppData", "Roaming")
+  );
 }
 function claudeDesktopConfigPath() {
   if (process.platform === "win32") {
-    return path.join(appData, "Claude", "claude_desktop_config.json");
+    return path.join(appDataDir(), "Claude", "claude_desktop_config.json");
+  }
+  if (process.platform === "darwin") {
+    return path.join(
+      home,
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json"
+    );
   }
   return path.join(
-    home,
-    "Library",
-    "Application Support",
+    absoluteEnvDir(
+      process.env.XDG_CONFIG_HOME,
+      () => path.join(home, ".config")
+    ),
     "Claude",
     "claude_desktop_config.json"
   );
 }
 function vsCodeConfigPath() {
   if (process.platform === "win32") {
-    return path.join(appData, "Code", "User", "mcp.json");
+    return path.join(appDataDir(), "Code", "User", "mcp.json");
   }
   if (process.platform === "darwin") {
     return path.join(
@@ -159,9 +670,17 @@ function vsCodeConfigPath() {
       "mcp.json"
     );
   }
-  return path.join(home, ".config", "Code", "User", "mcp.json");
+  return path.join(
+    absoluteEnvDir(
+      process.env.XDG_CONFIG_HOME,
+      () => path.join(home, ".config")
+    ),
+    "Code",
+    "User",
+    "mcp.json"
+  );
 }
-var fs, os, path, import_child_process, jsonc, SERVER_NAME2, NPM_PACKAGE, HOSTED_URL, claudeCodeClient, home, appData, CLIENTS;
+var fs, os, path, import_child_process, jsonc, SERVER_NAME2, NPM_PACKAGE, HOSTED_URL, PROJECT_BOUNDARY_MARKERS, CMD_META, KEY_PLACEHOLDER, claudeCodeClient, home, CLIENTS;
 var init_clients = __esm({
   "src/install/clients.ts"() {
     "use strict";
@@ -173,73 +692,37 @@ var init_clients = __esm({
     SERVER_NAME2 = "runpod";
     NPM_PACKAGE = "@runpod/mcp-server@latest";
     HOSTED_URL = process.env.RUNPOD_MCP_URL ?? "https://mcp.getrunpod.io/";
-    claudeCodeClient = {
-      id: "claude-code",
-      name: "Claude Code",
-      detect: () => Promise.resolve(findClaudeBinary() !== null),
-      add: (mode) => {
-        const binary = findClaudeBinary();
-        if (!binary) {
-          return Promise.resolve({
-            success: false,
-            message: "claude CLI not found"
-          });
-        }
-        const args = mode.kind === "local" ? [
-          "mcp",
-          "add",
-          SERVER_NAME2,
-          "--scope",
-          "user",
-          "-e",
-          `RUNPOD_API_KEY=${mode.apiKey}`,
-          "--",
-          "npx",
-          "-y",
-          NPM_PACKAGE
-        ] : [
-          "mcp",
-          "add",
-          "--transport",
-          "http",
-          "--scope",
-          "user",
-          SERVER_NAME2,
-          mode.url
-        ];
-        return Promise.resolve(runClaude(binary, args));
-      },
-      remove: () => {
-        const binary = findClaudeBinary();
-        if (!binary) {
-          return Promise.resolve({
-            success: false,
-            message: "claude CLI not found"
-          });
-        }
-        try {
-          (0, import_child_process.execFileSync)(binary, ["mcp", "remove", "--scope", "user", SERVER_NAME2], {
-            stdio: "pipe"
-          });
-          return Promise.resolve({ success: true });
-        } catch (error) {
-          return Promise.resolve({ success: true, message: errMessage(error) });
-        }
-      },
-      describeTarget: () => "Claude Code user config (via `claude mcp` CLI)"
-    };
+    PROJECT_BOUNDARY_MARKERS = [
+      ".git",
+      "package.json",
+      "pnpm-workspace.yaml",
+      "pnpm-lock.yaml",
+      "package-lock.json",
+      "yarn.lock",
+      "bun.lock",
+      "bun.lockb"
+    ];
+    CMD_META = /[()\][%!^"`<>&|;, *?\t\n\v\r]/;
+    KEY_PLACEHOLDER = "YOUR_RUNPOD_API_KEY";
+    claudeCodeClient = createClaudeCodeClient(findClaudeBinary);
     home = os.homedir();
-    appData = process.env.APPDATA ?? path.join(home, "AppData", "Roaming");
     CLIENTS = [
       claudeCodeClient,
       jsonClient({
         id: "cursor",
         name: "Cursor",
+        // A VS Code fork, and its MCP reader keeps VS Code's tolerance — comments and
+        // trailing commas both parse. Read out of the shipped bundle, not assumed from
+        // "Electron app"; see ConfigDialect.
+        dialect: "jsonc",
         configPath: () => path.join(home, ".cursor", "mcp.json")
       }),
       jsonClient({
         id: "windsurf",
         name: "Windsurf",
+        // Not installed on any machine this was checked on, so its parser was never read.
+        // Lenient-and-disclosed rather than a guess in either direction.
+        dialect: "unverified",
         // Windsurf is stdio-only, so it reaches the hosted server via mcp-remote.
         hostedStrategy: "mcp-remote",
         configPath: () => path.join(home, ".codeium", "windsurf", "mcp_config.json")
@@ -247,6 +730,9 @@ var init_clients = __esm({
       jsonClient({
         id: "claude-desktop",
         name: "Claude Desktop",
+        // Genuinely strict: its reader is a bare `JSON.parse(readFileSync(...))` with no
+        // preprocessing and no retry, so a comment or trailing comma is fatal.
+        dialect: "json",
         // Claude Desktop config files are stdio-only; use the mcp-remote bridge.
         hostedStrategy: "mcp-remote",
         configPath: claudeDesktopConfigPath,
@@ -257,6 +743,9 @@ var init_clients = __esm({
         id: "vscode",
         name: "Visual Studio Code",
         serverProperty: "servers",
+        // The one client that genuinely reads JSONC — comments and trailing commas in
+        // mcp.json are supported and common.
+        dialect: "jsonc",
         configPath: vsCodeConfigPath,
         detectPaths: () => [path.dirname(vsCodeConfigPath())]
       })
@@ -264,6 +753,33 @@ var init_clients = __esm({
   }
 });
 
+// src/install/verify-key.ts
+async function verifyApiKey(apiKey, timeoutMs = VERIFY_API_KEY_TIMEOUT_MS) {
+  try {
+    const base = process.env.RUNPOD_REST_API_URL ?? "https://rest.runpod.io/v1";
+    const response = await fetch(`${base}/pods`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      // Without this the wizard sits at "Verifying…" forever against a host
+      // that accepts the connection and goes quiet, with no way out but ^C.
+      // An abort lands in the catch below and is reported as "check failed",
+      // which is exactly what it is.
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (response.ok) return true;
+    if (response.status === 401 || response.status === 403) return false;
+    return null;
+  } catch {
+    return null;
+  }
+}
+var VERIFY_API_KEY_TIMEOUT_MS;
+var init_verify_key = __esm({
+  "src/install/verify-key.ts"() {
+    "use strict";
+    VERIFY_API_KEY_TIMEOUT_MS = 1e4;
+  }
+});
+
 // src/install/wizard.ts
 var wizard_exports = {};
 __export(wizard_exports, {
@@ -281,25 +797,12 @@ function openBrowser(url) {
   } catch {
   }
 }
-async function verifyApiKey(apiKey) {
-  try {
-    const base = process.env.RUNPOD_REST_API_URL ?? "https://rest.runpod.io/v1";
-    const response = await fetch(`${base}/pods`, {
-      headers: { Authorization: `Bearer ${apiKey}` }
-    });
-    if (response.ok) return true;
-    if (response.status === 401 || response.status === 403) return false;
-    return null;
-  } catch {
-    return null;
-  }
-}
 function bail(message = "Cancelled.") {
   p.cancel(message);
   process.exit(0);
 }
 async function promptForApiKey() {
-  const fromEnv = process.env.RUNPOD_API_KEY;
+  const fromEnv = process.env.RUNPOD_API_KEY?.trim();
   if (fromEnv) {
     const useEnv = await p.confirm({
       message: "Use the RUNPOD_API_KEY from your environment?"
@@ -394,7 +897,9 @@ async function runAdd() {
     const result = await client.add(mode);
     if (result.success) {
       spinner2.stop(`${client.name} configured.`);
-      results.push(`\u2713 ${client.name} \u2014 ${client.describeTarget()}`);
+      results.push(
+        `\u2713 ${client.name} \u2014 ${result.message ? `${result.message}; ` : ""}${client.describeTarget()}`
+      );
     } else {
       spinner2.stop(`${client.name} failed.`);
       results.push(`\u2717 ${client.name} \u2014 ${result.message ?? "unknown error"}`);
@@ -438,6 +943,7 @@ var init_wizard = __esm({
     import_child_process2 = require("child_process");
     p = __toESM(require("@clack/prompts"), 1);
     init_clients();
+    init_verify_key();
     API_KEYS_URL = "https://www.runpod.io/console/user/settings";
   }
 });
@@ -473,10 +979,15 @@ function containerConfigToV2(p2) {
     mounts: persistentMount(p2.volumeInGb, p2.volumeMountPath)
   });
 }
-function gpuConfigToV2(gpuTypeIds, gpuCount) {
+function gpuConfigToV2(gpuTypeIds, gpuCount, allowedCudaVersions, minCudaVersion2) {
   const id = gpuTypeIds?.[0];
   if (id === void 0) return void 0;
-  return compact({ id, count: gpuCount });
+  return compact({
+    id,
+    count: gpuCount ?? 1,
+    allowedCudaVersions,
+    minCudaVersion: minCudaVersion2
+  });
 }
 function mapPodCreateToV2(params) {
   return compact({
@@ -497,7 +1008,12 @@ function mapPodCreateToV2(params) {
     // singular on v2 (`gpu.id`): gpuConfigToV2 takes the first id; the
     // create-pod handler warns when more than one gpuTypeId was supplied.
     dataCenterIds: params.dataCenterIds?.length ? params.dataCenterIds : void 0,
-    gpu: gpuConfigToV2(params.gpuTypeIds, params.gpuCount)
+    gpu: gpuConfigToV2(
+      params.gpuTypeIds,
+      params.gpuCount,
+      params.allowedCudaVersions,
+      params.minCudaVersion
+    )
   });
 }
 function mapPodUpdateToV2(params) {
@@ -514,9 +1030,15 @@ function defaultScalerType(endpointType) {
 function endpointScaling(scalerType, value) {
   return scalerType === "REQUEST_COUNT" ? { type: "REQUEST_COUNT", requestCount: value } : { type: "QUEUE_DELAY", queueDelay: value };
 }
-function endpointGpuConfig(pools, count) {
-  if (!pools?.length) return void 0;
-  return compact({ pools, count });
+function endpointGpuConfig(params, mode) {
+  const gpu = compact({
+    pools: params.gpuPoolIds?.length ? params.gpuPoolIds : void 0,
+    count: params.gpuCount,
+    allowedCudaVersions: params.allowedCudaVersions,
+    minCudaVersion: params.minCudaVersion
+  });
+  if (mode === "create" && !("pools" in gpu)) return void 0;
+  return Object.keys(gpu).length ? gpu : void 0;
 }
 function endpointWorkers(params) {
   const workers = compact({
@@ -526,7 +1048,7 @@ function endpointWorkers(params) {
   });
   return Object.keys(workers).length ? workers : void 0;
 }
-function endpointCommonToV2(params) {
+function endpointCommonToV2(params, mode) {
   return compact({
     name: params.name,
     image: params.imageName,
@@ -535,7 +1057,7 @@ function endpointCommonToV2(params) {
     ports: params.ports,
     env: params.env,
     registry: params.containerRegistryAuthId,
-    gpu: endpointGpuConfig(params.gpuPoolIds, params.gpuCount),
+    gpu: endpointGpuConfig(params, mode),
     workers: endpointWorkers(params),
     dataCenterIds: params.dataCenterIds?.length ? params.dataCenterIds : void 0,
     networkVolumes: params.networkVolumeIds?.length ? params.networkVolumeIds : void 0,
@@ -546,7 +1068,7 @@ function endpointCommonToV2(params) {
 function mapEndpointCreateToV2(params) {
   const endpointType = params.endpointType ?? DEFAULT_ENDPOINT_TYPE;
   return compact({
-    ...endpointCommonToV2(params),
+    ...endpointCommonToV2(params, "create"),
     type: endpointType,
     scaling: endpointScaling(
       params.scalerType ?? defaultScalerType(endpointType),
@@ -556,13 +1078,28 @@ function mapEndpointCreateToV2(params) {
 }
 function mapEndpointUpdateToV2(params) {
   return compact({
-    ...endpointCommonToV2(params),
+    ...endpointCommonToV2(params, "update"),
     scaling: params.scalerType ? endpointScaling(
       params.scalerType,
       params.scalerValue ?? DEFAULT_SCALER_VALUE
     ) : void 0
   });
 }
+var CUDA_MAJOR_MINOR = /^\d+\.\d+$/;
+function cudaConstraintError(params, opts = {}) {
+  const { allowedCudaVersions, minCudaVersion: minCudaVersion2 } = params;
+  if (allowedCudaVersions?.length && minCudaVersion2) {
+    return "allowedCudaVersions and minCudaVersion are mutually exclusive \u2014 pass either an exact set or an open-ended floor, not both.";
+  }
+  if (minCudaVersion2 !== void 0 && !CUDA_MAJOR_MINOR.test(minCudaVersion2) && !(opts.allowClear && minCudaVersion2 === "")) {
+    return `minCudaVersion must be major.minor (e.g. "12.0", not "12")${opts.allowClear ? "; an empty string clears the floor" : ""}.`;
+  }
+  const bad = allowedCudaVersions?.find((v) => !CUDA_MAJOR_MINOR.test(v));
+  if (bad !== void 0) {
+    return `allowedCudaVersions entries must be major.minor (e.g. "12.8"); got "${bad}". Discover valid values via get-capacity or list-gpu-types.`;
+  }
+  return void 0;
+}
 function mapNetworkVolumeCreateToV2(params) {
   return compact({
     name: params.name,
@@ -603,6 +1140,42 @@ function podBodyFromTemplate(template) {
   }
   return out;
 }
+var SSH_PUBLIC_KEY_LINE = /^(ssh-[a-z0-9-]+|ecdsa-[a-z0-9-]+|sk-[a-z0-9@.-]+)\s+\S+/i;
+var PRIVATE_KEY_MARKER = /private[-\s]?key|PuTTY-User-Key-File/i;
+function normalizeSshPublicKey(input) {
+  if (PRIVATE_KEY_MARKER.test(input))
+    return {
+      ok: false,
+      error: 'sshPublicKey looks like a PRIVATE key. Pass the PUBLIC key instead \u2014 the contents of your ~/.ssh/<key>.pub file (e.g. "ssh-ed25519 AAAA\u2026").'
+    };
+  const lines = input.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (lines.length === 0)
+    return {
+      ok: false,
+      error: "sshPublicKey is empty. Pass the contents of your ~/.ssh/<key>.pub file, or omit the parameter entirely to create the pod without SSH."
+    };
+  if (lines.some((line) => !SSH_PUBLIC_KEY_LINE.test(line)))
+    return {
+      ok: false,
+      error: 'sshPublicKey is not an SSH public key. Expected the CONTENTS of your ~/.ssh/<key>.pub file \u2014 a line like "ssh-ed25519 AAAAC3Nza\u2026 you@host" (ssh-*, ecdsa-*, or sk-* followed by the base64 key) \u2014 not a file path, a SHA256 fingerprint, or a bare base64 blob. Newline-separate multiple keys.'
+    };
+  return { ok: true, key: lines.join("\n") };
+}
+function applySshPublicKey(body, sshPublicKey) {
+  const ports = Array.isArray(body.ports) ? body.ports : [];
+  const hasSshPort = ports.some((p2) => /^\s*22\/tcp\s*$/i.test(String(p2)));
+  const env = { ...body.env ?? {} };
+  const key = sshPublicKey.trim();
+  if (!env.PUBLIC_KEY) env.PUBLIC_KEY = key;
+  else if (!env.PUBLIC_KEY.includes(key))
+    env.PUBLIC_KEY = `${env.PUBLIC_KEY}
+${key}`;
+  return {
+    ...body,
+    ports: hasSshPort ? ports : [...ports, "22/tcp"],
+    env
+  };
+}
 function mapTemplateUpdateToV2(params) {
   return {
     ...containerConfigToV2(params),
@@ -868,7 +1441,7 @@ function resolveBackend(opts) {
 
 // src/server.ts
 var SERVER_NAME = "Runpod API Server";
-var SERVER_VERSION = true ? "3.2.0" : "dev";
+var SERVER_VERSION = true ? "3.4.0" : "dev";
 var SERVER_INSTRUCTIONS = `These tools cover common Runpod operations, but they are curated projections: the underlying APIs expose more fields and parameters than the tools surface.
 
 When you need data or capability beyond these tools, consult the full API contracts directly. The REST v2 API lives at https://api.runpod.io/v2 \u2014 the same host these tools call \u2014 and is machine-readable at https://api.runpod.io/v2/openapi.json (fetch and search it to enumerate every path, parameter, and response schema). REST v1 at https://rest.runpod.io/v1 is deprecated; prefer v2. The REST version these tools are actually configured for is reported in the serverInfo.version string of the initialize response, e.g. "[RUNPOD_REST_VERSION=v2]". The GraphQL API at https://api.runpod.io/graphql may expose data the REST API does not yet cover; its schema is documented at https://graphql-spec.runpod.io/, and introspection is disabled in production, so use that reference rather than __schema queries. Both APIs take Bearer auth with a Runpod API key: use the key this client is already configured with \u2014 do not search the environment or filesystem for a credential.`;
@@ -1043,6 +1616,28 @@ var HttpError = class extends Error {
     this.body = body;
   }
 };
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var MIN_REQUEST_TIMEOUT_MS = 1e3;
+var RequestTimeoutError = class extends Error {
+  constructor(prefix, timeoutMs, method) {
+    const write = method !== "GET" && method !== "HEAD";
+    super(
+      `${prefix}: no response after ${timeoutMs}ms for ${method} (the API may be overloaded, or still be working on it). ${write ? "This request may have SUCCEEDED upstream \u2014 do not retry blindly. Check with the matching list-/get- tool first and retry only if it did not take effect." : "This was a read and changed nothing, so retrying is safe."}`
+    );
+    this.name = "RequestTimeoutError";
+    this.timeoutMs = timeoutMs;
+    this.method = method;
+  }
+};
+async function withRequestTimeout(errorPrefix, timeoutMs, method, run) {
+  const signal = AbortSignal.timeout(timeoutMs);
+  try {
+    return await run(signal);
+  } catch (error) {
+    if (error instanceof HttpError || !signal.aborted) throw error;
+    throw new RequestTimeoutError(errorPrefix, timeoutMs, method);
+  }
+}
 function isJsonContentType(contentType) {
   if (!contentType) return false;
   const ct = contentType.toLowerCase();
@@ -1058,28 +1653,49 @@ function buildRequestHeaders(apiKey, tracking) {
     ...tracking()
   };
 }
+function resolveCeiling(ceiling) {
+  if (ceiling === void 0) return Infinity;
+  if (typeof ceiling !== "function") return ceiling;
+  return Math.max(ceiling(), MIN_REQUEST_TIMEOUT_MS);
+}
+function clampTimeout(requestedMs, ceiling, defaultMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+  return Math.min(requestedMs ?? defaultMs, resolveCeiling(ceiling));
+}
 function createHttpClient(deps) {
-  return async function request(url, method = "GET", body) {
-    const init = {
+  const defaultTimeoutMs = deps.defaultTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  return async function request(url, method = "GET", body, options) {
+    const timeoutMs = clampTimeout(
+      options?.timeoutMs,
+      deps.maxTimeoutMs,
+      defaultTimeoutMs
+    );
+    return withRequestTimeout(
+      deps.errorPrefix,
+      timeoutMs,
       method,
-      headers: buildRequestHeaders(deps.apiKey, deps.tracking)
-    };
-    if (body && methodSendsBody(method)) {
-      init.body = JSON.stringify(body);
-    }
-    const response = await deps.fetch(url, init);
-    if (!response.ok) {
-      throw new HttpError(
-        deps.errorPrefix,
-        response.status,
-        await response.text(),
-        response.status === 429 ? rateLimitHint(
-          response.headers.get("ratelimit"),
-          response.headers.get("retry-after")
-        ) : response.status === 401 ? EXPIRED_CREDENTIAL_HINT : void 0
-      );
-    }
-    return isJsonContentType(response.headers.get("content-type")) ? response.json() : { success: true, status: response.status };
+      async (signal) => {
+        const init = {
+          method,
+          headers: buildRequestHeaders(deps.apiKey, deps.tracking),
+          signal
+        };
+        if (body && methodSendsBody(method)) {
+          init.body = JSON.stringify(body);
+        }
+        const response = await deps.fetch(url, init);
+        if (!response.ok) {
+          const hint = response.status === 429 ? rateLimitHint(
+            response.headers.get("ratelimit"),
+            response.headers.get("retry-after")
+          ) : response.status === 401 ? EXPIRED_CREDENTIAL_HINT : void 0;
+          const text = await response.text().catch(
+            () => "<body unavailable: the connection closed while reading it>"
+          );
+          throw new HttpError(deps.errorPrefix, response.status, text, hint);
+        }
+        return isJsonContentType(response.headers.get("content-type")) ? response.json() : { success: true, status: response.status };
+      }
+    );
   };
 }
 
@@ -1206,7 +1822,7 @@ async function streamLogsReply(rt, tool, params) {
 }
 
 // src/tools/runtime.ts
-var MCP_SERVER_VERSION = true ? "3.2.0" : "dev";
+var MCP_SERVER_VERSION = true ? "3.4.0" : "dev";
 var SESSION_ID = (0, import_node_crypto.randomUUID)();
 function trackingHeaders(server, ctx) {
   const info = server.server.getClientVersion();
@@ -1221,6 +1837,11 @@ function trackingHeaders(server, ctx) {
     sessionId: SESSION_ID
   });
 }
+var HTTP_TRANSPORT_BUDGET_MS = 5e4;
+function invocationBudget(totalMs) {
+  const startedAt = Date.now();
+  return () => totalMs - (Date.now() - startedAt);
+}
 var defaultFetch = import_node_fetch.default;
 async function withApiErrorLog(label, call) {
   try {
@@ -1244,6 +1865,23 @@ var DESTRUCTIVE = {
   openWorldHint: true
 };
 async function graphqlRequest(query, tracking, fetchImpl, url, options) {
+  return withRequestTimeout(
+    "Runpod GraphQL Error",
+    clampTimeout(options?.timeoutMs, options?.maxTimeoutMs),
+    // GraphQL is POST on the wire whatever it carries, but the retry advice keys
+    // off the method, and telling a caller its list-gpu-types "may have
+    // SUCCEEDED upstream — check with the matching list-/get- tool first" points
+    // it back at the tool that just failed. The operation keyword is what
+    // actually says whether anything could have been written.
+    isGraphqlMutation(query) ? "POST" : "GET",
+    (signal) => runGraphql(query, tracking, fetchImpl, url, signal, options)
+  );
+}
+function isGraphqlMutation(query) {
+  const firstMeaningful = query.split("\n").map((line) => line.trim()).find((line) => line.length > 0 && !line.startsWith("#"));
+  return /^mutation\b/.test(firstMeaningful ?? "");
+}
+async function runGraphql(query, tracking, fetchImpl, url, signal, options) {
   const response = await fetchImpl(url, {
     method: "POST",
     headers: {
@@ -1254,7 +1892,8 @@ async function graphqlRequest(query, tracking, fetchImpl, url, options) {
     body: JSON.stringify({
       query,
       ...options?.variables ? { variables: options.variables } : {}
-    })
+    }),
+    signal
   });
   if (!response.ok) {
     const bodyText = await response.text();
@@ -1310,39 +1949,53 @@ function createToolRuntime(server, ctx, deps = {}) {
   }
   const rawFetch = deps.fetch ?? defaultFetch;
   const httpFetch = observeUnauthorized(rawFetch);
+  const remainingHttpBudgetMs = invocationBudget(HTTP_TRANSPORT_BUDGET_MS);
+  const timeouts = {
+    defaultTimeoutMs: deps.defaultTimeoutMs,
+    maxTimeoutMs: deps.maxTimeoutMs ?? (ctx.transport === "http" ? remainingHttpBudgetMs : void 0)
+  };
   const v1Client = createHttpClient({
     apiKey: ctx.apiKey,
     fetch: httpFetch,
     tracking,
-    errorPrefix: "Runpod API Error"
+    errorPrefix: "Runpod API Error",
+    ...timeouts
   });
-  const runpodRequest = (endpoint, method = "GET", body) => withApiErrorLog(
+  const runpodRequest = (endpoint, method = "GET", body, options) => withApiErrorLog(
     "Error calling Runpod API:",
-    () => v1Client(`${restV1Base(process.env)}${endpoint}`, method, body)
+    () => v1Client(
+      `${restV1Base(process.env)}${endpoint}`,
+      method,
+      body,
+      options
+    )
   );
   const serverlessClient = createHttpClient({
     apiKey: ctx.apiKey,
     fetch: httpFetch,
     tracking,
-    errorPrefix: "Runpod Serverless API Error"
+    errorPrefix: "Runpod Serverless API Error",
+    ...timeouts
   });
-  const serverlessRequest = (endpointId, path2, method = "GET", body) => withApiErrorLog(
+  const serverlessRequest = (endpointId, path2, method = "GET", body, options) => withApiErrorLog(
     "Error calling Runpod Serverless API:",
     () => serverlessClient(
       `${serverlessBase(process.env)}/${endpointId}${path2}`,
       method,
-      body
+      body,
+      options
     )
   );
   const restClient = createHttpClient({
     apiKey: ctx.apiKey,
     fetch: httpFetch,
     tracking,
-    errorPrefix: "Runpod API Error"
+    errorPrefix: "Runpod API Error",
+    ...timeouts
   });
-  const callRestUrl = (url, method = "GET", body) => withApiErrorLog(
+  const callRestUrl = (url, method = "GET", body, options) => withApiErrorLog(
     "Error calling Runpod API:",
-    () => restClient(url, method, body)
+    () => restClient(url, method, body, options)
   );
   const sseFetch = observeUnauthorized(
     deps.sseFetch ?? import_node_fetch.default
@@ -1375,12 +2028,18 @@ function createToolRuntime(server, ctx, deps = {}) {
   };
   return {
     jsonReply,
+    // No GraphQL caller overrides a deadline, but both are still capped by the
+    // shared budget: deploy-hub-repo spends one of each back to back.
     graphql: (query) => graphqlRequest(
       query,
       tracking,
       // rawFetch, not httpFetch: this call carries no credential (see above).
       rawFetch,
-      publicGraphqlBase(process.env)
+      publicGraphqlBase(process.env),
+      {
+        timeoutMs: deps.defaultTimeoutMs,
+        maxTimeoutMs: timeouts.maxTimeoutMs
+      }
     ),
     graphqlAuthed: (query, variables) => graphqlRequest(
       query,
@@ -1388,7 +2047,12 @@ function createToolRuntime(server, ctx, deps = {}) {
       httpFetch,
       // NOT publicGraphqlBase: this call carries the caller's API key.
       authedGraphqlBase(process.env),
-      { variables, apiKey: ctx.apiKey }
+      {
+        variables,
+        apiKey: ctx.apiKey,
+        timeoutMs: deps.defaultTimeoutMs,
+        maxTimeoutMs: timeouts.maxTimeoutMs
+      }
     ),
     runpodRequest,
     serverlessRequest,
@@ -1396,7 +2060,8 @@ function createToolRuntime(server, ctx, deps = {}) {
     backendFor,
     streamSse,
     podAction,
-    env: process.env
+    env: process.env,
+    transport: ctx.transport
   };
 }
 
@@ -1465,6 +2130,7 @@ function capListResult(result, options, extra) {
 }
 
 // src/tools/catalog.ts
+var GPU_PRODUCTS = /* @__PURE__ */ new Set(["POD", "CLUSTER", "SERVERLESS"]);
 function registerCatalogTools(server, rt) {
   const { jsonReply: jsonReply2, graphql, callRestUrl, backendFor } = rt;
   server.tool(
@@ -1483,15 +2149,50 @@ function registerCatalogTools(server, rt) {
       ),
       includeAvailability: import_zod3.z.boolean().optional().describe(
         "Request realtime stock and annotate each GPU with an availability summary (HIGH/MEDIUM/LOW/NONE). Default true. Set false to skip the availability lookup \u2014 then out-of-stock GPUs cannot be filtered."
+      ),
+      product: import_zod3.z.enum(["POD", "CLUSTER", "SERVERLESS"]).optional().describe(
+        "Product context for the availability lookup \u2014 the same GPU can be scarce for Pods and plentiful for Serverless. Default POD. Use SERVERLESS when picking a GPU for an endpoint, CLUSTER for Instant Clusters. Ignored when includeAvailability is false."
+      ),
+      minCudaVersion: import_zod3.z.string().optional().describe(
+        'Scope the availability lookup to hosts at or above this CUDA version (v2 only). Integer major or major.minor \u2014 "12" means any 12.x release; unlike the create-pod/create-endpoint body fields, a bare major is accepted here because the filter only widens a read. Requires includeAvailability (the default).'
       )
     },
     { title: "List GPU types", ...READ_ONLY },
     async (params) => {
       const backend = backendFor("gpus");
+      if (params.minCudaVersion !== void 0 && backend.version !== "v2") {
+        return jsonReply2({
+          error: "The minCudaVersion filter is only supported on the v2 REST API. Set RUNPOD_REST_VERSION=v2, or use get-capacity for per-CUDA-version availability.",
+          status: 501
+        });
+      }
       if (backend.version === "v2") {
         const wantAvailability = params.includeAvailability !== false;
+        const product = GPU_PRODUCTS.has(String(params.product)) ? String(params.product) : "POD";
+        if (params.minCudaVersion !== void 0) {
+          if (!wantAvailability) {
+            return jsonReply2({
+              error: "minCudaVersion filters the availability lookup, so it requires includeAvailability (the default). Drop includeAvailability:false or the filter.",
+              status: 400
+            });
+          }
+          if (!/^\d+(\.\d+)?$/.test(params.minCudaVersion)) {
+            return jsonReply2({
+              error: 'minCudaVersion must be an integer major ("12") or major.minor ("12.1").',
+              status: 400
+            });
+          }
+        }
+        const query = new URLSearchParams();
+        if (wantAvailability) {
+          query.set("include", "AVAILABILITY");
+          query.set("product", product);
+          if (params.minCudaVersion !== void 0) {
+            query.set("minCudaVersion", params.minCudaVersion);
+          }
+        }
         const raw = await callRestUrl(
-          `${backend.base}${backend.list}${wantAvailability ? "?include=AVAILABILITY" : ""}`
+          `${backend.base}${backend.list}${query.size ? `?${query}` : ""}`
         );
         let gpus = backend.unwrap(raw);
         gpus = gpus.filter((g) => g.id !== "unknown");
@@ -1664,6 +2365,9 @@ function registerCatalogTools(server, rt) {
       gpuTypeId: import_zod3.z.string().describe("ID of the GPU type to retrieve"),
       includeAvailability: import_zod3.z.boolean().optional().describe(
         "Include realtime per-datacenter availability (HIGH/MEDIUM/LOW/NONE). Default true."
+      ),
+      product: import_zod3.z.enum(["POD", "CLUSTER", "SERVERLESS"]).optional().describe(
+        "Product context for the availability lookup \u2014 stock differs by product. Default POD. Use SERVERLESS when picking a GPU for an endpoint, CLUSTER for Instant Clusters. Ignored when includeAvailability is false."
       )
     },
     { title: "Get GPU type", ...READ_ONLY },
@@ -1676,7 +2380,8 @@ function registerCatalogTools(server, rt) {
         });
       }
       const path2 = backend.get(encodeURIComponent(params.gpuTypeId));
-      const query = params.includeAvailability === false ? "" : "?include=AVAILABILITY";
+      const product = GPU_PRODUCTS.has(String(params.product)) ? String(params.product) : "POD";
+      const query = params.includeAvailability === false ? "" : `?include=AVAILABILITY&product=${product}`;
       const result = await callRestUrl(`${backend.base}${path2}${query}`);
       return jsonReply2(result);
     }
@@ -2556,7 +3261,7 @@ function registerPodTools(server, rt) {
   );
   server.tool(
     "create-pod",
-    'Create a new GPU/CPU pod on Runpod. Pass gpuTypeIds for a GPU pod, or computeType:"CPU" for a CPU pod (CPU pods are served by the v1 API for now). Pass either imageName or templateId (templateId deploys from an existing template \u2014 its name, image, start command, ports, env, disk, volume, and registry credential are used as defaults, and any field you also pass explicitly replaces the template value for that field, e.g. passing env replaces the whole env set rather than merging; pass containerRegistryAuthId to override or supply a private-image credential, or an empty string to deploy with none). If the user specifies neither an image nor a template, recommend the "Runpod Pytorch 2.8.0" image (runpod/pytorch:1.0.2-cu1281-torch280-ubuntu2404) as the default \u2014 it has the most up-to-date CUDA and PyTorch versions.',
+    'Create a new GPU/CPU pod on Runpod. Pass gpuTypeIds for a GPU pod, or computeType:"CPU" for a CPU pod (CPU pods are served by the v1 API for now). Pass either imageName or templateId (templateId deploys from an existing template \u2014 its name, image, start command, ports, env, disk, volume, and registry credential are used as defaults, and any field you also pass explicitly replaces the template value for that field, e.g. passing env replaces the whole env set rather than merging; pass containerRegistryAuthId to override or supply a private-image credential, or an empty string to deploy with none). For full SSH access (including SCP/SFTP/rsync), pass sshPublicKey \u2014 it sets the PUBLIC_KEY env var and exposes 22/tcp, which official Runpod images turn into a running sshd with the key authorized. If the user specifies neither an image nor a template, recommend the "Runpod Pytorch 2.8.0" image (runpod/pytorch:1.0.2-cu1281-torch280-ubuntu2404) as the default \u2014 it has the most up-to-date CUDA and PyTorch versions.',
     {
       name: import_zod7.z.string().optional().describe(
         "Name for the pod. Required on v2 unless deploying from a templateId (the template supplies its name as the default)."
@@ -2570,20 +3275,48 @@ function registerPodTools(server, rt) {
       ),
       cloudType: import_zod7.z.enum(["SECURE", "COMMUNITY"]).optional().describe("SECURE or COMMUNITY cloud"),
       gpuTypeIds: import_zod7.z.array(import_zod7.z.string()).optional().describe("List of acceptable GPU types"),
-      gpuCount: import_zod7.z.number().optional().describe("Number of GPUs"),
+      // v2 GpuConfig.count is `integer, minimum: 1`. Without these bounds a 0,
+      // a negative, or a fractional count reached the wire as-is and came back
+      // as a raw 422; reject it here with a message that names the field.
+      gpuCount: import_zod7.z.number().int().min(1).optional().describe("Number of GPUs (minimum 1)"),
       containerDiskInGb: import_zod7.z.number().optional().describe("Container disk size in GB"),
       volumeInGb: import_zod7.z.number().optional().describe("Volume size in GB"),
       volumeMountPath: import_zod7.z.string().optional().describe("Path to mount the volume"),
       ports: import_zod7.z.array(import_zod7.z.string()).optional().describe("Ports to expose (e.g., '8888/http', '22/tcp')"),
       env: import_zod7.z.record(import_zod7.z.string()).optional().describe("Environment variables"),
+      sshPublicKey: import_zod7.z.string().optional().describe(
+        'SSH PUBLIC key(s) to authorize on the pod \u2014 the CONTENTS of your ~/.ssh/<key>.pub file, i.e. a literal "ssh-ed25519 AAAAC3Nza\u2026 you@host" line, NOT a path to the file, a fingerprint, or the private key; newline-separate multiple keys. Merges the key into the PUBLIC_KEY env var and ensures 22/tcp is exposed, enabling full SSH (SCP/SFTP/rsync) on any image that honors the PUBLIC_KEY convention \u2014 all runpod/* official images do. Extends template ports/env rather than replacing them.'
+      ),
       containerRegistryAuthId: import_zod7.z.string().optional().describe(
         "Container registry credential ID for pulling a private image (see list-container-registry-auths). When deploying from a templateId, this overrides the credential the template carries; pass an empty string to deploy with NO credential (clears a template\u2019s inherited registry)."
       ),
-      dataCenterIds: import_zod7.z.array(import_zod7.z.string()).optional().describe("List of data centers")
+      dataCenterIds: import_zod7.z.array(import_zod7.z.string()).optional().describe("List of data centers"),
+      allowedCudaVersions: import_zod7.z.array(import_zod7.z.string()).optional().describe(
+        'Acceptable host CUDA versions as major.minor, e.g. ["12.8","12.6"] (v2, GPU pods only). Exact match \u2014 discover valid values per GPU type with get-capacity. Mutually exclusive with minCudaVersion.'
+      ),
+      minCudaVersion: import_zod7.z.string().optional().describe(
+        'Lowest acceptable host CUDA version as major.minor, e.g. "12.4" (v2, GPU pods only). A bare major like "12" is rejected. Open-ended floor; mutually exclusive with a non-empty allowedCudaVersions.'
+      )
     },
     { title: "Create pod", ...WRITE },
     async (params) => {
       const backend = backendFor("pods");
+      const { sshPublicKey, ...podParams } = params;
+      let sshKey;
+      if (sshPublicKey !== void 0) {
+        const validated = normalizeSshPublicKey(sshPublicKey);
+        if (!validated.ok)
+          return jsonReply2({ error: validated.error, status: 400 });
+        sshKey = validated.key;
+      }
+      const sshNote = "sshPublicKey applied: PUBLIC_KEY env set and 22/tcp exposed. Full SSH (incl. SCP/SFTP/rsync) also requires an image that installs PUBLIC_KEY into authorized_keys and starts sshd (all runpod/* official images do) and a machine with a public IP \u2014 read the pod\u2019s portMappings for port 22 once it is running.";
+      const hasCudaParams = params.allowedCudaVersions !== void 0 || params.minCudaVersion !== void 0;
+      if (hasCudaParams && backend.version !== "v2") {
+        return jsonReply2({
+          error: "allowedCudaVersions/minCudaVersion are only supported on the v2 REST API. Set RUNPOD_REST_VERSION=v2.",
+          status: 501
+        });
+      }
       if (params.templateId && backend.version !== "v2") {
         return jsonReply2({
           error: "Deploying a pod from a templateId is only supported on the v2 REST API. Set RUNPOD_REST_VERSION=v2, or pass imageName instead.",
@@ -2619,6 +3352,16 @@ function registerPodTools(server, rt) {
             status: 400
           });
         }
+        if (hasCudaParams && !wantsGpu) {
+          return jsonReply2({
+            error: "allowedCudaVersions/minCudaVersion apply to GPU pods only \u2014 pass gpuTypeIds (see list-gpu-types).",
+            status: 400
+          });
+        }
+        if (hasCudaParams) {
+          const cudaError = cudaConstraintError(params);
+          if (cudaError) return jsonReply2({ error: cudaError, status: 400 });
+        }
         if (!wantsCpu && !params.name && !params.templateId) {
           return jsonReply2({
             error: "Provide a name for the pod (deploying from a templateId inherits the template name).",
@@ -2633,13 +3376,15 @@ function registerPodTools(server, rt) {
             });
           }
           try {
+            const cpuBody = sshKey ? applySshPublicKey(podParams, sshKey) : podParams;
             const result = await callRestUrl(
               `${restV1Base(env)}/pods`,
               "POST",
-              params
+              cpuBody
             );
             return jsonReply2({
               ...result,
+              ...sshKey ? { _ssh: sshNote } : {},
               _servedBy: "v1",
               _note: "CPU pod: created on the v1 API, because the v2 REST API does not support CPU pods yet."
             });
@@ -2656,7 +3401,7 @@ function registerPodTools(server, rt) {
           }
         }
       }
-      let body = backend.mapCreate(params);
+      let body = backend.mapCreate(podParams);
       if (params.templateId) {
         let template;
         try {
@@ -2674,19 +3419,21 @@ function registerPodTools(server, rt) {
         }
         body = { ...podBodyFromTemplate(template), ...body };
       }
+      if (sshKey) body = applySshPublicKey(body, sshKey);
       try {
         const result = await callRestUrl(
           `${backend.base}${backend.list}`,
           "POST",
           body
         );
+        const extras = {};
+        if (sshKey) extras._ssh = sshNote;
         if (backend.version === "v2" && (params.gpuTypeIds?.length ?? 0) > 1) {
-          return jsonReply2({
-            ...result,
-            _warning: `v2 accepts one GPU type per pod; used "${params.gpuTypeIds[0]}" and ignored ${params.gpuTypeIds.length - 1} other(s): ${params.gpuTypeIds.slice(1).join(", ")}.`
-          });
+          extras._warning = `v2 accepts one GPU type per pod; used "${params.gpuTypeIds[0]}" and ignored ${params.gpuTypeIds.length - 1} other(s): ${params.gpuTypeIds.slice(1).join(", ")}.`;
         }
-        return jsonReply2(result);
+        return jsonReply2(
+          Object.keys(extras).length ? { ...result, ...extras } : result
+        );
       } catch (error) {
         if (error instanceof HttpError) {
           return jsonReply2({ error: error.message, status: error.status });
@@ -2804,6 +3551,9 @@ function registerPodTools(server, rt) {
 var import_zod8 = require("zod");
 var MIN_QUEUE_DELAY = 0.5;
 var MIN_REQUEST_COUNT = 1;
+function isRequestCountScaler(type) {
+  return type === "REQUEST_COUNT";
+}
 var MIN_IDLE_TIMEOUT = 1;
 var MAX_IDLE_TIMEOUT = 3600;
 function scalerValueError(scalerType, scalerValue) {
@@ -2896,6 +3646,12 @@ function registerEndpointTools(server, rt) {
         'GPU pool names (v2, required). The `pool` field from list-gpu-types, e.g. ["AMPERE_80"]. NOT GPU type ids.'
       ),
       gpuCount: import_zod8.z.number().optional().describe("GPUs per worker (v2)"),
+      allowedCudaVersions: import_zod8.z.array(import_zod8.z.string()).optional().describe(
+        'Acceptable host CUDA versions for worker placement as major.minor, e.g. ["12.8"] (v2). Exact match \u2014 see get-capacity for which versions have stock. Mutually exclusive with minCudaVersion.'
+      ),
+      minCudaVersion: import_zod8.z.string().optional().describe(
+        'Lowest acceptable host CUDA version as major.minor, e.g. "12.4" (v2). A bare major like "12" is rejected. Mutually exclusive with a non-empty allowedCudaVersions.'
+      ),
       args: import_zod8.z.string().optional().describe("Container start command/args (v2)"),
       containerDiskInGb: import_zod8.z.number().optional().describe("Container disk size in GB (v2)"),
       ports: import_zod8.z.array(import_zod8.z.string()).optional().describe("Ports to expose (v2), e.g. ['8000/http']"),
@@ -2925,6 +3681,13 @@ function registerEndpointTools(server, rt) {
     { title: "Create endpoint", ...WRITE },
     async (params) => {
       const backend = backendFor("endpoints");
+      const hasCudaParams = params.allowedCudaVersions !== void 0 || params.minCudaVersion !== void 0;
+      if (hasCudaParams && backend.version !== "v2") {
+        return jsonReply2({
+          error: "allowedCudaVersions/minCudaVersion are only supported on the v2 REST API. Set RUNPOD_REST_VERSION=v2.",
+          status: 501
+        });
+      }
       if (backend.version === "v2") {
         if (!params.name) {
           return jsonReply2({
@@ -2957,6 +3720,10 @@ function registerEndpointTools(server, rt) {
         if (scalerError) {
           return jsonReply2({ error: scalerError, status: 400 });
         }
+        if (hasCudaParams) {
+          const cudaError = cudaConstraintError(params);
+          if (cudaError) return jsonReply2({ error: cudaError, status: 400 });
+        }
         const body = backend.mapCreate(params);
         const result2 = await callRestUrl(
           `${backend.base}${backend.list}`,
@@ -2994,7 +3761,7 @@ function registerEndpointTools(server, rt) {
   );
   server.tool(
     "update-endpoint",
-    "Update a Serverless endpoint's config. On v2 you can change image/disk/env/ports/registry/workers/scaling/networkVolumes/timeout/flashboot; on v1, scaling fields (worker min/max, idle timeout, scaler type/value, name). Only provided fields change. An endpoint's request routing (queue vs load balancer) is fixed at creation and cannot be changed here \u2014 recreate the endpoint instead.",
+    "Update a Serverless endpoint's config. On v2 you can change image/disk/env/ports/registry/workers/scaling/networkVolumes/timeout/flashboot, plus the GPU selection (gpuPoolIds/gpuCount) and its CUDA constraints (allowedCudaVersions/minCudaVersion) \u2014 CUDA-only or count-only changes do not require resending gpuPoolIds; on v1, scaling fields (worker min/max, idle timeout, scaler type/value, name). Only provided fields change. An endpoint's request routing (queue vs load balancer) is fixed at creation and cannot be changed here \u2014 recreate the endpoint instead. Note: passing gpuPoolIds replaces the GPU selection wholesale, which clears any GPU-type exclusions set elsewhere (console or set-endpoint-gpus) \u2014 the reply carries a _warning when that happens.",
     {
       endpointId: import_zod8.z.string().describe("ID of the endpoint to update"),
       name: import_zod8.z.string().optional().describe("New name for the endpoint"),
@@ -3013,6 +3780,12 @@ function registerEndpointTools(server, rt) {
       imageName: import_zod8.z.string().optional().describe("New Docker image (v2)"),
       gpuPoolIds: import_zod8.z.array(import_zod8.z.string()).optional().describe('New GPU pool names (v2), e.g. ["AMPERE_80"]'),
       gpuCount: import_zod8.z.number().optional().describe("New GPUs per worker (v2)"),
+      allowedCudaVersions: import_zod8.z.array(import_zod8.z.string()).optional().describe(
+        "New acceptable host CUDA versions as major.minor (v2). Changing only this does not require resending gpuPoolIds. An explicit [] clears the constraint. Mutually exclusive with minCudaVersion."
+      ),
+      minCudaVersion: import_zod8.z.string().optional().describe(
+        'New lowest acceptable host CUDA version as major.minor (v2). An empty string clears the floor; a bare major like "12" is rejected. Mutually exclusive with a non-empty allowedCudaVersions.'
+      ),
       args: import_zod8.z.string().optional().describe("New container args (v2)"),
       containerDiskInGb: import_zod8.z.number().optional().describe("New container disk size in GB (v2)"),
       ports: import_zod8.z.array(import_zod8.z.string()).optional().describe("New ports (v2)"),
@@ -3027,14 +3800,41 @@ function registerEndpointTools(server, rt) {
       const { endpointId, ...updateParams } = params;
       const backend = backendFor("endpoints");
       const url = `${backend.base}${backend.get(endpointId)}`;
+      const hasCudaParams = updateParams.allowedCudaVersions !== void 0 || updateParams.minCudaVersion !== void 0;
       if (backend.version !== "v2") {
+        if (hasCudaParams) {
+          return jsonReply2({
+            error: "allowedCudaVersions/minCudaVersion are only supported on the v2 REST API. Set RUNPOD_REST_VERSION=v2.",
+            status: 501
+          });
+        }
         const body2 = backend.mapUpdate(updateParams);
         return jsonReply2(await callRestUrl(url, "PATCH", body2));
       }
+      if (hasCudaParams) {
+        const cudaError = cudaConstraintError(updateParams, {
+          allowClear: true
+        });
+        if (cudaError) return jsonReply2({ error: cudaError, status: 400 });
+      }
+      if (updateParams.gpuPoolIds !== void 0 && !updateParams.gpuPoolIds.length) {
+        return jsonReply2({
+          error: "gpuPoolIds cannot be empty \u2014 omit it to keep the current GPU selection.",
+          status: 400
+        });
+      }
       let scalerType = updateParams.scalerType;
-      if (scalerType === void 0 && updateParams.scalerValue !== void 0) {
+      const needScalerRead = scalerType === void 0 && updateParams.scalerValue !== void 0;
+      const needExclusionRead = (updateParams.gpuPoolIds?.length ?? 0) > 0;
+      let clearedExclusions = [];
+      if (needScalerRead || needExclusionRead) {
         const current = await callRestUrl(url);
-        scalerType = current?.scaling?.type === "REQUEST_COUNT" ? "REQUEST_COUNT" : "QUEUE_DELAY";
+        if (needScalerRead) {
+          scalerType = isRequestCountScaler(current?.scaling?.type) ? "REQUEST_COUNT" : "QUEUE_DELAY";
+        }
+        if (needExclusionRead && current?.gpu?.excludedTypes?.length) {
+          clearedExclusions = current.gpu.excludedTypes;
+        }
       }
       const scalerError = scalerValueError(
         scalerType,
@@ -3047,7 +3847,14 @@ function registerEndpointTools(server, rt) {
         ...updateParams,
         scalerType
       });
-      return jsonReply2(await callRestUrl(url, "PATCH", body));
+      const result = await callRestUrl(url, "PATCH", body);
+      if (clearedExclusions.length) {
+        return jsonReply2({
+          ...result,
+          _warning: `Supplying gpuPoolIds replaced the GPU selection wholesale, clearing ${clearedExclusions.length} GPU-type exclusion(s) previously set on this endpoint: ${clearedExclusions.join(", ")}. Re-apply them with set-endpoint-gpus if still wanted.`
+        });
+      }
+      return jsonReply2(result);
     }
   );
   server.tool(
@@ -3147,8 +3954,108 @@ var import_zod9 = require("zod");
 var DIAGNOSIS_TTL_MS = 15e3;
 var MAX_DIAGNOSIS_ENTRIES = 500;
 var diagnosisCache = /* @__PURE__ */ new Map();
+var HTTP_LONG_POLL_BUDGET_MS = 45e3;
+var STDIO_STREAM_BUDGET_MS = 5 * 60 * 1e3;
+var RUNSYNC_UPSTREAM_DEFAULT_WAIT_MS = 9e4;
+var STREAM_UPSTREAM_DEFAULT_WAIT_MS = 1e4;
+var HTTP_STREAM_POLL_WAIT_MS = 1e3;
+var STREAM_JOB_POLL_INTERVAL_MS = 1e3;
+var MAX_CONSECUTIVE_STREAM_ERRORS = 5;
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED",
+  "TIMED_OUT"
+]);
+function isUnfinishedJobReply(result) {
+  return result !== null && typeof result === "object" && !Array.isArray(result) && !("waitClamped" in result) && !TERMINAL_STATUSES.has(result.status ?? "");
+}
+function formatBudget(ms) {
+  return ms >= 12e4 ? `${Math.round(ms / 6e4)} minutes` : `${Math.round(ms / 1e3)} seconds`;
+}
+var UPSTREAM_HOLD_SLACK_MS = 5e3;
+var MIN_STREAM_POLL_TIMEOUT_MS = 2e3;
+var QUEUED_DIAGNOSIS_TIMEOUT_MS = 5e3;
+function streamPollTimeoutMs(remainingMs, holdMs) {
+  return Math.max(
+    Math.min(remainingMs, holdMs + UPSTREAM_HOLD_SLACK_MS),
+    MIN_STREAM_POLL_TIMEOUT_MS
+  );
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function streamPollPlan(hosted) {
+  return hosted ? {
+    budgetMs: HTTP_LONG_POLL_BUDGET_MS,
+    holdMs: HTTP_STREAM_POLL_WAIT_MS,
+    query: `?wait=${HTTP_STREAM_POLL_WAIT_MS}`
+  } : {
+    budgetMs: STDIO_STREAM_BUDGET_MS,
+    holdMs: STREAM_UPSTREAM_DEFAULT_WAIT_MS,
+    query: ""
+  };
+}
+var RESUME_ADVICE = "Call stream-job again to continue collecting output, get-job-status to check the job without streaming, or stream without a budget by calling the runtime API directly (GET https://api.runpod.ai/v2/{endpointId}/stream/{jobId} with a Bearer API key).";
+function budgetExhaustedNote(budgetMs, lastError) {
+  return {
+    pollingTimedOut: true,
+    note: `Polling stopped after ${formatBudget(
+      budgetMs
+    )} with the job possibly still running. ${RESUME_ADVICE}`,
+    // Surface the trailing error (if any) instead of discarding it — the last
+    // polls may have been failing (e.g. job expired) even though earlier ones
+    // succeeded. Cleared on success, so this is never a stale error from
+    // minutes of healthy streaming ago.
+    ...lastError ? { lastError } : {}
+  };
+}
+function errorCapNote(lastError) {
+  return {
+    error: `Polling aborted after ${MAX_CONSECUTIVE_STREAM_ERRORS} consecutive errors: ${lastError}`,
+    note: `Polling stopped after ${MAX_CONSECUTIVE_STREAM_ERRORS} consecutive errors with the job possibly still running. ${RESUME_ADVICE}`
+  };
+}
+async function collectJobStream(deps) {
+  const { poll, budgetMs, holdMs } = deps;
+  const startedAt = Date.now();
+  const elapsed = () => Date.now() - startedAt;
+  const chunks = [];
+  let result = {};
+  let consecutiveErrors = 0;
+  let lastError;
+  while (true) {
+    try {
+      const reply = await poll(
+        streamPollTimeoutMs(budgetMs - elapsed(), holdMs)
+      );
+      consecutiveErrors = 0;
+      lastError = void 0;
+      if (Array.isArray(reply.stream)) chunks.push(...reply.stream);
+      result = reply;
+      if (TERMINAL_STATUSES.has(reply.status)) break;
+    } catch (error) {
+      consecutiveErrors++;
+      lastError = error instanceof Error ? error.message : String(error);
+      if (consecutiveErrors >= MAX_CONSECUTIVE_STREAM_ERRORS) {
+        result = { ...result, ...errorCapNote(lastError) };
+        break;
+      }
+    }
+    if (elapsed() > budgetMs) {
+      result = { ...result, ...budgetExhaustedNote(budgetMs, lastError) };
+      break;
+    }
+    await sleep(STREAM_JOB_POLL_INTERVAL_MS);
+  }
+  return { result, chunks };
+}
 function registerJobTools(server, rt) {
   const { jsonReply: jsonReply2, serverlessRequest, backendFor, callRestUrl } = rt;
+  const hosted = rt.transport === "http";
+  const streamBudget = formatBudget(
+    hosted ? HTTP_LONG_POLL_BUDGET_MS : STDIO_STREAM_BUDGET_MS
+  );
   async function diagnoseQueuedJob(endpointId) {
     const cached = diagnosisCache.get(endpointId);
     if (cached && cached.expiresAt > Date.now()) {
@@ -3159,7 +4066,10 @@ function registerJobTools(server, rt) {
       const backend = backendFor("workers");
       if (backend.version !== "v2") return null;
       const raw = await callRestUrl(
-        `${backend.base}/serverless/${endpointId}/workers`
+        `${backend.base}/serverless/${endpointId}/workers`,
+        "GET",
+        void 0,
+        { timeoutMs: QUEUED_DIAGNOSIS_TIMEOUT_MS }
       );
       const summary = raw?.summary;
       const workers = raw?.workers ?? [];
@@ -3250,14 +4160,14 @@ function registerJobTools(server, rt) {
   );
   server.tool(
     "runsync-endpoint",
-    "Submit a synchronous job to a Serverless endpoint and wait for the result. Best for tasks completing within 90 seconds. If processing exceeds 90 seconds, the response returns a job ID to poll with get-job-status. Max payload: 20 MB. Results expire after 1 minute. Use the wait parameter to extend the server-side wait up to 5 minutes (300000 ms).",
+    `Submit a synchronous job to a Serverless endpoint and wait for the result. Best for fast tasks: if the job outlives the wait, the response returns a job ID and a non-terminal status (IN_QUEUE or IN_PROGRESS) to poll with get-job-status. Max payload 20 MB; results expire after 1 minute. ${hosted ? `This server waits up to ${HTTP_LONG_POLL_BUDGET_MS} ms \u2014 it runs behind a 60-second gateway deadline, so that is both the default and the ceiling for the wait parameter. For longer jobs use run-endpoint + get-job-status, or POST https://api.runpod.ai/v2/{endpointId}/runsync?wait=300000 directly with a Bearer API key.` : "The wait parameter extends the server-side wait to up to 5 minutes (300000 ms); it defaults to 90000 (90 seconds)."}`,
     {
       endpointId: endpointIdSchema.describe(
         "ID of the Serverless endpoint to run synchronously"
       ),
       input: inputSchema,
       wait: import_zod9.z.number().min(1e3).max(3e5).optional().describe(
-        "How long in milliseconds the server should wait for a result before returning a job ID to poll (1000\u2013300000). Defaults to 90000 (90 seconds)."
+        hosted ? `How long in milliseconds the server should wait for a result before returning a job ID to poll. Accepted range 1000\u2013300000, but this server clamps anything above ${HTTP_LONG_POLL_BUDGET_MS} down to ${HTTP_LONG_POLL_BUDGET_MS}, which is also the effective default.` : "How long in milliseconds the server should wait for a result before returning a job ID to poll (1000\u2013300000). Defaults to 90000 (90 seconds)."
       ),
       webhook: webhookSchema,
       policy: policySchema,
@@ -3266,13 +4176,36 @@ function registerJobTools(server, rt) {
     { title: "Run endpoint (sync)", ...WRITE },
     async (params) => {
       const { endpointId, wait, ...body } = params;
-      const path2 = wait ? `/runsync?wait=${wait}` : "/runsync";
+      const effectiveWait = hosted ? Math.min(
+        wait ?? RUNSYNC_UPSTREAM_DEFAULT_WAIT_MS,
+        HTTP_LONG_POLL_BUDGET_MS
+      ) : wait;
+      const waitQuery = effectiveWait === void 0 ? "" : `?wait=${effectiveWait}`;
+      const path2 = `/runsync${waitQuery}`;
       const result = await serverlessRequest(
         endpointId,
         path2,
         "POST",
-        body
+        body,
+        {
+          // From the wait actually sent — on http the clamped 45s, not the
+          // 300s the caller may have asked for.
+          timeoutMs: (effectiveWait ?? RUNSYNC_UPSTREAM_DEFAULT_WAIT_MS) + UPSTREAM_HOLD_SLACK_MS
+        }
       );
+      const requestedWait = wait ?? RUNSYNC_UPSTREAM_DEFAULT_WAIT_MS;
+      if (hosted && requestedWait > HTTP_LONG_POLL_BUDGET_MS && isUnfinishedJobReply(result)) {
+        return jsonReply2({
+          ...result,
+          waitClamped: {
+            requestedMs: requestedWait,
+            effectiveMs: effectiveWait,
+            reason: `This server runs behind a 60-second gateway deadline, so a non-terminal status here means the job outlived ${formatBudget(
+              HTTP_LONG_POLL_BUDGET_MS
+            )}, not the requested wait \u2014 poll get-job-status rather than treating it as stuck.`
+          }
+        });
+      }
       return jsonReply2(result);
     }
   );
@@ -3306,7 +4239,7 @@ function registerJobTools(server, rt) {
   );
   server.tool(
     "stream-job",
-    "Retrieve all streaming output from a Serverless job by polling until the job reaches a terminal state. The worker must support streaming output. Polls /stream/{jobId} repeatedly and collects every chunk until status is COMPLETED, FAILED, CANCELLED, or TIMED_OUT.",
+    `Retrieve streaming output from a Serverless job. The worker must support streaming output. Polls /stream/{jobId} and collects chunks until the status is COMPLETED, FAILED, CANCELLED, or TIMED_OUT, for up to ${streamBudget}${hosted ? " (this server runs behind a 60-second gateway deadline)" : ""}. If the budget expires first, returns the chunks collected so far with pollingTimedOut: true \u2014 call stream-job again to resume where it left off, or get-job-status to check without streaming.${hosted ? " To collect with no budget, poll GET https://api.runpod.ai/v2/{endpointId}/stream/{jobId} yourself with a Bearer API key until the status is terminal \u2014 each request drains only the chunks buffered so far, so a single request is not the whole output." : ""}`,
     {
       endpointId: endpointIdSchema.describe(
         "ID of the Serverless endpoint the job belongs to"
@@ -3315,51 +4248,16 @@ function registerJobTools(server, rt) {
     },
     { title: "Stream job", ...READ_ONLY },
     async (params) => {
-      const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
-        "COMPLETED",
-        "FAILED",
-        "CANCELLED",
-        "TIMED_OUT"
-      ]);
-      const MAX_POLL_TIME_MS = 5 * 60 * 1e3;
-      const POLL_INTERVAL_MS = 1e3;
-      const MAX_CONSECUTIVE_ERRORS = 5;
-      const allChunks = [];
-      let finalResult = {};
-      let consecutiveErrors = 0;
-      let lastError;
-      const startTime = Date.now();
-      while (true) {
-        try {
-          const result = await serverlessRequest(
-            params.endpointId,
-            `/stream/${params.jobId}`
-          );
-          consecutiveErrors = 0;
-          if (Array.isArray(result.stream)) {
-            allChunks.push(...result.stream);
-          }
-          finalResult = result;
-          if (TERMINAL_STATUSES.has(result.status)) {
-            break;
-          }
-        } catch (error) {
-          consecutiveErrors++;
-          lastError = error instanceof Error ? error.message : String(error);
-          if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
-            finalResult.error = `Polling aborted after ${MAX_CONSECUTIVE_ERRORS} consecutive errors: ${lastError}`;
-            break;
-          }
-        }
-        if (Date.now() - startTime > MAX_POLL_TIME_MS) {
-          finalResult.pollingTimedOut = true;
-          finalResult.note = "Polling timed out after 5 minutes. Use get-job-status to check the job later.";
-          if (lastError) finalResult.lastError = lastError;
-          break;
-        }
-        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-      }
-      return jsonReply2({ ...finalResult, stream: allChunks });
+      const plan = streamPollPlan(hosted);
+      const streamPath = `/stream/${params.jobId}${plan.query}`;
+      const { result, chunks } = await collectJobStream({
+        budgetMs: plan.budgetMs,
+        holdMs: plan.holdMs,
+        poll: (timeoutMs) => serverlessRequest(params.endpointId, streamPath, "GET", void 0, {
+          timeoutMs
+        })
+      });
+      return jsonReply2({ ...result, stream: chunks });
     }
   );
   server.tool(