@runpod/mcp-server 1.3.0 → 2.0.0

package/dist/stdio.cjs

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,13 +30,426 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/install/clients.ts
+function localServerConfig(apiKey, serverProperty) {
+  const config = {
+    command: "npx",
+    args: ["-y", NPM_PACKAGE],
+    env: { RUNPOD_API_KEY: apiKey }
+  };
+  return serverProperty === "servers" ? { type: "stdio", ...config } : config;
+}
+function hostedServerConfig(strategy, serverProperty, url) {
+  if (strategy === "mcp-remote") {
+    return { command: "npx", args: ["-y", "mcp-remote", url] };
+  }
+  return serverProperty === "servers" ? { type: "http", url } : { url };
+}
+function upsertJsonServer(configPath, serverProperty, 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");
+    return { success: true };
+  } catch (error) {
+    return { success: false, message: errMessage(error) };
+  }
+}
+function removeJsonServer(configPath, serverProperty) {
+  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");
+    return { success: true };
+  } catch (error) {
+    return { success: false, message: errMessage(error) };
+  }
+}
+function errMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function exists(p2) {
+  try {
+    return fs.existsSync(p2);
+  } catch {
+    return false;
+  }
+}
+function jsonClient(opts) {
+  const serverProperty = opts.serverProperty ?? "mcpServers";
+  const hostedStrategy = opts.hostedStrategy ?? "http";
+  return {
+    id: opts.id,
+    name: opts.name,
+    detect: () => Promise.resolve(
+      (opts.detectPaths?.() ?? [path.dirname(opts.configPath())]).some(exists)
+    ),
+    add: (mode) => {
+      const value = mode.kind === "local" ? localServerConfig(mode.apiKey, serverProperty) : hostedServerConfig(hostedStrategy, serverProperty, mode.url);
+      return Promise.resolve(
+        upsertJsonServer(opts.configPath(), serverProperty, value)
+      );
+    },
+    remove: () => Promise.resolve(removeJsonServer(opts.configPath(), serverProperty)),
+    describeTarget: () => opts.configPath()
+  };
+}
+function findClaudeBinary() {
+  const candidates = [
+    path.join(os.homedir(), ".claude", "local", "claude"),
+    "/usr/local/bin/claude",
+    "/opt/homebrew/bin/claude"
+  ];
+  for (const candidate of candidates) {
+    if (exists(candidate)) return candidate;
+  }
+  try {
+    (0, import_child_process.execSync)("command -v claude", { stdio: "pipe" });
+    return "claude";
+  } catch {
+    return null;
+  }
+}
+function runClaude(binary, args) {
+  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" };
+    }
+    return { success: false, message };
+  }
+}
+function claudeDesktopConfigPath() {
+  if (process.platform === "win32") {
+    return path.join(appData, "Claude", "claude_desktop_config.json");
+  }
+  return path.join(
+    home,
+    "Library",
+    "Application Support",
+    "Claude",
+    "claude_desktop_config.json"
+  );
+}
+function vsCodeConfigPath() {
+  if (process.platform === "win32") {
+    return path.join(appData, "Code", "User", "mcp.json");
+  }
+  if (process.platform === "darwin") {
+    return path.join(
+      home,
+      "Library",
+      "Application Support",
+      "Code",
+      "User",
+      "mcp.json"
+    );
+  }
+  return 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 init_clients = __esm({
+  "src/install/clients.ts"() {
+    "use strict";
+    fs = __toESM(require("fs"), 1);
+    os = __toESM(require("os"), 1);
+    path = __toESM(require("path"), 1);
+    import_child_process = require("child_process");
+    jsonc = __toESM(require("jsonc-parser"), 1);
+    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)"
+    };
+    home = os.homedir();
+    appData = process.env.APPDATA ?? path.join(home, "AppData", "Roaming");
+    CLIENTS = [
+      claudeCodeClient,
+      jsonClient({
+        id: "cursor",
+        name: "Cursor",
+        configPath: () => path.join(home, ".cursor", "mcp.json")
+      }),
+      jsonClient({
+        id: "windsurf",
+        name: "Windsurf",
+        // 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")
+      }),
+      jsonClient({
+        id: "claude-desktop",
+        name: "Claude Desktop",
+        // Claude Desktop config files are stdio-only; use the mcp-remote bridge.
+        hostedStrategy: "mcp-remote",
+        configPath: claudeDesktopConfigPath,
+        // Detect by the application/support directory, which exists once the app runs.
+        detectPaths: () => [path.dirname(claudeDesktopConfigPath())]
+      }),
+      jsonClient({
+        id: "vscode",
+        name: "Visual Studio Code",
+        serverProperty: "servers",
+        configPath: vsCodeConfigPath,
+        detectPaths: () => [path.dirname(vsCodeConfigPath())]
+      })
+    ];
+  }
+});
+
+// src/install/wizard.ts
+var wizard_exports = {};
+__export(wizard_exports, {
+  runWizard: () => runWizard
+});
+function openBrowser(url) {
+  try {
+    if (process.platform === "darwin") {
+      (0, import_child_process2.execFileSync)("open", [url], { stdio: "ignore" });
+    } else if (process.platform === "win32") {
+      (0, import_child_process2.execFileSync)("cmd", ["/c", "start", "", url], { stdio: "ignore" });
+    } else {
+      (0, import_child_process2.execFileSync)("xdg-open", [url], { stdio: "ignore" });
+    }
+  } 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;
+  if (fromEnv) {
+    const useEnv = await p.confirm({
+      message: "Use the RUNPOD_API_KEY from your environment?"
+    });
+    if (p.isCancel(useEnv)) bail();
+    if (useEnv) return fromEnv;
+  }
+  const create = await p.confirm({
+    message: "Open the Runpod console to create or copy an API key?"
+  });
+  if (p.isCancel(create)) bail();
+  if (create) {
+    openBrowser(API_KEYS_URL);
+    p.log.info(`Opening ${API_KEYS_URL}`);
+  }
+  const apiKey = await p.password({
+    message: "Paste your Runpod API key",
+    validate: (value) => !value || value.trim().length === 0 ? "API key cannot be empty" : void 0
+  });
+  if (p.isCancel(apiKey)) bail();
+  return apiKey.trim();
+}
+async function selectClients(detected, verb) {
+  const options = CLIENTS.map((client) => ({
+    value: client.id,
+    label: client.name,
+    hint: detected.get(client.id) ? "detected" : void 0
+  }));
+  const selected = await p.multiselect({
+    message: `Which agents should we ${verb}?`,
+    options,
+    // Pre-select detected clients so the common case is a single Enter press.
+    initialValues: CLIENTS.filter((c) => detected.get(c.id)).map((c) => c.id),
+    required: true
+  });
+  if (p.isCancel(selected)) bail();
+  return CLIENTS.filter((c) => selected.includes(c.id));
+}
+async function detectAll() {
+  const entries = await Promise.all(
+    CLIENTS.map(async (c) => [c.id, await c.detect()])
+  );
+  return new Map(entries);
+}
+async function selectMode() {
+  const kind = await p.select({
+    message: "How do you want to connect to Runpod?",
+    options: [
+      {
+        value: "hosted",
+        label: "Sign in with Runpod (recommended)",
+        hint: "hosted, OAuth, no API key stored"
+      },
+      {
+        value: "local",
+        label: "Run locally with an API key",
+        hint: "runs on this machine via npx"
+      }
+    ],
+    initialValue: "hosted"
+  });
+  if (p.isCancel(kind)) bail();
+  if (kind === "hosted") {
+    return { kind: "hosted", url: HOSTED_URL };
+  }
+  const apiKey = await promptForApiKey();
+  const verifySpinner = p.spinner();
+  verifySpinner.start("Verifying API key");
+  const valid = await verifyApiKey(apiKey);
+  if (valid === true) {
+    verifySpinner.stop("API key verified.");
+  } else if (valid === false) {
+    verifySpinner.stop("API key rejected by Runpod.");
+    const proceed = await p.confirm({
+      message: "The key did not authenticate. Continue anyway?",
+      initialValue: false
+    });
+    if (p.isCancel(proceed) || !proceed) bail();
+  } else {
+    verifySpinner.stop("Could not verify the key (offline?). Continuing.");
+  }
+  return { kind: "local", apiKey };
+}
+async function runAdd() {
+  const detected = await detectAll();
+  const clients = await selectClients(detected, "set up");
+  const mode = await selectMode();
+  const results = [];
+  for (const client of clients) {
+    const spinner2 = p.spinner();
+    spinner2.start(`Configuring ${client.name}`);
+    const result = await client.add(mode);
+    if (result.success) {
+      spinner2.stop(`${client.name} configured.`);
+      results.push(`\u2713 ${client.name} \u2014 ${client.describeTarget()}`);
+    } else {
+      spinner2.stop(`${client.name} failed.`);
+      results.push(`\u2717 ${client.name} \u2014 ${result.message ?? "unknown error"}`);
+    }
+  }
+  p.note(results.join("\n"), "Results");
+  p.outro(
+    mode.kind === "hosted" ? 'Restart your agent, then complete "Sign in with Runpod" when it connects.' : "Restart your agent (or reconnect MCP) to load the Runpod tools."
+  );
+}
+async function runRemove() {
+  const detected = await detectAll();
+  const clients = await selectClients(detected, "remove Runpod from");
+  const results = [];
+  for (const client of clients) {
+    const spinner2 = p.spinner();
+    spinner2.start(`Removing from ${client.name}`);
+    const result = await client.remove();
+    spinner2.stop(
+      result.success ? `${client.name} cleaned up.` : `${client.name} failed.`
+    );
+    results.push(
+      `${result.success ? "\u2713" : "\u2717"} ${client.name}${result.message ? ` \u2014 ${result.message}` : ""}`
+    );
+  }
+  p.note(results.join("\n"), "Results");
+  p.outro("Done.");
+}
+async function runWizard(subcommand2) {
+  p.intro("Runpod MCP server installer");
+  if (subcommand2 === "remove") {
+    await runRemove();
+  } else {
+    await runAdd();
+  }
+}
+var import_child_process2, p, API_KEYS_URL;
+var init_wizard = __esm({
+  "src/install/wizard.ts"() {
+    "use strict";
+    import_child_process2 = require("child_process");
+    p = __toESM(require("@clack/prompts"), 1);
+    init_clients();
+    API_KEYS_URL = "https://www.runpod.io/console/user/settings";
+  }
+});
+
 // src/stdio.ts
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_node_fetch2 = __toESM(require("node-fetch"), 1);
 
 // src/server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var SERVER_NAME = "Runpod API Server";
-var SERVER_VERSION = true ? "1.3.0" : "dev";
+var SERVER_VERSION = true ? "2.0.0" : "dev";
 function createServer(version = SERVER_VERSION) {
   return new import_mcp.McpServer({
     name: SERVER_NAME,
@@ -41,32 +461,465 @@ function createServer(version = SERVER_VERSION) {
   });
 }
 
-// src/tools.ts
-var import_zod = require("zod");
+// src/tools/runtime.ts
 var import_node_fetch = __toESM(require("node-fetch"), 1);
 var import_node_crypto = require("crypto");
-var API_BASE_URL = process.env.RUNPOD_REST_API_URL ?? "https://rest.runpod.io/v1";
-var SERVERLESS_API_BASE_URL = process.env.RUNPOD_SERVERLESS_API_URL ?? "https://api.runpod.ai/v2";
-var GRAPHQL_URL = process.env.RUNPOD_PUBLIC_GRAPHQL_URL ?? "https://api.runpod.io/graphql";
-var MCP_SERVER_VERSION = true ? "1.3.0" : "dev";
-var SESSION_ID = (0, import_node_crypto.randomUUID)();
+
+// src/_shared/http.ts
+var HttpError = class extends Error {
+  constructor(prefix, status, body) {
+    super(`${prefix}: ${status} - ${body}`);
+    this.name = "HttpError";
+    this.status = status;
+    this.body = body;
+  }
+};
+function isJsonContentType(contentType) {
+  if (!contentType) return false;
+  const ct = contentType.toLowerCase();
+  return ct.includes("application/json") || ct.includes("+json");
+}
+function methodSendsBody(method) {
+  return method === "POST" || method === "PATCH" || method === "PUT";
+}
+function buildRequestHeaders(apiKey, tracking) {
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    ...tracking()
+  };
+}
+function createHttpClient(deps) {
+  return async function request(url, method = "GET", body) {
+    const init = {
+      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()
+      );
+    }
+    return isJsonContentType(response.headers.get("content-type")) ? response.json() : { success: true, status: response.status };
+  };
+}
+
+// src/_shared/tracking.ts
 function sanitizeUaToken(value) {
   return value.replace(/[()<>@,;:\\"/[\]?={}\s]/g, "_").slice(0, 64);
 }
-function trackingHeaders(server2, ctx) {
-  const info = server2.server.getClientVersion();
-  const fallbackName = ctx.clientUserAgent || "unknown";
-  const name = sanitizeUaToken(info?.name || fallbackName);
-  const version = sanitizeUaToken(info?.version || "unknown");
-  const serverVersion = ctx.serverVersion || MCP_SERVER_VERSION;
-  const userAgent = `runpod-mcp-server/${serverVersion} (caller=mcp; client=${name}; client_version=${version}; transport=${ctx.transport})`;
+function buildTrackingHeaders(input) {
+  const name = sanitizeUaToken(input.clientName || "unknown");
+  const version = sanitizeUaToken(input.clientVersion || "unknown");
+  const userAgent = `runpod-mcp-server/${input.serverVersion} (caller=mcp; client=${name}; client_version=${version}; transport=${input.transport})`;
   return {
     "User-Agent": userAgent,
-    "X-Runpod-Session-Id": SESSION_ID
+    "X-Runpod-Session-Id": input.sessionId
+  };
+}
+
+// src/_shared/mappers.ts
+function compact(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+function persistentMount(size, path2) {
+  if (size === void 0 || path2 === void 0) return void 0;
+  return { persistent: { size, path: path2 } };
+}
+function containerConfigToV2(p2) {
+  return compact({
+    image: p2.imageName,
+    disk: p2.containerDiskInGb,
+    ports: p2.ports,
+    env: p2.env,
+    mounts: persistentMount(p2.volumeInGb, p2.volumeMountPath)
+  });
+}
+function gpuConfigToV2(gpuTypeIds, gpuCount) {
+  const id = gpuTypeIds?.[0];
+  if (id === void 0) return void 0;
+  return compact({ id, count: gpuCount });
+}
+function mapPodCreateToV2(params) {
+  return compact({
+    ...containerConfigToV2(params),
+    name: params.name,
+    cloud: params.cloudType,
+    // v2 CreatePodRequest takes `dataCenterIds` as an ARRAY (preferred data
+    // centers; omit/empty = scheduler chooses). Pass the v1 list straight
+    // through — the earlier singular `dataCenter` key did not exist on the pod
+    // schema, so placement was being silently dropped. GPU, by contrast, IS
+    // 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)
+  });
+}
+function mapPodUpdateToV2(params) {
+  return {
+    ...containerConfigToV2(params),
+    ...compact({ name: params.name })
+  };
+}
+function nestedOrUndefined(obj) {
+  const c = compact(obj);
+  return Object.keys(c).length ? c : void 0;
+}
+function endpointGpuConfig(pools, count) {
+  if (!pools?.length) return void 0;
+  return compact({ pools, count });
+}
+function mapEndpointToV2(params) {
+  return compact({
+    name: params.name,
+    image: params.imageName,
+    args: params.args,
+    disk: params.containerDiskInGb,
+    ports: params.ports,
+    env: params.env,
+    registry: params.containerRegistryAuthId,
+    gpu: endpointGpuConfig(params.gpuPoolIds, params.gpuCount),
+    workers: nestedOrUndefined({
+      min: params.workersMin,
+      max: params.workersMax
+    }),
+    scaling: nestedOrUndefined({
+      type: params.scalerType,
+      value: params.scalerValue,
+      idleTimeout: params.idleTimeout
+    }),
+    dataCenterIds: params.dataCenterIds?.length ? params.dataCenterIds : void 0,
+    networkVolumes: params.networkVolumeIds?.length ? params.networkVolumeIds : void 0,
+    timeout: params.executionTimeoutMs,
+    flashboot: params.flashboot
+  });
+}
+var mapEndpointCreateToV2 = mapEndpointToV2;
+var mapEndpointUpdateToV2 = mapEndpointToV2;
+function mapNetworkVolumeCreateToV2(params) {
+  return compact({
+    name: params.name,
+    size: params.size,
+    dataCenter: params.dataCenterId
+  });
+}
+function mapTemplateCreateToV2(params) {
+  return {
+    ...containerConfigToV2(params),
+    ...compact({
+      name: params.name,
+      serverless: params.isServerless,
+      registry: params.containerRegistryAuthId
+    }),
+    // Required by v2 — always emit, defaulting to NVIDIA.
+    category: params.category ?? "NVIDIA"
+  };
+}
+function mapTemplateUpdateToV2(params) {
+  return {
+    ...containerConfigToV2(params),
+    ...compact({
+      name: params.name,
+      registry: params.containerRegistryAuthId
+    })
+  };
+}
+
+// src/_shared/backend.ts
+var V1_ONLY = /* @__PURE__ */ new Set(["jobs"]);
+var V2_UNWRAP_KEY = {
+  pods: "pods",
+  templates: "templates",
+  networkVolumes: "networkVolumes",
+  registries: "registries",
+  gpus: "gpus",
+  cpus: "cpus",
+  dataCenters: "dataCenters",
+  endpoints: "endpoints",
+  jobs: "jobs",
+  tags: "tags",
+  workers: "workers",
+  billing: "records"
+};
+var RESOURCE_ENV_KEY = {
+  pods: "PODS",
+  templates: "TEMPLATES",
+  networkVolumes: "NETWORK_VOLUMES",
+  registries: "REGISTRIES",
+  gpus: "GPUS",
+  cpus: "CPUS",
+  dataCenters: "DATA_CENTERS",
+  endpoints: "ENDPOINTS",
+  jobs: "JOBS",
+  tags: "TAGS",
+  workers: "WORKERS",
+  billing: "BILLING"
+};
+function restV1Base(env) {
+  return env.RUNPOD_REST_API_URL ?? "https://rest.runpod.io/v1";
+}
+function restV2Base(env) {
+  return env.RUNPOD_REST_V2_API_URL ?? "https://v2-rest.runpod.io/v2";
+}
+function serverlessBase(env) {
+  return env.RUNPOD_SERVERLESS_API_URL ?? "https://api.runpod.ai/v2";
+}
+function publicGraphqlBase(env) {
+  return env.RUNPOD_PUBLIC_GRAPHQL_URL ?? "https://api.runpod.io/graphql";
+}
+function unwrapList(resource, version, raw) {
+  if (version === "v1") return Array.isArray(raw) ? raw : [];
+  if (raw === null || typeof raw !== "object") return [];
+  const arr = raw[V2_UNWRAP_KEY[resource]];
+  return Array.isArray(arr) ? arr : [];
+}
+function resolveVersion(opts) {
+  const { resource, env, ctx, v2Available } = opts;
+  if (V1_ONLY.has(resource)) return "v1";
+  const perResource = env[`RUNPOD_REST_VERSION_${RESOURCE_ENV_KEY[resource]}`];
+  const setting = (perResource ?? env.RUNPOD_REST_VERSION ?? "v2").toLowerCase();
+  if (setting === "v2") return "v2";
+  if (setting === "auto") {
+    if (ctx.transport === "http") return "v1";
+    return v2Available === true ? "v2" : "v1";
+  }
+  return "v1";
+}
+function wantsAutoProbe(env) {
+  return Object.entries(env).some(
+    ([k, v]) => k.startsWith("RUNPOD_REST_VERSION") && (v ?? "").toLowerCase() === "auto"
+  );
+}
+var PROBE_TIMEOUT_MS = 4e3;
+function classifyProbeStatus(status) {
+  if (status >= 500) return void 0;
+  if (status === 401 || status === 403) return void 0;
+  return status >= 200 && status < 300;
+}
+async function runV2Probe(deps) {
+  try {
+    const res = await deps.fetch(`${deps.baseUrl}/catalog/gpus`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${deps.apiKey}` },
+      signal: AbortSignal.timeout(deps.timeoutMs ?? PROBE_TIMEOUT_MS)
+    });
+    const verdict = classifyProbeStatus(res.status);
+    if (verdict === void 0) {
+      deps.warn?.(
+        `v2 auto-probe: ${deps.baseUrl} returned ${res.status} (transient) \u2014 using v1 for now; will re-probe. Pin RUNPOD_REST_VERSION=v2 to force v2.`
+      );
+    }
+    return verdict;
+  } catch {
+    deps.warn?.(
+      `v2 auto-probe: ${deps.baseUrl} unreachable (timed out after ${deps.timeoutMs ?? PROBE_TIMEOUT_MS}ms or network error) \u2014 using v1 for now; will re-probe. Pin RUNPOD_REST_VERSION=v2 to force v2.`
+    );
+    return void 0;
+  }
+}
+function createV2Prober(deps) {
+  let cached;
+  let inFlight;
+  const probeOnce = async () => {
+    const verdict = await runV2Probe(deps);
+    if (verdict !== void 0) cached = verdict;
+    return verdict ?? false;
+  };
+  return () => {
+    if (cached !== void 0) return Promise.resolve(cached);
+    if (!inFlight) {
+      inFlight = probeOnce().finally(() => {
+        inFlight = void 0;
+      });
+    }
+    return inFlight;
+  };
+}
+var identity = (body) => body;
+var V1_REST_PATHS = {
+  pods: { list: "/pods", get: (id) => `/pods/${id}` },
+  templates: { list: "/templates", get: (id) => `/templates/${id}` },
+  networkVolumes: {
+    list: "/networkvolumes",
+    get: (id) => `/networkvolumes/${id}`
+  },
+  registries: {
+    list: "/containerregistryauth",
+    get: (id) => `/containerregistryauth/${id}`
+  },
+  endpoints: { list: "/endpoints", get: (id) => `/endpoints/${id}` }
+};
+var CATALOG = /* @__PURE__ */ new Set([
+  "gpus",
+  "cpus",
+  "dataCenters"
+]);
+var V2_ONLY = /* @__PURE__ */ new Set([
+  "tags",
+  "workers",
+  "billing"
+]);
+var V2_REST_PATHS = {
+  pods: { list: "/pods", get: (id) => `/pods/${id}` },
+  templates: { list: "/templates", get: (id) => `/templates/${id}` },
+  networkVolumes: {
+    list: "/network-volumes",
+    get: (id) => `/network-volumes/${id}`
+  },
+  registries: { list: "/registries", get: (id) => `/registries/${id}` },
+  gpus: { list: "/catalog/gpus", get: (id) => `/catalog/gpus/${id}` },
+  cpus: { list: "/catalog/cpus", get: (id) => `/catalog/cpus/${id}` },
+  dataCenters: {
+    list: "/catalog/datacenters",
+    get: (id) => `/catalog/datacenters/${id}`
+  },
+  tags: { list: "/tags", get: (id) => `/tags/${id}` },
+  // Endpoints live under /v2/serverless on v2 (NOT /v2/endpoints). The v2 list
+  // response wraps rows under `endpoints` (see V2_UNWRAP_KEY), so the existing
+  // unwrap key stays correct.
+  endpoints: { list: "/serverless", get: (id) => `/serverless/${id}` },
+  // workers/billing build their own sub-paths in the tool from `base`; the
+  // list entry just satisfies buildV2Backend (which requires a paths entry).
+  workers: { list: "/serverless" },
+  billing: { list: "/billing" }
+};
+var V2_MAPPERS = {
+  pods: {
+    create: (b) => mapPodCreateToV2(b),
+    update: (b) => mapPodUpdateToV2(b)
+  },
+  templates: {
+    create: (b) => mapTemplateCreateToV2(b),
+    update: (b) => mapTemplateUpdateToV2(b)
+  },
+  networkVolumes: {
+    create: (b) => mapNetworkVolumeCreateToV2(
+      b
+    ),
+    update: identity
+  },
+  registries: { create: identity, update: identity },
+  endpoints: {
+    create: (b) => mapEndpointCreateToV2(b),
+    update: (b) => mapEndpointUpdateToV2(b)
+  }
+};
+function buildV2Backend(resource, env, unwrap) {
+  const paths = V2_REST_PATHS[resource];
+  if (!paths) throw new Error(`no v2 REST paths for resource "${resource}"`);
+  const mappers = V2_MAPPERS[resource];
+  return {
+    kind: "rest",
+    version: "v2",
+    base: restV2Base(env),
+    list: paths.list,
+    get: paths.get,
+    unwrap,
+    mapCreate: mappers?.create ?? identity,
+    mapUpdate: mappers?.update ?? identity
+  };
+}
+function buildV1Backend(resource, env, unwrap) {
+  if (resource === "jobs") {
+    return {
+      kind: "rest",
+      version: "v1",
+      base: serverlessBase(env),
+      unwrap,
+      mapCreate: identity,
+      mapUpdate: identity
+    };
+  }
+  if (V2_ONLY.has(resource)) {
+    return {
+      kind: "rest",
+      version: "v1",
+      base: restV1Base(env),
+      unwrap,
+      mapCreate: identity,
+      mapUpdate: identity
+    };
+  }
+  if (CATALOG.has(resource)) {
+    return {
+      kind: "graphql",
+      version: "v1",
+      base: publicGraphqlBase(env),
+      unwrap,
+      mapCreate: identity,
+      mapUpdate: identity
+    };
+  }
+  const paths = V1_REST_PATHS[resource];
+  if (!paths) throw new Error(`no v1 REST paths for resource "${resource}"`);
+  return {
+    kind: "rest",
+    version: "v1",
+    base: restV1Base(env),
+    list: paths.list,
+    get: paths.get,
+    unwrap,
+    mapCreate: identity,
+    mapUpdate: identity
+  };
+}
+function resolveBackend(opts) {
+  const { resource, env } = opts;
+  const version = resolveVersion(opts);
+  const unwrap = (raw) => unwrapList(resource, version, raw);
+  return version === "v2" ? buildV2Backend(resource, env, unwrap) : buildV1Backend(resource, env, unwrap);
+}
+
+// src/tools/runtime.ts
+var MCP_SERVER_VERSION = true ? "2.0.0" : "dev";
+var SESSION_ID = (0, import_node_crypto.randomUUID)();
+function trackingHeaders(server, ctx) {
+  const info = server.server.getClientVersion();
+  return buildTrackingHeaders({
+    clientName: info?.name || ctx.clientUserAgent || "unknown",
+    clientVersion: info?.version || "unknown",
+    transport: ctx.transport,
+    // Prefer a server version supplied by the caller (the hosted entrypoint reads
+    // it from package.json at runtime, since tsup's build-time define does not
+    // run when Vercel compiles api/index.ts). Fall back to the build-time value.
+    serverVersion: ctx.serverVersion || MCP_SERVER_VERSION,
+    sessionId: SESSION_ID
+  });
+}
+var defaultFetch = import_node_fetch.default;
+async function withApiErrorLog(label, call) {
+  try {
+    return await call();
+  } catch (error) {
+    console.error(label, error);
+    throw error;
+  }
+}
+function jsonReply(result) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
   };
 }
-async function graphqlRequest(query, tracking) {
-  const response = await (0, import_node_fetch.default)(GRAPHQL_URL, {
+var READ_ONLY = { readOnlyHint: true, openWorldHint: true };
+var WRITE = { readOnlyHint: false, openWorldHint: true };
+var DESTRUCTIVE = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  idempotentHint: true,
+  openWorldHint: true
+};
+async function graphqlRequest(query, tracking, fetchImpl, url) {
+  const response = await fetchImpl(url, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -85,92 +938,224 @@ async function graphqlRequest(query, tracking) {
   }
   return result.data;
 }
-function createRunpodRequest(apiKey, tracking) {
-  return async function runpodRequest(endpoint, method = "GET", body) {
-    const url = `${API_BASE_URL}${endpoint}`;
-    const headers = {
-      Authorization: `Bearer ${apiKey}`,
-      "Content-Type": "application/json",
-      ...tracking()
-    };
-    const options = {
+function createToolRuntime(server, ctx, deps = {}) {
+  const tracking = () => trackingHeaders(server, ctx);
+  const httpFetch = deps.fetch ?? defaultFetch;
+  const v1Client = createHttpClient({
+    apiKey: ctx.apiKey,
+    fetch: httpFetch,
+    tracking,
+    errorPrefix: "Runpod API Error"
+  });
+  const runpodRequest = (endpoint, method = "GET", body) => withApiErrorLog(
+    "Error calling Runpod API:",
+    () => v1Client(`${restV1Base(process.env)}${endpoint}`, method, body)
+  );
+  const serverlessClient = createHttpClient({
+    apiKey: ctx.apiKey,
+    fetch: httpFetch,
+    tracking,
+    errorPrefix: "Runpod Serverless API Error"
+  });
+  const serverlessRequest = (endpointId, path2, method = "GET", body) => withApiErrorLog(
+    "Error calling Runpod Serverless API:",
+    () => serverlessClient(
+      `${serverlessBase(process.env)}/${endpointId}${path2}`,
       method,
-      headers
-    };
-    if (body && (method === "POST" || method === "PATCH")) {
-      options.body = JSON.stringify(body);
-    }
+      body
+    )
+  );
+  const restClient = createHttpClient({
+    apiKey: ctx.apiKey,
+    fetch: httpFetch,
+    tracking,
+    errorPrefix: "Runpod API Error"
+  });
+  const callRestUrl = (url, method = "GET", body) => withApiErrorLog(
+    "Error calling Runpod API:",
+    () => restClient(url, method, body)
+  );
+  const streamSse = deps.streamSse ?? (async (url, opts) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.maxWaitMs);
     try {
-      const response = await (0, import_node_fetch.default)(url, options);
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(`Runpod API Error: ${response.status} - ${errorText}`);
+      const res = await (0, import_node_fetch.default)(url, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${ctx.apiKey}`,
+          Accept: "text/event-stream",
+          ...tracking()
+        },
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        throw new HttpError(
+          "Runpod API Error",
+          res.status,
+          await res.text().catch(() => "")
+        );
       }
-      const contentType = response.headers.get("content-type");
-      if (contentType && contentType.includes("application/json")) {
-        return await response.json();
+      const chunks = [];
+      let bytes = 0;
+      let truncated = false;
+      try {
+        for await (const chunk of res.body) {
+          chunks.push(chunk);
+          bytes += chunk.length;
+          if (bytes >= opts.maxBytes) {
+            truncated = true;
+            controller.abort();
+            break;
+          }
+        }
+      } catch (err) {
+        if (!(err instanceof Error && err.name === "AbortError")) throw err;
       }
-      return { success: true, status: response.status };
-    } catch (error) {
-      console.error("Error calling Runpod API:", error);
-      throw error;
+      return { raw: Buffer.concat(chunks).toString("utf8"), truncated };
+    } finally {
+      clearTimeout(timer);
+    }
+  });
+  const backendFor = (resource) => resolveBackend({
+    resource,
+    env: process.env,
+    ctx: { transport: ctx.transport },
+    v2Available: deps.v2Available
+  });
+  const podAction = async (podId, action) => {
+    const backend = backendFor("pods");
+    const podPath = backend.get(podId);
+    if (backend.version === "v2") {
+      return callRestUrl(`${backend.base}${podPath}/action`, "POST", {
+        action
+      });
     }
+    return callRestUrl(`${backend.base}${podPath}/${action}`, "POST");
+  };
+  return {
+    jsonReply,
+    graphql: (query) => graphqlRequest(
+      query,
+      tracking,
+      httpFetch,
+      publicGraphqlBase(process.env)
+    ),
+    runpodRequest,
+    serverlessRequest,
+    callRestUrl,
+    backendFor,
+    streamSse,
+    podAction,
+    env: process.env
   };
 }
-function createServerlessRequest(apiKey, tracking) {
-  return async function serverlessRequest(endpointId, path, method = "GET", body) {
-    const url = `${SERVERLESS_API_BASE_URL}/${endpointId}${path}`;
-    const headers = {
-      Authorization: `Bearer ${apiKey}`,
-      "Content-Type": "application/json",
-      ...tracking()
-    };
-    const options = {
-      method,
-      headers
+
+// src/tools/catalog.ts
+var import_zod2 = require("zod");
+
+// src/pagination.ts
+var import_zod = require("zod");
+var DEFAULT_LIST_LIMIT = 20;
+var MAX_LIST_LIMIT = 100;
+var listPaginationParams = {
+  limit: import_zod.z.number().int().positive().max(MAX_LIST_LIMIT).optional().describe(
+    `Maximum number of items to return (default ${DEFAULT_LIST_LIMIT}, max ${MAX_LIST_LIMIT}). Use the returned nextCursor to fetch the next page.`
+  ),
+  cursor: import_zod.z.string().optional().describe(
+    "Opaque pagination cursor from a previous response (nextCursor). Omit to start from the beginning."
+  )
+};
+function decodeCursorOffset(cursor) {
+  if (!cursor) return 0;
+  try {
+    const decoded = Buffer.from(cursor, "base64").toString("utf8");
+    const offset = Number.parseInt(decoded, 10);
+    return Number.isFinite(offset) && offset >= 0 ? offset : 0;
+  } catch {
+    return 0;
+  }
+}
+function encodeCursorOffset(offset) {
+  return Buffer.from(String(offset), "utf8").toString("base64");
+}
+function capListResult(result, options, extra) {
+  const limit = Math.min(options.limit ?? DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT);
+  const offset = decodeCursorOffset(options.cursor);
+  if (!Array.isArray(result)) {
+    return {
+      content: [
+        { type: "text", text: JSON.stringify(result, null, 2) }
+      ]
     };
-    if (body && (method === "POST" || method === "PATCH")) {
-      options.body = JSON.stringify(body);
-    }
-    try {
-      const response = await (0, import_node_fetch.default)(url, options);
-      if (!response.ok) {
-        const errorText = await response.text();
-        throw new Error(
-          `Runpod Serverless API Error: ${response.status} - ${errorText}`
-        );
-      }
-      const contentType = response.headers.get("content-type");
-      if (contentType && contentType.includes("application/json")) {
-        return await response.json();
-      }
-      return { success: true, status: response.status };
-    } catch (error) {
-      console.error("Error calling Runpod Serverless API:", error);
-      throw error;
+  }
+  const total = result.length;
+  const page = result.slice(offset, offset + limit);
+  const nextOffset = offset + page.length;
+  const hasMore = nextOffset < total;
+  const { items: _i, pagination: _p, ...safeExtra } = extra ?? {};
+  void _i;
+  void _p;
+  const envelope = {
+    ...safeExtra,
+    items: page,
+    pagination: {
+      total,
+      returned: page.length,
+      offset,
+      truncated: hasMore,
+      nextCursor: hasMore ? encodeCursorOffset(nextOffset) : null,
+      note: hasMore ? `Showing ${page.length} of ${total}. Pass cursor=nextCursor to fetch more, or narrow the query with filters.` : void 0
     }
   };
+  return {
+    content: [
+      { type: "text", text: JSON.stringify(envelope, null, 2) }
+    ]
+  };
 }
-function registerTools(server2, ctx) {
-  const tracking = () => trackingHeaders(server2, ctx);
-  const runpodRequest = createRunpodRequest(ctx.apiKey, tracking);
-  const serverlessRequest = createServerlessRequest(ctx.apiKey, tracking);
-  server2.tool(
+
+// src/tools/catalog.ts
+function registerCatalogTools(server, rt) {
+  const { jsonReply: jsonReply2, graphql, callRestUrl, backendFor } = rt;
+  server.tool(
     "list-gpu-types",
+    "List available GPU types with stock/pricing and capability filters (minimum VRAM, secure/community cloud, name search). Use this to discover valid gpuTypeIds before creating a pod or endpoint. On v2 the realtime stock filter is a no-op.",
     {
-      minMemoryGb: import_zod.z.number().optional().describe("Filter to GPUs with at least this much VRAM in GB"),
-      secureCloudOnly: import_zod.z.boolean().optional().describe("Filter to only GPUs available in secure cloud"),
-      communityCloudOnly: import_zod.z.boolean().optional().describe("Filter to only GPUs available in community cloud"),
-      searchTerm: import_zod.z.string().optional().describe(
+      ...listPaginationParams,
+      minMemoryGb: import_zod2.z.number().optional().describe("Filter to GPUs with at least this much VRAM in GB"),
+      secureCloudOnly: import_zod2.z.boolean().optional().describe("Filter to only GPUs available in secure cloud"),
+      communityCloudOnly: import_zod2.z.boolean().optional().describe("Filter to only GPUs available in community cloud"),
+      searchTerm: import_zod2.z.string().optional().describe(
         "Search term to filter GPUs by name (e.g., 'A100', 'RTX 4090')"
       ),
-      includeUnavailable: import_zod.z.boolean().optional().describe(
+      includeUnavailable: import_zod2.z.boolean().optional().describe(
         "Include GPUs that are currently out of stock. Default is false"
       )
     },
+    { title: "List GPU types", ...READ_ONLY },
     async (params) => {
-      const data = await graphqlRequest(
-        `
+      const backend = backendFor("gpus");
+      if (backend.version === "v2") {
+        const raw = await callRestUrl(`${backend.base}${backend.list}`);
+        let gpus = backend.unwrap(raw);
+        if (params.minMemoryGb !== void 0)
+          gpus = gpus.filter(
+            (g) => Number(g.memory ?? 0) >= params.minMemoryGb
+          );
+        if (params.secureCloudOnly) gpus = gpus.filter((g) => g.secure);
+        if (params.communityCloudOnly) gpus = gpus.filter((g) => g.community);
+        if (params.searchTerm) {
+          const t = params.searchTerm.toLowerCase();
+          gpus = gpus.filter(
+            (g) => String(g.id ?? "").toLowerCase().includes(t) || String(g.name ?? "").toLowerCase().includes(t)
+          );
+        }
+        return capListResult(gpus, {
+          limit: params.limit,
+          cursor: params.cursor
+        });
+      }
+      const data = await graphql(`
         query {
           gpuTypes {
             id
@@ -183,9 +1168,7 @@ function registerTools(server2, ctx) {
             }
           }
         }
-      `,
-        tracking
-      );
+      `);
       const stockPriority = {
         High: 3,
         Medium: 2,
@@ -231,26 +1214,39 @@ function registerTools(server2, ctx) {
         stockStatus: gpu.lowestPrice?.stockStatus || "unavailable",
         available: isAvailable(gpu)
       }));
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return capListResult(result, {
+        limit: params.limit,
+        cursor: params.cursor
+      });
     }
   );
-  server2.tool(
+  server.tool(
     "list-data-centers",
+    "List Runpod data centers (id, name, region/location). Use this to discover valid dataCenterIds for placing pods, endpoints, or network volumes.",
     {
-      region: import_zod.z.string().optional().describe(
+      ...listPaginationParams,
+      region: import_zod2.z.string().optional().describe(
         "Filter by region/location (e.g., 'United States', 'Europe', 'Canada')"
       )
     },
+    { title: "List data centers", ...READ_ONLY },
     async (params) => {
-      const data = await graphqlRequest(
-        `
+      const backend = backendFor("dataCenters");
+      if (backend.version === "v2") {
+        const raw = await callRestUrl(`${backend.base}${backend.list}`);
+        let dcs = backend.unwrap(raw);
+        if (params.region) {
+          const t = params.region.toLowerCase();
+          dcs = dcs.filter(
+            (dc) => String(dc.region ?? "").toLowerCase().includes(t)
+          );
+        }
+        return capListResult(dcs, {
+          limit: params.limit,
+          cursor: params.cursor
+        });
+      }
+      const data = await graphql(`
         query {
           dataCenters {
             id
@@ -258,9 +1254,7 @@ function registerTools(server2, ctx) {
             location
           }
         }
-      `,
-        tracking
-      );
+      `);
       let dataCenters = data.dataCenters;
       if (params.region) {
         const term = params.region.toLowerCase();
@@ -268,343 +1262,629 @@ function registerTools(server2, ctx) {
           (dc) => dc.location.toLowerCase().includes(term)
         );
       }
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(dataCenters, null, 2)
-          }
-        ]
-      };
+      return capListResult(dataCenters, {
+        limit: params.limit,
+        cursor: params.cursor
+      });
+    }
+  );
+  server.tool(
+    "list-cpu-types",
+    "List available CPU flavor types for CPU pods/endpoints. v2-only \u2014 returns a 501 notice on the v1 API.",
+    { ...listPaginationParams },
+    { title: "List CPU types", ...READ_ONLY },
+    async (params) => {
+      const backend = backendFor("cpus");
+      if (backend.version === "v1") {
+        return jsonReply2({
+          error: "list-cpu-types is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2.",
+          status: 501
+        });
+      }
+      const raw = await callRestUrl(`${backend.base}${backend.list}`);
+      return capListResult(backend.unwrap(raw), {
+        limit: params.limit,
+        cursor: params.cursor
+      });
+    }
+  );
+  server.tool(
+    "get-gpu-type",
+    "Get details for a single GPU type by id. v2-only \u2014 returns a 501 notice on the v1 API (use list-gpu-types there).",
+    {
+      gpuTypeId: import_zod2.z.string().describe("ID of the GPU type to retrieve")
+    },
+    { title: "Get GPU type", ...READ_ONLY },
+    async (params) => {
+      const backend = backendFor("gpus");
+      if (backend.version === "v1") {
+        return jsonReply2({
+          error: "get-gpu-type is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2 (or use list-gpu-types on v1).",
+          status: 501
+        });
+      }
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.gpuTypeId)}`
+      );
+      return jsonReply2(result);
+    }
+  );
+  server.tool(
+    "get-cpu-type",
+    "Get details for a single CPU flavor type by id. v2-only \u2014 returns a 501 notice on the v1 API (use list-cpu-types there).",
+    {
+      cpuTypeId: import_zod2.z.string().describe("ID of the CPU type to retrieve")
+    },
+    { title: "Get CPU type", ...READ_ONLY },
+    async (params) => {
+      const backend = backendFor("cpus");
+      if (backend.version === "v1") {
+        return jsonReply2({
+          error: "get-cpu-type is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2.",
+          status: 501
+        });
+      }
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.cpuTypeId)}`
+      );
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
+    "get-data-center",
+    "Get details for a single data center by id. v2-only \u2014 returns a 501 notice on the v1 API (use list-data-centers there).",
+    {
+      dataCenterId: import_zod2.z.string().describe("ID of the data center to retrieve")
+    },
+    { title: "Get data center", ...READ_ONLY },
+    async (params) => {
+      const backend = backendFor("dataCenters");
+      if (backend.version === "v1") {
+        return jsonReply2({
+          error: "get-data-center is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2.",
+          status: 501
+        });
+      }
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.dataCenterId)}`
+      );
+      return jsonReply2(result);
+    }
+  );
+}
+
+// src/tools/pods.ts
+var import_zod3 = require("zod");
+function registerPodTools(server, rt) {
+  const { jsonReply: jsonReply2, callRestUrl, backendFor, podAction, env } = rt;
+  server.tool(
     "list-pods",
+    "List your pods (running and stopped) with optional filters \u2014 compute type, GPU type, data center, name \u2014 plus machine/network-volume expansion. Paginated via limit/cursor.",
     {
-      computeType: import_zod.z.enum(["GPU", "CPU"]).optional().describe("Filter to only GPU or only CPU Pods"),
-      gpuTypeId: import_zod.z.array(import_zod.z.string()).optional().describe("Filter to Pods with any of the listed GPU types"),
-      dataCenterId: import_zod.z.array(import_zod.z.string()).optional().describe("Filter to Pods in any of the provided data centers"),
-      name: import_zod.z.string().optional().describe("Filter to Pods with the provided name"),
-      includeMachine: import_zod.z.boolean().optional().describe("Include information about the machine"),
-      includeNetworkVolume: import_zod.z.boolean().optional().describe("Include information about attached network volumes")
+      ...listPaginationParams,
+      computeType: import_zod3.z.enum(["GPU", "CPU"]).optional().describe("Filter to only GPU or only CPU Pods"),
+      gpuTypeId: import_zod3.z.array(import_zod3.z.string()).optional().describe("Filter to Pods with any of the listed GPU types"),
+      dataCenterId: import_zod3.z.array(import_zod3.z.string()).optional().describe("Filter to Pods in any of the provided data centers"),
+      name: import_zod3.z.string().optional().describe("Filter to Pods with the provided name"),
+      includeMachine: import_zod3.z.boolean().optional().describe("Include information about the machine"),
+      includeNetworkVolume: import_zod3.z.boolean().optional().describe("Include information about attached network volumes")
     },
+    { title: "List pods", ...READ_ONLY },
     async (params) => {
-      const queryParams = new URLSearchParams();
-      if (params.computeType)
-        queryParams.append("computeType", params.computeType);
-      if (params.gpuTypeId)
-        params.gpuTypeId.forEach(
-          (type) => queryParams.append("gpuTypeId", type)
-        );
-      if (params.dataCenterId)
-        params.dataCenterId.forEach(
-          (dc) => queryParams.append("dataCenterId", dc)
-        );
-      if (params.name) queryParams.append("name", params.name);
-      if (params.includeMachine)
-        queryParams.append("includeMachine", params.includeMachine.toString());
-      if (params.includeNetworkVolume)
-        queryParams.append(
-          "includeNetworkVolume",
-          params.includeNetworkVolume.toString()
-        );
-      const queryString = queryParams.toString() ? `?${queryParams.toString()}` : "";
-      const result = await runpodRequest(`/pods${queryString}`);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      const backend = backendFor("pods");
+      let queryString = "";
+      if (backend.version === "v1") {
+        const queryParams = new URLSearchParams();
+        if (params.computeType)
+          queryParams.append("computeType", params.computeType);
+        if (params.gpuTypeId)
+          params.gpuTypeId.forEach(
+            (type) => queryParams.append("gpuTypeId", type)
+          );
+        if (params.dataCenterId)
+          params.dataCenterId.forEach(
+            (dc) => queryParams.append("dataCenterId", dc)
+          );
+        if (params.name) queryParams.append("name", params.name);
+        if (params.includeMachine)
+          queryParams.append(
+            "includeMachine",
+            params.includeMachine.toString()
+          );
+        if (params.includeNetworkVolume)
+          queryParams.append(
+            "includeNetworkVolume",
+            params.includeNetworkVolume.toString()
+          );
+        queryString = queryParams.toString() ? `?${queryParams.toString()}` : "";
+      }
+      const result = await callRestUrl(
+        `${backend.base}${backend.list}${queryString}`
+      );
+      return capListResult(backend.unwrap(result), {
+        limit: params.limit,
+        cursor: params.cursor
+      });
     }
   );
-  server2.tool(
+  server.tool(
     "get-pod",
+    "Get full details for one pod by id, optionally expanding machine and attached network-volume info.",
     {
-      podId: import_zod.z.string().describe("ID of the pod to retrieve"),
-      includeMachine: import_zod.z.boolean().optional().describe("Include information about the machine"),
-      includeNetworkVolume: import_zod.z.boolean().optional().describe("Include information about attached network volumes")
+      podId: import_zod3.z.string().describe("ID of the pod to retrieve"),
+      includeMachine: import_zod3.z.boolean().optional().describe("Include information about the machine"),
+      includeNetworkVolume: import_zod3.z.boolean().optional().describe("Include information about attached network volumes")
     },
+    { title: "Get pod", ...READ_ONLY },
     async (params) => {
-      const queryParams = new URLSearchParams();
-      if (params.includeMachine)
-        queryParams.append("includeMachine", params.includeMachine.toString());
-      if (params.includeNetworkVolume)
-        queryParams.append(
-          "includeNetworkVolume",
-          params.includeNetworkVolume.toString()
-        );
-      const queryString = queryParams.toString() ? `?${queryParams.toString()}` : "";
-      const result = await runpodRequest(`/pods/${params.podId}${queryString}`);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      const backend = backendFor("pods");
+      let queryString = "";
+      if (backend.version === "v1") {
+        const queryParams = new URLSearchParams();
+        if (params.includeMachine)
+          queryParams.append(
+            "includeMachine",
+            params.includeMachine.toString()
+          );
+        if (params.includeNetworkVolume)
+          queryParams.append(
+            "includeNetworkVolume",
+            params.includeNetworkVolume.toString()
+          );
+        queryString = queryParams.toString() ? `?${queryParams.toString()}` : "";
+      }
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.podId)}${queryString}`
+      );
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "create-pod",
-    'Create a new GPU/CPU pod on Runpod. If the user does not specify an image, 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). If the user does not specify an image, 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_zod.z.string().optional().describe("Name for the pod"),
-      imageName: import_zod.z.string().describe("Docker image to use"),
-      cloudType: import_zod.z.enum(["SECURE", "COMMUNITY"]).optional().describe("SECURE or COMMUNITY cloud"),
-      gpuTypeIds: import_zod.z.array(import_zod.z.string()).optional().describe("List of acceptable GPU types"),
-      gpuCount: import_zod.z.number().optional().describe("Number of GPUs"),
-      containerDiskInGb: import_zod.z.number().optional().describe("Container disk size in GB"),
-      volumeInGb: import_zod.z.number().optional().describe("Volume size in GB"),
-      volumeMountPath: import_zod.z.string().optional().describe("Path to mount the volume"),
-      ports: import_zod.z.array(import_zod.z.string()).optional().describe("Ports to expose (e.g., '8888/http', '22/tcp')"),
-      env: import_zod.z.record(import_zod.z.string()).optional().describe("Environment variables"),
-      dataCenterIds: import_zod.z.array(import_zod.z.string()).optional().describe("List of data centers")
+      name: import_zod3.z.string().optional().describe("Name for the pod"),
+      imageName: import_zod3.z.string().describe("Docker image to use"),
+      computeType: import_zod3.z.enum(["GPU", "CPU"]).optional().describe(
+        "Pod type. On v2, required when not passing gpuTypeIds. 'CPU' is served by the v1 API for now (v2 has no CPU pods yet)."
+      ),
+      cloudType: import_zod3.z.enum(["SECURE", "COMMUNITY"]).optional().describe("SECURE or COMMUNITY cloud"),
+      gpuTypeIds: import_zod3.z.array(import_zod3.z.string()).optional().describe("List of acceptable GPU types"),
+      gpuCount: import_zod3.z.number().optional().describe("Number of GPUs"),
+      containerDiskInGb: import_zod3.z.number().optional().describe("Container disk size in GB"),
+      volumeInGb: import_zod3.z.number().optional().describe("Volume size in GB"),
+      volumeMountPath: import_zod3.z.string().optional().describe("Path to mount the volume"),
+      ports: import_zod3.z.array(import_zod3.z.string()).optional().describe("Ports to expose (e.g., '8888/http', '22/tcp')"),
+      env: import_zod3.z.record(import_zod3.z.string()).optional().describe("Environment variables"),
+      dataCenterIds: import_zod3.z.array(import_zod3.z.string()).optional().describe("List of data centers")
     },
+    { title: "Create pod", ...WRITE },
     async (params) => {
-      const result = await runpodRequest("/pods", "POST", params);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
+      const backend = backendFor("pods");
+      const hasGpuTypes = (params.gpuTypeIds?.length ?? 0) > 0;
+      const hasGpuCount = (params.gpuCount ?? 0) > 0;
+      const wantsCpu = params.computeType === "CPU";
+      const wantsGpu = hasGpuTypes || hasGpuCount || params.computeType === "GPU";
+      if (backend.version === "v2") {
+        if (wantsGpu && wantsCpu) {
+          return jsonReply2({
+            error: "Specify a GPU pod (gpuTypeIds or computeType:'GPU') OR a CPU pod (computeType:'CPU'), not both.",
+            status: 400
+          });
+        }
+        if (!wantsGpu && !wantsCpu) {
+          return jsonReply2({
+            error: "No pod type specified. Pass gpuTypeIds (see list-gpu-types) for a GPU pod, or computeType:'CPU' for a CPU pod.",
+            status: 400
+          });
+        }
+        if (wantsGpu && !hasGpuTypes) {
+          return jsonReply2({
+            error: "A GPU pod needs gpuTypeIds (see list-gpu-types); gpuCount or computeType alone is under-specified.",
+            status: 400
+          });
+        }
+        if (wantsCpu) {
+          try {
+            const result = await callRestUrl(
+              `${restV1Base(env)}/pods`,
+              "POST",
+              params
+            );
+            return jsonReply2({
+              ...result,
+              _servedBy: "v1",
+              _note: "CPU pod: created on the v1 API, because the v2 REST API does not support CPU pods yet."
+            });
+          } catch (error) {
+            if (error instanceof HttpError) {
+              return jsonReply2({
+                error: error.message,
+                status: error.status,
+                _servedBy: "v1",
+                _note: "CPU pod create was routed to the v1 API and failed."
+              });
+            }
+            throw error;
           }
-        ]
-      };
+        }
+      }
+      const body = backend.mapCreate(params);
+      try {
+        const result = await callRestUrl(
+          `${backend.base}${backend.list}`,
+          "POST",
+          body
+        );
+        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(", ")}.`
+          });
+        }
+        return jsonReply2(result);
+      } catch (error) {
+        if (error instanceof HttpError && error.status === 501) {
+          return jsonReply2({
+            error: "CPU pods are not yet supported on the v2 REST API. Use a GPU pod, or create the CPU pod via the v1 API (set RUNPOD_REST_VERSION=v1).",
+            status: 501
+          });
+        }
+        throw error;
+      }
     }
   );
-  server2.tool(
+  server.tool(
     "update-pod",
+    "Update a pod's mutable fields (name, image, container disk, volume, ports, env). Only the fields you provide change.",
     {
-      podId: import_zod.z.string().describe("ID of the pod to update"),
-      name: import_zod.z.string().optional().describe("New name for the pod"),
-      imageName: import_zod.z.string().optional().describe("New Docker image"),
-      containerDiskInGb: import_zod.z.number().optional().describe("New container disk size in GB"),
-      volumeInGb: import_zod.z.number().optional().describe("New volume size in GB"),
-      volumeMountPath: import_zod.z.string().optional().describe("New path to mount the volume"),
-      ports: import_zod.z.array(import_zod.z.string()).optional().describe("New ports to expose"),
-      env: import_zod.z.record(import_zod.z.string()).optional().describe("New environment variables")
+      podId: import_zod3.z.string().describe("ID of the pod to update"),
+      name: import_zod3.z.string().optional().describe("New name for the pod"),
+      imageName: import_zod3.z.string().optional().describe("New Docker image"),
+      containerDiskInGb: import_zod3.z.number().optional().describe("New container disk size in GB"),
+      volumeInGb: import_zod3.z.number().optional().describe("New volume size in GB"),
+      volumeMountPath: import_zod3.z.string().optional().describe("New path to mount the volume"),
+      ports: import_zod3.z.array(import_zod3.z.string()).optional().describe("New ports to expose"),
+      env: import_zod3.z.record(import_zod3.z.string()).optional().describe("New environment variables")
     },
+    { title: "Update pod", ...WRITE, idempotentHint: true },
     async (params) => {
       const { podId, ...updateParams } = params;
-      const result = await runpodRequest(
-        `/pods/${podId}`,
+      const backend = backendFor("pods");
+      const body = backend.mapUpdate(updateParams);
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(podId)}`,
         "PATCH",
-        updateParams
+        body
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "start-pod",
+    "Start a stopped pod (resumes the same pod and its billing).",
     {
-      podId: import_zod.z.string().describe("ID of the pod to start")
+      podId: import_zod3.z.string().describe("ID of the pod to start")
     },
+    { title: "Start pod", ...WRITE, idempotentHint: true },
     async (params) => {
-      const result = await runpodRequest(`/pods/${params.podId}/start`, "POST");
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      const result = await podAction(params.podId, "start");
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "stop-pod",
+    "Stop a running pod. The pod and its disk persist; GPU billing stops.",
     {
-      podId: import_zod.z.string().describe("ID of the pod to stop")
+      podId: import_zod3.z.string().describe("ID of the pod to stop")
     },
+    { title: "Stop pod", ...WRITE, idempotentHint: true },
     async (params) => {
-      const result = await runpodRequest(`/pods/${params.podId}/stop`, "POST");
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      const result = await podAction(params.podId, "stop");
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
+    "restart-pod",
+    "Restart a running pod (single PodAction call). v2-only \u2014 on the v1 API returns a 501 notice (stop then start the pod instead).",
+    {
+      podId: import_zod3.z.string().describe("ID of the pod to restart")
+    },
+    { title: "Restart pod", ...WRITE },
+    async (params) => {
+      const backend = backendFor("pods");
+      if (backend.version === "v1") {
+        return jsonReply2({
+          error: "restart-pod is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2 (or stop then start the pod on v1).",
+          status: 501
+        });
+      }
+      const result = await podAction(params.podId, "restart");
+      return jsonReply2(result);
+    }
+  );
+  server.tool(
     "delete-pod",
+    "Permanently delete a pod and its data. This cannot be undone.",
     {
-      podId: import_zod.z.string().describe("ID of the pod to delete")
+      podId: import_zod3.z.string().describe("ID of the pod to delete")
     },
+    { title: "Delete pod", ...DESTRUCTIVE },
     async (params) => {
-      const result = await runpodRequest(`/pods/${params.podId}`, "DELETE");
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      const backend = backendFor("pods");
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.podId)}`,
+        "DELETE"
+      );
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+}
+
+// src/tools/endpoints.ts
+var import_zod4 = require("zod");
+function registerEndpointTools(server, rt) {
+  const { jsonReply: jsonReply2, callRestUrl, backendFor } = rt;
+  server.tool(
     "list-endpoints",
+    "List your Serverless endpoints, optionally expanding template and worker details (v1 only). Paginated via limit/cursor.",
     {
-      includeTemplate: import_zod.z.boolean().optional().describe("Include template information"),
-      includeWorkers: import_zod.z.boolean().optional().describe("Include information about workers")
+      ...listPaginationParams,
+      includeTemplate: import_zod4.z.boolean().optional().describe("Include template information (v1 only)"),
+      includeWorkers: import_zod4.z.boolean().optional().describe("Include information about workers (v1 only)")
     },
+    { title: "List endpoints", ...READ_ONLY },
     async (params) => {
-      const queryParams = new URLSearchParams();
-      if (params.includeTemplate)
-        queryParams.append(
-          "includeTemplate",
-          params.includeTemplate.toString()
-        );
-      if (params.includeWorkers)
-        queryParams.append("includeWorkers", params.includeWorkers.toString());
-      const queryString = queryParams.toString() ? `?${queryParams.toString()}` : "";
-      const result = await runpodRequest(`/endpoints${queryString}`);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      const backend = backendFor("endpoints");
+      let queryString = "";
+      if (backend.version === "v1") {
+        const queryParams = new URLSearchParams();
+        if (params.includeTemplate)
+          queryParams.append(
+            "includeTemplate",
+            params.includeTemplate.toString()
+          );
+        if (params.includeWorkers)
+          queryParams.append(
+            "includeWorkers",
+            params.includeWorkers.toString()
+          );
+        queryString = queryParams.toString() ? `?${queryParams.toString()}` : "";
+      }
+      const result = await callRestUrl(
+        `${backend.base}${backend.list}${queryString}`
+      );
+      return capListResult(backend.unwrap(result), {
+        limit: params.limit,
+        cursor: params.cursor
+      });
     }
   );
-  server2.tool(
+  server.tool(
     "get-endpoint",
+    "Get one Serverless endpoint by id, optionally expanding template and worker details (v1 only).",
     {
-      endpointId: import_zod.z.string().describe("ID of the endpoint to retrieve"),
-      includeTemplate: import_zod.z.boolean().optional().describe("Include template information"),
-      includeWorkers: import_zod.z.boolean().optional().describe("Include information about workers")
+      endpointId: import_zod4.z.string().describe("ID of the endpoint to retrieve"),
+      includeTemplate: import_zod4.z.boolean().optional().describe("Include template information (v1 only)"),
+      includeWorkers: import_zod4.z.boolean().optional().describe("Include information about workers (v1 only)")
     },
+    { title: "Get endpoint", ...READ_ONLY },
     async (params) => {
-      const queryParams = new URLSearchParams();
-      if (params.includeTemplate)
-        queryParams.append(
-          "includeTemplate",
-          params.includeTemplate.toString()
-        );
-      if (params.includeWorkers)
-        queryParams.append("includeWorkers", params.includeWorkers.toString());
-      const queryString = queryParams.toString() ? `?${queryParams.toString()}` : "";
-      const result = await runpodRequest(
-        `/endpoints/${params.endpointId}${queryString}`
+      const backend = backendFor("endpoints");
+      let queryString = "";
+      if (backend.version === "v1") {
+        const queryParams = new URLSearchParams();
+        if (params.includeTemplate)
+          queryParams.append(
+            "includeTemplate",
+            params.includeTemplate.toString()
+          );
+        if (params.includeWorkers)
+          queryParams.append(
+            "includeWorkers",
+            params.includeWorkers.toString()
+          );
+        queryString = queryParams.toString() ? `?${queryParams.toString()}` : "";
+      }
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.endpointId)}${queryString}`
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "create-endpoint",
+    "Create a Serverless endpoint. On v2 (default), pass an inline config: imageName + gpuPoolIds (GPU pool names from list-gpu-types \u2014 the `pool` field, e.g. AMPERE_80/ADA_24) plus optional workers/scaling/disk/env. On v1, pass a templateId instead. Worker min/max set autoscaling bounds (min 0 = scale to zero).",
     {
-      name: import_zod.z.string().optional().describe("Name for the endpoint"),
-      templateId: import_zod.z.string().describe("Template ID to use"),
-      computeType: import_zod.z.enum(["GPU", "CPU"]).optional().describe("GPU or CPU endpoint"),
-      gpuTypeIds: import_zod.z.array(import_zod.z.string()).optional().describe("List of acceptable GPU types"),
-      gpuCount: import_zod.z.number().optional().describe("Number of GPUs per worker"),
-      workersMin: import_zod.z.number().optional().describe("Minimum number of workers"),
-      workersMax: import_zod.z.number().optional().describe("Maximum number of workers"),
-      dataCenterIds: import_zod.z.array(import_zod.z.string()).optional().describe("List of data centers")
+      name: import_zod4.z.string().optional().describe("Name for the endpoint"),
+      // --- v2 inline-config fields ---
+      imageName: import_zod4.z.string().optional().describe("Docker image (v2). Required on v2 instead of a templateId."),
+      gpuPoolIds: import_zod4.z.array(import_zod4.z.string()).optional().describe(
+        'GPU pool names (v2, required). The `pool` field from list-gpu-types, e.g. ["AMPERE_80"]. NOT GPU type ids.'
+      ),
+      gpuCount: import_zod4.z.number().optional().describe("GPUs per worker (v2)"),
+      args: import_zod4.z.string().optional().describe("Container start command/args (v2)"),
+      containerDiskInGb: import_zod4.z.number().optional().describe("Container disk size in GB (v2)"),
+      ports: import_zod4.z.array(import_zod4.z.string()).optional().describe("Ports to expose (v2), e.g. ['8000/http']"),
+      env: import_zod4.z.record(import_zod4.z.string()).optional().describe("Environment variables (v2)"),
+      containerRegistryAuthId: import_zod4.z.string().optional().describe("Container registry auth id for a private image (v2)"),
+      networkVolumeIds: import_zod4.z.array(import_zod4.z.string()).optional().describe("Network volume ids to attach (v2)"),
+      executionTimeoutMs: import_zod4.z.number().optional().describe("Per-job execution timeout in ms (v2)"),
+      flashboot: import_zod4.z.enum(["OFF", "FLASHBOOT", "PRIORITY_FLASHBOOT"]).optional().describe("FlashBoot mode (v2)"),
+      // --- v1 template-based fields ---
+      templateId: import_zod4.z.string().optional().describe("Template ID (v1). Required on v1."),
+      computeType: import_zod4.z.enum(["GPU", "CPU"]).optional().describe("GPU or CPU endpoint (v1)"),
+      gpuTypeIds: import_zod4.z.array(import_zod4.z.string()).optional().describe("List of acceptable GPU types (v1)"),
+      // --- shared autoscaling fields ---
+      workersMin: import_zod4.z.number().optional().describe("Minimum number of workers"),
+      workersMax: import_zod4.z.number().optional().describe("Maximum number of workers"),
+      scalerType: import_zod4.z.enum(["QUEUE_DELAY", "REQUEST_COUNT"]).optional().describe("Autoscaler type"),
+      scalerValue: import_zod4.z.number().optional().describe("Autoscaler target value"),
+      idleTimeout: import_zod4.z.number().optional().describe("Idle timeout in seconds before scaling a worker down"),
+      dataCenterIds: import_zod4.z.array(import_zod4.z.string()).optional().describe("List of preferred data centers")
     },
+    { title: "Create endpoint", ...WRITE },
     async (params) => {
-      const result = await runpodRequest("/endpoints", "POST", params);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      const backend = backendFor("endpoints");
+      if (backend.version === "v2") {
+        if (!params.name) {
+          return jsonReply2({
+            error: "On the v2 REST API, create-endpoint requires a name.",
+            status: 400
+          });
+        }
+        if (!params.imageName) {
+          return jsonReply2({
+            error: "On the v2 REST API, create-endpoint needs an imageName (v2 endpoints are image-based, not template-based). To use a templateId, set RUNPOD_REST_VERSION=v1.",
+            status: 400
+          });
+        }
+        if (!params.gpuPoolIds?.length) {
+          return jsonReply2({
+            error: 'create-endpoint needs gpuPoolIds on v2 (GPU pool names from list-gpu-types \u2014 the `pool` field, e.g. ["AMPERE_80"]).',
+            status: 400
+          });
+        }
+        const body = backend.mapCreate(params);
+        const result2 = await callRestUrl(
+          `${backend.base}${backend.list}`,
+          "POST",
+          body
+        );
+        return jsonReply2(result2);
+      }
+      if (!params.templateId) {
+        return jsonReply2({
+          error: "On the v1 REST API, create-endpoint needs a templateId. (On v2 \u2014 the default \u2014 pass imageName + gpuPoolIds instead.)",
+          status: 400
+        });
+      }
+      const v1Body = {};
+      for (const k of [
+        "templateId",
+        "name",
+        "computeType",
+        "gpuTypeIds",
+        "gpuCount",
+        "workersMin",
+        "workersMax",
+        "dataCenterIds"
+      ]) {
+        if (params[k] !== void 0) v1Body[k] = params[k];
+      }
+      const result = await callRestUrl(
+        `${backend.base}${backend.list}`,
+        "POST",
+        v1Body
+      );
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  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.",
     {
-      endpointId: import_zod.z.string().describe("ID of the endpoint to update"),
-      name: import_zod.z.string().optional().describe("New name for the endpoint"),
-      workersMin: import_zod.z.number().optional().describe("New minimum number of workers"),
-      workersMax: import_zod.z.number().optional().describe("New maximum number of workers"),
-      idleTimeout: import_zod.z.number().optional().describe("New idle timeout in seconds"),
-      scalerType: import_zod.z.enum(["QUEUE_DELAY", "REQUEST_COUNT"]).optional().describe("Scaler type"),
-      scalerValue: import_zod.z.number().optional().describe("Scaler value")
+      endpointId: import_zod4.z.string().describe("ID of the endpoint to update"),
+      name: import_zod4.z.string().optional().describe("New name for the endpoint"),
+      workersMin: import_zod4.z.number().optional().describe("New minimum number of workers"),
+      workersMax: import_zod4.z.number().optional().describe("New maximum number of workers"),
+      idleTimeout: import_zod4.z.number().optional().describe("New idle timeout in seconds"),
+      scalerType: import_zod4.z.enum(["QUEUE_DELAY", "REQUEST_COUNT"]).optional().describe("Scaler type"),
+      scalerValue: import_zod4.z.number().optional().describe("Scaler value"),
+      // --- v2-only inline-config fields ---
+      imageName: import_zod4.z.string().optional().describe("New Docker image (v2)"),
+      gpuPoolIds: import_zod4.z.array(import_zod4.z.string()).optional().describe('New GPU pool names (v2), e.g. ["AMPERE_80"]'),
+      gpuCount: import_zod4.z.number().optional().describe("New GPUs per worker (v2)"),
+      args: import_zod4.z.string().optional().describe("New container args (v2)"),
+      containerDiskInGb: import_zod4.z.number().optional().describe("New container disk size in GB (v2)"),
+      ports: import_zod4.z.array(import_zod4.z.string()).optional().describe("New ports (v2)"),
+      env: import_zod4.z.record(import_zod4.z.string()).optional().describe("New environment variables (v2)"),
+      containerRegistryAuthId: import_zod4.z.string().optional().describe("New container registry auth id (v2)"),
+      networkVolumeIds: import_zod4.z.array(import_zod4.z.string()).optional().describe("New network volume ids (v2)"),
+      executionTimeoutMs: import_zod4.z.number().optional().describe("New per-job execution timeout in ms (v2)"),
+      flashboot: import_zod4.z.enum(["OFF", "FLASHBOOT", "PRIORITY_FLASHBOOT"]).optional().describe("New FlashBoot mode (v2)")
     },
+    { title: "Update endpoint", ...WRITE, idempotentHint: true },
     async (params) => {
       const { endpointId, ...updateParams } = params;
-      const result = await runpodRequest(
-        `/endpoints/${endpointId}`,
+      const backend = backendFor("endpoints");
+      const body = backend.mapUpdate(updateParams);
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(endpointId)}`,
         "PATCH",
-        updateParams
+        body
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "delete-endpoint",
+    "Permanently delete a Serverless endpoint. This cannot be undone.",
     {
-      endpointId: import_zod.z.string().describe("ID of the endpoint to delete")
+      endpointId: import_zod4.z.string().describe("ID of the endpoint to delete")
     },
+    { title: "Delete endpoint", ...DESTRUCTIVE },
     async (params) => {
-      const result = await runpodRequest(
-        `/endpoints/${params.endpointId}`,
+      const backend = backendFor("endpoints");
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.endpointId)}`,
         "DELETE"
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
+    }
+  );
+  server.tool(
+    "list-endpoint-workers",
+    "List the workers backing a Serverless endpoint, with their status and an aggregate summary. v2-only \u2014 returns a 501 notice on the v1 API. Paginated via limit/cursor.",
+    {
+      ...listPaginationParams,
+      endpointId: import_zod4.z.string().describe("ID of the Serverless endpoint whose workers to list")
+    },
+    { title: "List endpoint workers", ...READ_ONLY },
+    async (params) => {
+      const backend = backendFor("workers");
+      if (backend.version === "v1") {
+        return jsonReply2({
+          error: "list-endpoint-workers is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2 (on v1, use get-endpoint with includeWorkers).",
+          status: 501
+        });
+      }
+      const raw = await callRestUrl(
+        `${backend.base}/serverless/${params.endpointId}/workers`
+      );
+      return capListResult(
+        backend.unwrap(raw),
+        { limit: params.limit, cursor: params.cursor },
+        { summary: raw?.summary, endpointVersion: raw?.endpointVersion }
+      );
     }
   );
-  const endpointIdSchema = import_zod.z.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid endpoint ID format");
-  const jobIdSchema = import_zod.z.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid job ID format");
-  const inputSchema = import_zod.z.record(import_zod.z.unknown()).describe(
+}
+
+// src/tools/jobs.ts
+var import_zod5 = require("zod");
+function registerJobTools(server, rt) {
+  const { jsonReply: jsonReply2, serverlessRequest } = rt;
+  const endpointIdSchema = import_zod5.z.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid endpoint ID format");
+  const jobIdSchema = import_zod5.z.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid job ID format");
+  const inputSchema = import_zod5.z.record(import_zod5.z.unknown()).describe(
     "Input payload for the worker handler. The expected fields depend on the deployed model or worker."
   );
-  const webhookSchema = import_zod.z.string().url().optional().describe(
+  const webhookSchema = import_zod5.z.string().url().optional().describe(
     "Webhook URL to receive job completion notifications instead of polling"
   );
-  const policySchema = import_zod.z.object({
-    executionTimeout: import_zod.z.number().optional().describe("Maximum execution time in milliseconds"),
-    lowPriority: import_zod.z.boolean().optional().describe("Submit as a low-priority job"),
-    ttl: import_zod.z.number().optional().describe("Time-to-live for the job result in milliseconds")
+  const policySchema = import_zod5.z.object({
+    executionTimeout: import_zod5.z.number().optional().describe("Maximum execution time in milliseconds"),
+    lowPriority: import_zod5.z.boolean().optional().describe("Submit as a low-priority job"),
+    ttl: import_zod5.z.number().optional().describe("Time-to-live for the job result in milliseconds")
   }).optional().describe("Execution policy options");
-  const s3ConfigSchema = import_zod.z.object({
-    accessId: import_zod.z.string().describe("S3 access key ID"),
-    accessSecret: import_zod.z.string().describe("S3 secret access key"),
-    bucketName: import_zod.z.string().describe("S3 bucket name"),
-    endpointUrl: import_zod.z.string().describe("S3 endpoint URL")
+  const s3ConfigSchema = import_zod5.z.object({
+    accessId: import_zod5.z.string().describe("S3 access key ID"),
+    accessSecret: import_zod5.z.string().describe("S3 secret access key"),
+    bucketName: import_zod5.z.string().describe("S3 bucket name"),
+    endpointUrl: import_zod5.z.string().describe("S3 endpoint URL")
   }).optional().describe("S3-compatible storage config for large outputs");
-  server2.tool(
+  server.tool(
     "run-endpoint",
     "Submit an asynchronous job to a Serverless endpoint. Returns a job ID immediately \u2014 use get-job-status to poll for results. Async results are available for 30 minutes after completion.",
     {
@@ -616,6 +1896,7 @@ function registerTools(server2, ctx) {
       policy: policySchema,
       s3Config: s3ConfigSchema
     },
+    { title: "Run endpoint (async)", ...WRITE },
     async (params) => {
       const { endpointId, ...body } = params;
       const result = await serverlessRequest(
@@ -624,17 +1905,10 @@ function registerTools(server2, ctx) {
         "POST",
         body
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  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).",
     {
@@ -642,33 +1916,27 @@ function registerTools(server2, ctx) {
         "ID of the Serverless endpoint to run synchronously"
       ),
       input: inputSchema,
-      wait: import_zod.z.number().min(1e3).max(3e5).optional().describe(
+      wait: import_zod5.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)."
       ),
       webhook: webhookSchema,
       policy: policySchema,
       s3Config: s3ConfigSchema
     },
+    { title: "Run endpoint (sync)", ...WRITE },
     async (params) => {
       const { endpointId, wait, ...body } = params;
-      const path = wait ? `/runsync?wait=${wait}` : "/runsync";
+      const path2 = wait ? `/runsync?wait=${wait}` : "/runsync";
       const result = await serverlessRequest(
         endpointId,
-        path,
+        path2,
         "POST",
         body
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "get-job-status",
     "Check the status of an asynchronous Serverless job. Returns the current status and output when complete. Job statuses: IN_QUEUE, IN_PROGRESS, COMPLETED, FAILED, CANCELLED, TIMED_OUT.",
     {
@@ -677,22 +1945,16 @@ function registerTools(server2, ctx) {
       ),
       jobId: jobIdSchema.describe("ID of the job to check")
     },
+    { title: "Get job status", ...READ_ONLY },
     async (params) => {
       const result = await serverlessRequest(
         params.endpointId,
         `/status/${params.jobId}`
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  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.",
     {
@@ -701,6 +1963,7 @@ function registerTools(server2, ctx) {
       ),
       jobId: jobIdSchema.describe("ID of the job to stream results from")
     },
+    { title: "Stream job", ...READ_ONLY },
     async (params) => {
       const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
         "COMPLETED",
@@ -746,21 +2009,10 @@ function registerTools(server2, ctx) {
         }
         await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
       }
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              { ...finalResult, stream: allChunks },
-              null,
-              2
-            )
-          }
-        ]
-      };
+      return jsonReply2({ ...finalResult, stream: allChunks });
     }
   );
-  server2.tool(
+  server.tool(
     "cancel-job",
     "Cancel a Serverless job that is queued or in progress.",
     {
@@ -769,23 +2021,17 @@ function registerTools(server2, ctx) {
       ),
       jobId: jobIdSchema.describe("ID of the job to cancel")
     },
+    { title: "Cancel job", ...WRITE, idempotentHint: true },
     async (params) => {
       const result = await serverlessRequest(
         params.endpointId,
         `/cancel/${params.jobId}`,
         "POST"
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "retry-job",
     "Retry a failed or timed-out Serverless job. Only works for jobs with FAILED or TIMED_OUT status. The previous output is removed and the job is requeued.",
     {
@@ -794,23 +2040,17 @@ function registerTools(server2, ctx) {
       ),
       jobId: jobIdSchema.describe("ID of the job to retry")
     },
+    { title: "Retry job", ...WRITE },
     async (params) => {
       const result = await serverlessRequest(
         params.endpointId,
         `/retry/${params.jobId}`,
         "POST"
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "endpoint-health",
     "Get the health and operational status of a Serverless endpoint, including worker counts and job statistics.",
     {
@@ -818,19 +2058,13 @@ function registerTools(server2, ctx) {
         "ID of the Serverless endpoint to check health for"
       )
     },
+    { title: "Endpoint health", ...READ_ONLY },
     async (params) => {
       const result = await serverlessRequest(params.endpointId, "/health");
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "purge-endpoint-queue",
     "Remove all pending jobs from a Serverless endpoint queue. Only affects queued jobs \u2014 in-progress jobs continue running. Use this for error recovery or clearing outdated requests.",
     {
@@ -838,321 +2072,594 @@ function registerTools(server2, ctx) {
         "ID of the Serverless endpoint to purge the queue for"
       )
     },
+    { title: "Purge endpoint queue", ...WRITE, idempotentHint: true },
     async (params) => {
       const result = await serverlessRequest(
         params.endpointId,
         "/purge-queue",
         "POST"
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+}
+
+// src/tools/templates.ts
+var import_zod6 = require("zod");
+function registerTemplateTools(server, rt) {
+  const { jsonReply: jsonReply2, callRestUrl, backendFor } = rt;
+  server.tool(
     "list-templates",
     `List available templates. By default returns only the user's own templates. Use includeRunpodTemplates to also include official Runpod templates. The recommended default template for new pods is "Runpod Pytorch 2.8.0" (ID: runpod-torch-v280) \u2014 it has the latest CUDA and PyTorch versions.`,
     {
-      includeRunpodTemplates: import_zod.z.boolean().optional().describe("Include official Runpod templates in the response"),
-      includePublicTemplates: import_zod.z.boolean().optional().describe("Include community-made public templates in the response"),
-      includeEndpointBoundTemplates: import_zod.z.boolean().optional().describe(
+      ...listPaginationParams,
+      includeRunpodTemplates: import_zod6.z.boolean().optional().describe("Include official Runpod templates in the response"),
+      includePublicTemplates: import_zod6.z.boolean().optional().describe("Include community-made public templates in the response"),
+      includeEndpointBoundTemplates: import_zod6.z.boolean().optional().describe(
         "Include templates bound to Serverless endpoints in the response"
       )
     },
+    { title: "List templates", ...READ_ONLY },
     async (params) => {
-      const queryParams = new URLSearchParams();
-      if (params.includeRunpodTemplates)
-        queryParams.set("includeRunpodTemplates", "true");
-      if (params.includePublicTemplates)
-        queryParams.set("includePublicTemplates", "true");
-      if (params.includeEndpointBoundTemplates)
-        queryParams.set("includeEndpointBoundTemplates", "true");
-      const query = queryParams.toString();
-      const result = await runpodRequest(
-        `/templates${query ? `?${query}` : ""}`
+      const backend = backendFor("templates");
+      let query = "";
+      if (backend.version === "v1") {
+        const queryParams = new URLSearchParams();
+        if (params.includeRunpodTemplates)
+          queryParams.set("includeRunpodTemplates", "true");
+        if (params.includePublicTemplates)
+          queryParams.set("includePublicTemplates", "true");
+        if (params.includeEndpointBoundTemplates)
+          queryParams.set("includeEndpointBoundTemplates", "true");
+        query = queryParams.toString() ? `?${queryParams.toString()}` : "";
+      }
+      const result = await callRestUrl(
+        `${backend.base}${backend.list}${query}`
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return capListResult(backend.unwrap(result), {
+        limit: params.limit,
+        cursor: params.cursor
+      });
     }
   );
-  server2.tool(
+  server.tool(
     "get-template",
+    "Get one template by id (image, env, ports, disk/volume config).",
     {
-      templateId: import_zod.z.string().describe("ID of the template to retrieve")
+      templateId: import_zod6.z.string().describe("ID of the template to retrieve")
     },
+    { title: "Get template", ...READ_ONLY },
     async (params) => {
-      const result = await runpodRequest(`/templates/${params.templateId}`);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      const backend = backendFor("templates");
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.templateId)}`
+      );
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "create-template",
+    "Create a reusable pod/endpoint template (image, ports, env, disk/volume). On v2 a category is required and defaults to NVIDIA.",
     {
-      name: import_zod.z.string().describe("Name for the template"),
-      imageName: import_zod.z.string().describe("Docker image to use"),
-      isServerless: import_zod.z.boolean().optional().describe("Is this a serverless template"),
-      ports: import_zod.z.array(import_zod.z.string()).optional().describe("Ports to expose"),
-      dockerEntrypoint: import_zod.z.array(import_zod.z.string()).optional().describe("Docker entrypoint commands"),
-      dockerStartCmd: import_zod.z.array(import_zod.z.string()).optional().describe("Docker start commands"),
-      env: import_zod.z.record(import_zod.z.string()).optional().describe("Environment variables"),
-      containerDiskInGb: import_zod.z.number().optional().describe("Container disk size in GB"),
-      volumeInGb: import_zod.z.number().optional().describe("Volume size in GB"),
-      volumeMountPath: import_zod.z.string().optional().describe("Path to mount the volume"),
-      readme: import_zod.z.string().optional().describe("README content in markdown format")
+      name: import_zod6.z.string().describe("Name for the template"),
+      imageName: import_zod6.z.string().describe("Docker image to use"),
+      isServerless: import_zod6.z.boolean().optional().describe("Is this a serverless template"),
+      ports: import_zod6.z.array(import_zod6.z.string()).optional().describe("Ports to expose"),
+      dockerEntrypoint: import_zod6.z.array(import_zod6.z.string()).optional().describe("Docker entrypoint commands"),
+      dockerStartCmd: import_zod6.z.array(import_zod6.z.string()).optional().describe("Docker start commands"),
+      env: import_zod6.z.record(import_zod6.z.string()).optional().describe("Environment variables"),
+      containerDiskInGb: import_zod6.z.number().optional().describe("Container disk size in GB"),
+      volumeInGb: import_zod6.z.number().optional().describe("Volume size in GB"),
+      volumeMountPath: import_zod6.z.string().optional().describe("Path to mount the volume"),
+      readme: import_zod6.z.string().optional().describe("README content in markdown format"),
+      category: import_zod6.z.enum(["CPU", "NVIDIA", "AMD"]).optional().describe(
+        "Hardware category for the template. On v2 a category is required and defaults to NVIDIA when omitted \u2014 set CPU or AMD for non-NVIDIA templates so they are not mis-categorized."
+      ),
+      containerRegistryAuthId: import_zod6.z.string().optional().describe(
+        "ID of a container registry credential (from create-container-registry-auth / list-container-registry-auths) used to pull a private image. Required when imageName points at a private registry; without it serverless workers fail the image pull."
+      )
     },
+    { title: "Create template", ...WRITE },
     async (params) => {
-      const result = await runpodRequest("/templates", "POST", params);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      const backend = backendFor("templates");
+      const body = backend.mapCreate(params);
+      const result = await callRestUrl(
+        `${backend.base}${backend.list}`,
+        "POST",
+        body
+      );
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "update-template",
+    "Update a template's mutable fields (name, image, ports, env, readme). Only provided fields change.",
     {
-      templateId: import_zod.z.string().describe("ID of the template to update"),
-      name: import_zod.z.string().optional().describe("New name for the template"),
-      imageName: import_zod.z.string().optional().describe("New Docker image"),
-      ports: import_zod.z.array(import_zod.z.string()).optional().describe("New ports to expose"),
-      env: import_zod.z.record(import_zod.z.string()).optional().describe("New environment variables"),
-      readme: import_zod.z.string().optional().describe("New README content in markdown format")
+      templateId: import_zod6.z.string().describe("ID of the template to update"),
+      name: import_zod6.z.string().optional().describe("New name for the template"),
+      imageName: import_zod6.z.string().optional().describe("New Docker image"),
+      ports: import_zod6.z.array(import_zod6.z.string()).optional().describe("New ports to expose"),
+      env: import_zod6.z.record(import_zod6.z.string()).optional().describe("New environment variables"),
+      readme: import_zod6.z.string().optional().describe("New README content in markdown format"),
+      containerRegistryAuthId: import_zod6.z.string().optional().describe(
+        "ID of a container registry credential (from create-container-registry-auth / list-container-registry-auths) used to pull a private image. Set this to attach a credential to a template referencing a private registry."
+      )
     },
+    { title: "Update template", ...WRITE, idempotentHint: true },
     async (params) => {
       const { templateId, ...updateParams } = params;
-      const result = await runpodRequest(
-        `/templates/${templateId}`,
+      const backend = backendFor("templates");
+      const body = backend.mapUpdate(updateParams);
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(templateId)}`,
         "PATCH",
-        updateParams
+        body
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "delete-template",
+    "Permanently delete a template. This cannot be undone.",
     {
-      templateId: import_zod.z.string().describe("ID of the template to delete")
+      templateId: import_zod6.z.string().describe("ID of the template to delete")
     },
+    { title: "Delete template", ...DESTRUCTIVE },
     async (params) => {
-      const result = await runpodRequest(
-        `/templates/${params.templateId}`,
+      const backend = backendFor("templates");
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.templateId)}`,
         "DELETE"
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool("list-network-volumes", {}, async () => {
-    const result = await runpodRequest("/networkvolumes");
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(result, null, 2)
-        }
-      ]
-    };
-  });
-  server2.tool(
+}
+
+// src/tools/network-volumes.ts
+var import_zod7 = require("zod");
+function registerNetworkVolumeTools(server, rt) {
+  const { jsonReply: jsonReply2, callRestUrl, backendFor } = rt;
+  server.tool(
+    "list-network-volumes",
+    "List your network volumes (persistent storage attachable to pods). Paginated via limit/cursor.",
+    listPaginationParams,
+    { title: "List network volumes", ...READ_ONLY },
+    async (params) => {
+      const backend = backendFor("networkVolumes");
+      const result = await callRestUrl(`${backend.base}${backend.list}`);
+      return capListResult(backend.unwrap(result), {
+        limit: params.limit,
+        cursor: params.cursor
+      });
+    }
+  );
+  server.tool(
     "get-network-volume",
+    "Get one network volume by id (name, size, data center).",
     {
-      networkVolumeId: import_zod.z.string().describe("ID of the network volume to retrieve")
+      networkVolumeId: import_zod7.z.string().describe("ID of the network volume to retrieve")
     },
+    { title: "Get network volume", ...READ_ONLY },
     async (params) => {
-      const result = await runpodRequest(
-        `/networkvolumes/${params.networkVolumeId}`
+      const backend = backendFor("networkVolumes");
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.networkVolumeId)}`
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "create-network-volume",
+    "Create a persistent network volume in a data center (size 1\u20134000 GB) that pods can mount.",
     {
-      name: import_zod.z.string().describe("Name for the network volume"),
-      size: import_zod.z.number().describe("Size in GB (1-4000)"),
-      dataCenterId: import_zod.z.string().describe("Data center ID")
+      name: import_zod7.z.string().describe("Name for the network volume"),
+      size: import_zod7.z.number().describe("Size in GB (1-4000)"),
+      dataCenterId: import_zod7.z.string().describe("Data center ID (see list-data-centers)")
     },
+    { title: "Create network volume", ...WRITE },
     async (params) => {
-      const result = await runpodRequest("/networkvolumes", "POST", params);
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      const backend = backendFor("networkVolumes");
+      const body = backend.mapCreate(params);
+      const result = await callRestUrl(
+        `${backend.base}${backend.list}`,
+        "POST",
+        body
+      );
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "update-network-volume",
+    "Update a network volume (rename, or grow size \u2014 the new size must exceed the current size). Only provided fields change.",
     {
-      networkVolumeId: import_zod.z.string().describe("ID of the network volume to update"),
-      name: import_zod.z.string().optional().describe("New name for the network volume"),
-      size: import_zod.z.number().optional().describe("New size in GB (must be larger than current)")
+      networkVolumeId: import_zod7.z.string().describe("ID of the network volume to update"),
+      name: import_zod7.z.string().optional().describe("New name for the network volume"),
+      size: import_zod7.z.number().optional().describe("New size in GB (must be larger than current)")
     },
+    { title: "Update network volume", ...WRITE, idempotentHint: true },
     async (params) => {
       const { networkVolumeId, ...updateParams } = params;
-      const result = await runpodRequest(
-        `/networkvolumes/${networkVolumeId}`,
+      const backend = backendFor("networkVolumes");
+      const body = backend.mapUpdate(updateParams);
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(networkVolumeId)}`,
         "PATCH",
-        updateParams
+        body
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "delete-network-volume",
+    "Permanently delete a network volume and its data. This cannot be undone.",
     {
-      networkVolumeId: import_zod.z.string().describe("ID of the network volume to delete")
+      networkVolumeId: import_zod7.z.string().describe("ID of the network volume to delete")
     },
+    { title: "Delete network volume", ...DESTRUCTIVE },
     async (params) => {
-      const result = await runpodRequest(
-        `/networkvolumes/${params.networkVolumeId}`,
+      const backend = backendFor("networkVolumes");
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.networkVolumeId)}`,
         "DELETE"
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool("list-container-registry-auths", {}, async () => {
-    const result = await runpodRequest("/containerregistryauth");
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(result, null, 2)
-        }
-      ]
-    };
-  });
-  server2.tool(
+}
+
+// src/tools/registries.ts
+var import_zod8 = require("zod");
+function registerRegistryTools(server, rt) {
+  const { jsonReply: jsonReply2, callRestUrl, backendFor } = rt;
+  server.tool(
+    "list-container-registry-auths",
+    "List your saved container-registry credentials (private image-pull auth). Paginated via limit/cursor.",
+    listPaginationParams,
+    { title: "List container registry auths", ...READ_ONLY },
+    async (params) => {
+      const backend = backendFor("registries");
+      const result = await callRestUrl(`${backend.base}${backend.list}`);
+      return capListResult(backend.unwrap(result), {
+        limit: params.limit,
+        cursor: params.cursor
+      });
+    }
+  );
+  server.tool(
     "get-container-registry-auth",
+    "Get one saved container-registry credential by id (the secret/password is not returned).",
     {
-      containerRegistryAuthId: import_zod.z.string().describe("ID of the container registry auth to retrieve")
+      containerRegistryAuthId: import_zod8.z.string().describe("ID of the container registry auth to retrieve")
     },
+    { title: "Get container registry auth", ...READ_ONLY },
     async (params) => {
-      const result = await runpodRequest(
-        `/containerregistryauth/${params.containerRegistryAuthId}`
+      const backend = backendFor("registries");
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.containerRegistryAuthId)}`
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "create-container-registry-auth",
+    "Save container-registry credentials (username + password/token) so pods and endpoints can pull private images.",
     {
-      name: import_zod.z.string().describe("Name for the container registry auth"),
-      username: import_zod.z.string().describe("Registry username"),
-      password: import_zod.z.string().describe("Registry password")
+      name: import_zod8.z.string().describe("Name for the container registry auth"),
+      username: import_zod8.z.string().describe("Registry username"),
+      password: import_zod8.z.string().describe("Registry password or access token (stored as a secret)")
     },
+    { title: "Create container registry auth", ...WRITE },
     async (params) => {
-      const result = await runpodRequest(
-        "/containerregistryauth",
+      const backend = backendFor("registries");
+      const body = backend.mapCreate(params);
+      const result = await callRestUrl(
+        `${backend.base}${backend.list}`,
         "POST",
-        params
+        body
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
-  server2.tool(
+  server.tool(
     "delete-container-registry-auth",
+    "Permanently delete a saved container-registry credential. This cannot be undone.",
     {
-      containerRegistryAuthId: import_zod.z.string().describe("ID of the container registry auth to delete")
+      containerRegistryAuthId: import_zod8.z.string().describe("ID of the container registry auth to delete")
     },
+    { title: "Delete container registry auth", ...DESTRUCTIVE },
     async (params) => {
-      const result = await runpodRequest(
-        `/containerregistryauth/${params.containerRegistryAuthId}`,
+      const backend = backendFor("registries");
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.containerRegistryAuthId)}`,
         "DELETE"
       );
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
+      return jsonReply2(result);
     }
   );
 }
 
+// src/tools/tags.ts
+var import_zod9 = require("zod");
+var TAG_RESOURCE_TYPES = [
+  "POD",
+  "NETWORK_VOLUME",
+  "CLUSTER",
+  "SERVERLESS_ENDPOINT"
+];
+var taggedResourceSchema = import_zod9.z.object({
+  id: import_zod9.z.string().describe("Resource identifier (e.g. a pod or endpoint id)"),
+  type: import_zod9.z.enum(TAG_RESOURCE_TYPES).describe("Type of resource to associate with the tag")
+});
+function v2OnlyNotice(tool) {
+  return {
+    error: `${tool} is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2.`,
+    status: 501
+  };
+}
+function registerTagTools(server, rt) {
+  const { jsonReply: jsonReply2, callRestUrl, backendFor } = rt;
+  server.tool(
+    "list-tags",
+    "List your tags (key/value labels on pods, volumes, clusters, and endpoints). v2-only \u2014 returns a 501 notice on the v1 API. Paginated via limit/cursor.",
+    {
+      ...listPaginationParams,
+      includeResources: import_zod9.z.boolean().optional().describe("Include the resources attached to each tag in the response")
+    },
+    { title: "List tags", ...READ_ONLY },
+    async (params) => {
+      const backend = backendFor("tags");
+      if (backend.version === "v1") return jsonReply2(v2OnlyNotice("list-tags"));
+      const query = params.includeResources ? "?include=resources" : "";
+      const raw = await callRestUrl(`${backend.base}${backend.list}${query}`);
+      return capListResult(backend.unwrap(raw), {
+        limit: params.limit,
+        cursor: params.cursor
+      });
+    }
+  );
+  server.tool(
+    "get-tag",
+    "Get one tag by id, optionally including its attached resources. v2-only \u2014 returns a 501 notice on the v1 API.",
+    {
+      tagId: import_zod9.z.string().describe("ID of the tag to retrieve"),
+      includeResources: import_zod9.z.boolean().optional().describe("Include the resources attached to this tag")
+    },
+    { title: "Get tag", ...READ_ONLY },
+    async (params) => {
+      const backend = backendFor("tags");
+      if (backend.version === "v1") return jsonReply2(v2OnlyNotice("get-tag"));
+      const query = params.includeResources ? "?include=resources" : "";
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.tagId)}${query}`
+      );
+      return jsonReply2(result);
+    }
+  );
+  server.tool(
+    "create-tag",
+    "Create a key/value tag, optionally attaching resources at creation. v2-only \u2014 returns a 501 notice on the v1 API.",
+    {
+      key: import_zod9.z.string().min(1).describe('Tag key (e.g. "project")'),
+      value: import_zod9.z.string().min(1).describe('Tag value (e.g. "gpt-training")'),
+      resources: import_zod9.z.array(taggedResourceSchema).optional().describe("Resources to attach to the tag at creation time")
+    },
+    { title: "Create tag", ...WRITE },
+    async (params) => {
+      const backend = backendFor("tags");
+      if (backend.version === "v1")
+        return jsonReply2(v2OnlyNotice("create-tag"));
+      const result = await callRestUrl(
+        `${backend.base}${backend.list}`,
+        "POST",
+        params
+      );
+      return jsonReply2(result);
+    }
+  );
+  server.tool(
+    "update-tag",
+    "Update a tag (rename its key/value, or replace its resource associations). Provide at least one of key, value, or resources. Sending resources:[] removes all associations; omitting resources leaves them unchanged. Replacing resources is NOT atomic \u2014 a failed update can leave a partially-applied set, so for small association changes prefer attach-tag/detach-tag. v2-only \u2014 returns a 501 notice on the v1 API.",
+    {
+      tagId: import_zod9.z.string().describe("ID of the tag to update"),
+      key: import_zod9.z.string().min(1).optional().describe("New tag key"),
+      value: import_zod9.z.string().min(1).optional().describe("New tag value"),
+      resources: import_zod9.z.array(taggedResourceSchema).optional().describe(
+        "Replace the tag's resource associations with exactly these. Omit to leave unchanged; pass [] to detach all."
+      )
+    },
+    // No idempotentHint: replacing `resources` is non-atomic upstream, so a
+    // retried-after-partial-failure update is not guaranteed to be a no-op.
+    { title: "Update tag", ...WRITE },
+    async (params) => {
+      const { tagId, ...updateParams } = params;
+      const backend = backendFor("tags");
+      if (backend.version === "v1")
+        return jsonReply2(v2OnlyNotice("update-tag"));
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(tagId)}`,
+        "PATCH",
+        updateParams
+      );
+      return jsonReply2(result);
+    }
+  );
+  server.tool(
+    "delete-tag",
+    "Permanently delete a tag (removes it from all resources it is attached to). This cannot be undone. v2-only \u2014 returns a 501 notice on the v1 API.",
+    {
+      tagId: import_zod9.z.string().describe("ID of the tag to delete")
+    },
+    { title: "Delete tag", ...DESTRUCTIVE },
+    async (params) => {
+      const backend = backendFor("tags");
+      if (backend.version === "v1")
+        return jsonReply2(v2OnlyNotice("delete-tag"));
+      const result = await callRestUrl(
+        `${backend.base}${backend.get(params.tagId)}`,
+        "DELETE"
+      );
+      return jsonReply2(result);
+    }
+  );
+  server.tool(
+    "attach-tag",
+    "Attach a tag to a resource (pod, network volume, cluster, or serverless endpoint). Idempotent \u2014 attaching an already-associated resource is a no-op. v2-only \u2014 returns a 501 notice on the v1 API.",
+    {
+      tagId: import_zod9.z.string().describe("ID of the tag"),
+      resourceType: import_zod9.z.enum(TAG_RESOURCE_TYPES).describe("Type of resource to attach the tag to"),
+      resourceId: import_zod9.z.string().describe("ID of the resource to attach the tag to")
+    },
+    { title: "Attach tag to resource", ...WRITE, idempotentHint: true },
+    async (params) => {
+      const backend = backendFor("tags");
+      if (backend.version === "v1")
+        return jsonReply2(v2OnlyNotice("attach-tag"));
+      const result = await callRestUrl(
+        `${backend.base}/tags/${encodeURIComponent(params.tagId)}/resources/${params.resourceType}/${encodeURIComponent(params.resourceId)}`,
+        "PUT"
+      );
+      return jsonReply2(result);
+    }
+  );
+  server.tool(
+    "detach-tag",
+    "Detach a tag from a resource (removes the association only \u2014 the resource and tag are not deleted). Idempotent \u2014 detaching a resource that is not associated is a no-op. v2-only \u2014 returns a 501 notice on the v1 API.",
+    {
+      tagId: import_zod9.z.string().describe("ID of the tag"),
+      resourceType: import_zod9.z.enum(TAG_RESOURCE_TYPES).describe("Type of resource to detach the tag from"),
+      resourceId: import_zod9.z.string().describe("ID of the resource to detach the tag from")
+    },
+    { title: "Detach tag from resource", ...WRITE, idempotentHint: true },
+    async (params) => {
+      const backend = backendFor("tags");
+      if (backend.version === "v1")
+        return jsonReply2(v2OnlyNotice("detach-tag"));
+      const result = await callRestUrl(
+        `${backend.base}/tags/${encodeURIComponent(params.tagId)}/resources/${params.resourceType}/${encodeURIComponent(params.resourceId)}`,
+        "DELETE"
+      );
+      return jsonReply2(result);
+    }
+  );
+}
+
+// src/tools/billing.ts
+var import_zod10 = require("zod");
+var BILLING_SCOPE_PATH = {
+  all: "/billing",
+  pods: "/billing/pods",
+  serverless: "/billing/serverless",
+  endpoints: "/billing/endpoints",
+  networkvolumes: "/billing/networkvolumes",
+  clusters: "/billing/clusters"
+};
+function registerBillingTools(server, rt) {
+  const { jsonReply: jsonReply2, callRestUrl, backendFor } = rt;
+  server.tool(
+    "get-billing",
+    "Get time-bucketed Runpod spend history, either aggregated across all resources or broken down by resource type (pods, serverless, endpoints, network volumes, clusters). v2-only \u2014 returns a 501 notice on the v1 API. Records are capped via limit/cursor; narrow the window with startTime/endTime or lastN.",
+    {
+      ...listPaginationParams,
+      scope: import_zod10.z.enum([
+        "all",
+        "pods",
+        "serverless",
+        "endpoints",
+        "networkvolumes",
+        "clusters"
+      ]).optional().describe(
+        'Which billing breakdown to fetch. "all" (default) is the aggregate across every resource.'
+      ),
+      startTime: import_zod10.z.string().optional().describe(
+        "Start of the period (RFC 3339, e.g. 2026-05-01T00:00:00Z). Defaults to 30 days ago. Mutually exclusive with lastN."
+      ),
+      endTime: import_zod10.z.string().optional().describe(
+        "End of the period (RFC 3339), exclusive. Defaults to now. Mutually exclusive with lastN."
+      ),
+      bucketSize: import_zod10.z.enum(["hour", "day", "week", "month", "year"]).optional().describe("Length of each time bucket. Defaults to day."),
+      lastN: import_zod10.z.number().int().positive().optional().describe(
+        "Return the last N buckets of bucketSize, ending with the current one. Mutually exclusive with startTime/endTime."
+      )
+    },
+    { title: "Get billing history", ...READ_ONLY },
+    async (params) => {
+      const backend = backendFor("billing");
+      if (backend.version === "v1") {
+        return jsonReply2({
+          error: "get-billing is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2.",
+          status: 501
+        });
+      }
+      const subPath = BILLING_SCOPE_PATH[params.scope ?? "all"];
+      const query = new URLSearchParams();
+      if (params.startTime) query.set("startTime", params.startTime);
+      if (params.endTime) query.set("endTime", params.endTime);
+      if (params.bucketSize) query.set("bucketSize", params.bucketSize);
+      if (params.lastN !== void 0 && !params.startTime && !params.endTime)
+        query.set("lastN", String(params.lastN));
+      const qs = query.toString() ? `?${query.toString()}` : "";
+      const raw = await callRestUrl(`${backend.base}${subPath}${qs}`);
+      return capListResult(
+        backend.unwrap(raw),
+        { limit: params.limit, cursor: params.cursor },
+        { metadata: raw?.metadata }
+      );
+    }
+  );
+}
+
+// src/tools.ts
+function registerTools(server, ctx, deps = {}) {
+  const rt = createToolRuntime(server, ctx, deps);
+  registerCatalogTools(server, rt);
+  registerPodTools(server, rt);
+  registerEndpointTools(server, rt);
+  registerJobTools(server, rt);
+  registerTemplateTools(server, rt);
+  registerNetworkVolumeTools(server, rt);
+  registerRegistryTools(server, rt);
+  registerTagTools(server, rt);
+  registerBillingTools(server, rt);
+}
+
 // src/stdio.ts
-var API_KEY = process.env.RUNPOD_API_KEY;
-if (!API_KEY) {
-  console.error("RUNPOD_API_KEY environment variable is required");
-  process.exit(1);
-}
-var server = createServer();
-registerTools(server, { apiKey: API_KEY, transport: "stdio" });
-var transport = new import_stdio.StdioServerTransport();
-server.connect(transport);
+var WIZARD_SUBCOMMANDS = ["add", "remove"];
+var subcommand = process.argv[2];
+var isWizardMode = WIZARD_SUBCOMMANDS.includes(subcommand);
+async function main(apiKey) {
+  let v2Available;
+  if (wantsAutoProbe(process.env)) {
+    const probe = createV2Prober({
+      // node-fetch's signature is wider than the `{ status }` the prober needs.
+      fetch: import_node_fetch2.default,
+      baseUrl: restV2Base(process.env),
+      apiKey,
+      // Surface a transient/timeout fallback to v1 — otherwise `auto` silently
+      // pins the session to v1 with no signal (stderr is the MCP log channel).
+      warn: (message) => console.error(`[runpod-mcp] ${message}`)
+    });
+    v2Available = await probe();
+  }
+  const server = createServer();
+  registerTools(server, { apiKey, transport: "stdio" }, { v2Available });
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+}
+if (isWizardMode) {
+  Promise.resolve().then(() => (init_wizard(), wizard_exports)).then(({ runWizard: runWizard2 }) => runWizard2(subcommand)).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+} else {
+  const API_KEY = process.env.RUNPOD_API_KEY;
+  if (!API_KEY) {
+    console.error("RUNPOD_API_KEY environment variable is required");
+    process.exit(1);
+  }
+  main(API_KEY).catch((error) => {
+    console.error("Failed to start Runpod MCP server:", error);
+    process.exit(1);
+  });
+}
 //# sourceMappingURL=stdio.cjs.map