@runpod/mcp-server 1.2.0 → 1.4.0

package/dist/stdio.cjs

@@ -0,0 +1,1639 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  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");
+
+// src/server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var SERVER_NAME = "Runpod API Server";
+var SERVER_VERSION = true ? "1.4.0" : "dev";
+function createServer(version = SERVER_VERSION) {
+  return new import_mcp.McpServer({
+    name: SERVER_NAME,
+    version,
+    capabilities: {
+      resources: {},
+      tools: {}
+    }
+  });
+}
+
+// src/tools.ts
+var import_zod2 = require("zod");
+var import_node_fetch = __toESM(require("node-fetch"), 1);
+var import_node_crypto = require("crypto");
+
+// 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) {
+  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) }
+      ]
+    };
+  }
+  const total = result.length;
+  const page = result.slice(offset, offset + limit);
+  const nextOffset = offset + page.length;
+  const hasMore = nextOffset < total;
+  const envelope = {
+    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) }
+    ]
+  };
+}
+
+// src/tools.ts
+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.4.0" : "dev";
+var SESSION_ID = (0, import_node_crypto.randomUUID)();
+function sanitizeUaToken(value) {
+  return value.replace(/[()<>@,;:\\"/[\]?={}\s]/g, "_").slice(0, 64);
+}
+function trackingHeaders(server, ctx) {
+  const info = server.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})`;
+  return {
+    "User-Agent": userAgent,
+    "X-Runpod-Session-Id": SESSION_ID
+  };
+}
+async function graphqlRequest(query, tracking) {
+  const response = await (0, import_node_fetch.default)(GRAPHQL_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...tracking()
+    },
+    body: JSON.stringify({ query })
+  });
+  const result = await response.json();
+  if (result.errors && result.errors.length > 0) {
+    throw new Error(
+      `GraphQL Error: ${result.errors.map((e) => e.message).join(", ")}`
+    );
+  }
+  if (!result.data) {
+    throw new Error("No data returned from GraphQL query");
+  }
+  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 = {
+      method,
+      headers
+    };
+    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 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 API:", error);
+      throw error;
+    }
+  };
+}
+function createServerlessRequest(apiKey, tracking) {
+  return async function serverlessRequest(endpointId, path2, method = "GET", body) {
+    const url = `${SERVERLESS_API_BASE_URL}/${endpointId}${path2}`;
+    const headers = {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      ...tracking()
+    };
+    const options = {
+      method,
+      headers
+    };
+    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;
+    }
+  };
+}
+function registerTools(server, ctx) {
+  const tracking = () => trackingHeaders(server, ctx);
+  const runpodRequest = createRunpodRequest(ctx.apiKey, tracking);
+  const serverlessRequest = createServerlessRequest(ctx.apiKey, tracking);
+  server.tool(
+    "list-gpu-types",
+    {
+      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_zod2.z.boolean().optional().describe(
+        "Include GPUs that are currently out of stock. Default is false"
+      )
+    },
+    async (params) => {
+      const data = await graphqlRequest(
+        `
+        query {
+          gpuTypes {
+            id
+            displayName
+            memoryInGb
+            secureCloud
+            communityCloud
+            lowestPrice(input: { gpuCount: 1 }) {
+              stockStatus
+            }
+          }
+        }
+      `,
+        tracking
+      );
+      const stockPriority = {
+        High: 3,
+        Medium: 2,
+        Low: 1
+      };
+      const isAvailable = (gpu) => {
+        const status = gpu.lowestPrice?.stockStatus;
+        return !!status && status !== "Out";
+      };
+      let gpuTypes = data.gpuTypes.filter((gpu) => gpu.id !== "unknown");
+      if (!params.includeUnavailable) {
+        gpuTypes = gpuTypes.filter(isAvailable);
+      }
+      if (params.minMemoryGb) {
+        gpuTypes = gpuTypes.filter(
+          (gpu) => gpu.memoryInGb >= params.minMemoryGb
+        );
+      }
+      if (params.secureCloudOnly) {
+        gpuTypes = gpuTypes.filter((gpu) => gpu.secureCloud);
+      }
+      if (params.communityCloudOnly) {
+        gpuTypes = gpuTypes.filter((gpu) => gpu.communityCloud);
+      }
+      if (params.searchTerm) {
+        const term = params.searchTerm.toLowerCase();
+        gpuTypes = gpuTypes.filter(
+          (gpu) => gpu.id.toLowerCase().includes(term) || gpu.displayName.toLowerCase().includes(term)
+        );
+      }
+      gpuTypes.sort((a, b) => {
+        const aP = stockPriority[a.lowestPrice?.stockStatus || ""] || 0;
+        const bP = stockPriority[b.lowestPrice?.stockStatus || ""] || 0;
+        if (bP !== aP) return bP - aP;
+        return b.memoryInGb - a.memoryInGb;
+      });
+      const result = gpuTypes.map((gpu) => ({
+        id: gpu.id,
+        displayName: gpu.displayName,
+        memoryGb: gpu.memoryInGb,
+        secureCloud: gpu.secureCloud,
+        communityCloud: gpu.communityCloud,
+        stockStatus: gpu.lowestPrice?.stockStatus || "unavailable",
+        available: isAvailable(gpu)
+      }));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list-data-centers",
+    {
+      region: import_zod2.z.string().optional().describe(
+        "Filter by region/location (e.g., 'United States', 'Europe', 'Canada')"
+      )
+    },
+    async (params) => {
+      const data = await graphqlRequest(
+        `
+        query {
+          dataCenters {
+            id
+            name
+            location
+          }
+        }
+      `,
+        tracking
+      );
+      let dataCenters = data.dataCenters;
+      if (params.region) {
+        const term = params.region.toLowerCase();
+        dataCenters = dataCenters.filter(
+          (dc) => dc.location.toLowerCase().includes(term)
+        );
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(dataCenters, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list-pods",
+    {
+      ...listPaginationParams,
+      computeType: import_zod2.z.enum(["GPU", "CPU"]).optional().describe("Filter to only GPU or only CPU Pods"),
+      gpuTypeId: import_zod2.z.array(import_zod2.z.string()).optional().describe("Filter to Pods with any of the listed GPU types"),
+      dataCenterId: import_zod2.z.array(import_zod2.z.string()).optional().describe("Filter to Pods in any of the provided data centers"),
+      name: import_zod2.z.string().optional().describe("Filter to Pods with the provided name"),
+      includeMachine: import_zod2.z.boolean().optional().describe("Include information about the machine"),
+      includeNetworkVolume: import_zod2.z.boolean().optional().describe("Include information about attached network volumes")
+    },
+    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 capListResult(result, {
+        limit: params.limit,
+        cursor: params.cursor
+      });
+    }
+  );
+  server.tool(
+    "get-pod",
+    {
+      podId: import_zod2.z.string().describe("ID of the pod to retrieve"),
+      includeMachine: import_zod2.z.boolean().optional().describe("Include information about the machine"),
+      includeNetworkVolume: import_zod2.z.boolean().optional().describe("Include information about attached network volumes")
+    },
+    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)
+          }
+        ]
+      };
+    }
+  );
+  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.',
+    {
+      name: import_zod2.z.string().optional().describe("Name for the pod"),
+      imageName: import_zod2.z.string().describe("Docker image to use"),
+      cloudType: import_zod2.z.enum(["SECURE", "COMMUNITY"]).optional().describe("SECURE or COMMUNITY cloud"),
+      gpuTypeIds: import_zod2.z.array(import_zod2.z.string()).optional().describe("List of acceptable GPU types"),
+      gpuCount: import_zod2.z.number().optional().describe("Number of GPUs"),
+      containerDiskInGb: import_zod2.z.number().optional().describe("Container disk size in GB"),
+      volumeInGb: import_zod2.z.number().optional().describe("Volume size in GB"),
+      volumeMountPath: import_zod2.z.string().optional().describe("Path to mount the volume"),
+      ports: import_zod2.z.array(import_zod2.z.string()).optional().describe("Ports to expose (e.g., '8888/http', '22/tcp')"),
+      env: import_zod2.z.record(import_zod2.z.string()).optional().describe("Environment variables"),
+      dataCenterIds: import_zod2.z.array(import_zod2.z.string()).optional().describe("List of data centers")
+    },
+    async (params) => {
+      const result = await runpodRequest("/pods", "POST", params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "update-pod",
+    {
+      podId: import_zod2.z.string().describe("ID of the pod to update"),
+      name: import_zod2.z.string().optional().describe("New name for the pod"),
+      imageName: import_zod2.z.string().optional().describe("New Docker image"),
+      containerDiskInGb: import_zod2.z.number().optional().describe("New container disk size in GB"),
+      volumeInGb: import_zod2.z.number().optional().describe("New volume size in GB"),
+      volumeMountPath: import_zod2.z.string().optional().describe("New path to mount the volume"),
+      ports: import_zod2.z.array(import_zod2.z.string()).optional().describe("New ports to expose"),
+      env: import_zod2.z.record(import_zod2.z.string()).optional().describe("New environment variables")
+    },
+    async (params) => {
+      const { podId, ...updateParams } = params;
+      const result = await runpodRequest(
+        `/pods/${podId}`,
+        "PATCH",
+        updateParams
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "start-pod",
+    {
+      podId: import_zod2.z.string().describe("ID of the pod to start")
+    },
+    async (params) => {
+      const result = await runpodRequest(`/pods/${params.podId}/start`, "POST");
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "stop-pod",
+    {
+      podId: import_zod2.z.string().describe("ID of the pod to stop")
+    },
+    async (params) => {
+      const result = await runpodRequest(`/pods/${params.podId}/stop`, "POST");
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "delete-pod",
+    {
+      podId: import_zod2.z.string().describe("ID of the pod to delete")
+    },
+    async (params) => {
+      const result = await runpodRequest(`/pods/${params.podId}`, "DELETE");
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list-endpoints",
+    {
+      ...listPaginationParams,
+      includeTemplate: import_zod2.z.boolean().optional().describe("Include template information"),
+      includeWorkers: import_zod2.z.boolean().optional().describe("Include information about workers")
+    },
+    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 capListResult(result, {
+        limit: params.limit,
+        cursor: params.cursor
+      });
+    }
+  );
+  server.tool(
+    "get-endpoint",
+    {
+      endpointId: import_zod2.z.string().describe("ID of the endpoint to retrieve"),
+      includeTemplate: import_zod2.z.boolean().optional().describe("Include template information"),
+      includeWorkers: import_zod2.z.boolean().optional().describe("Include information about workers")
+    },
+    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}`
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "create-endpoint",
+    {
+      name: import_zod2.z.string().optional().describe("Name for the endpoint"),
+      templateId: import_zod2.z.string().describe("Template ID to use"),
+      computeType: import_zod2.z.enum(["GPU", "CPU"]).optional().describe("GPU or CPU endpoint"),
+      gpuTypeIds: import_zod2.z.array(import_zod2.z.string()).optional().describe("List of acceptable GPU types"),
+      gpuCount: import_zod2.z.number().optional().describe("Number of GPUs per worker"),
+      workersMin: import_zod2.z.number().optional().describe("Minimum number of workers"),
+      workersMax: import_zod2.z.number().optional().describe("Maximum number of workers"),
+      dataCenterIds: import_zod2.z.array(import_zod2.z.string()).optional().describe("List of data centers")
+    },
+    async (params) => {
+      const result = await runpodRequest("/endpoints", "POST", params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "update-endpoint",
+    {
+      endpointId: import_zod2.z.string().describe("ID of the endpoint to update"),
+      name: import_zod2.z.string().optional().describe("New name for the endpoint"),
+      workersMin: import_zod2.z.number().optional().describe("New minimum number of workers"),
+      workersMax: import_zod2.z.number().optional().describe("New maximum number of workers"),
+      idleTimeout: import_zod2.z.number().optional().describe("New idle timeout in seconds"),
+      scalerType: import_zod2.z.enum(["QUEUE_DELAY", "REQUEST_COUNT"]).optional().describe("Scaler type"),
+      scalerValue: import_zod2.z.number().optional().describe("Scaler value")
+    },
+    async (params) => {
+      const { endpointId, ...updateParams } = params;
+      const result = await runpodRequest(
+        `/endpoints/${endpointId}`,
+        "PATCH",
+        updateParams
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "delete-endpoint",
+    {
+      endpointId: import_zod2.z.string().describe("ID of the endpoint to delete")
+    },
+    async (params) => {
+      const result = await runpodRequest(
+        `/endpoints/${params.endpointId}`,
+        "DELETE"
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  const endpointIdSchema = import_zod2.z.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid endpoint ID format");
+  const jobIdSchema = import_zod2.z.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid job ID format");
+  const inputSchema = import_zod2.z.record(import_zod2.z.unknown()).describe(
+    "Input payload for the worker handler. The expected fields depend on the deployed model or worker."
+  );
+  const webhookSchema = import_zod2.z.string().url().optional().describe(
+    "Webhook URL to receive job completion notifications instead of polling"
+  );
+  const policySchema = import_zod2.z.object({
+    executionTimeout: import_zod2.z.number().optional().describe("Maximum execution time in milliseconds"),
+    lowPriority: import_zod2.z.boolean().optional().describe("Submit as a low-priority job"),
+    ttl: import_zod2.z.number().optional().describe("Time-to-live for the job result in milliseconds")
+  }).optional().describe("Execution policy options");
+  const s3ConfigSchema = import_zod2.z.object({
+    accessId: import_zod2.z.string().describe("S3 access key ID"),
+    accessSecret: import_zod2.z.string().describe("S3 secret access key"),
+    bucketName: import_zod2.z.string().describe("S3 bucket name"),
+    endpointUrl: import_zod2.z.string().describe("S3 endpoint URL")
+  }).optional().describe("S3-compatible storage config for large outputs");
+  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.",
+    {
+      endpointId: endpointIdSchema.describe(
+        "ID of the Serverless endpoint to run"
+      ),
+      input: inputSchema,
+      webhook: webhookSchema,
+      policy: policySchema,
+      s3Config: s3ConfigSchema
+    },
+    async (params) => {
+      const { endpointId, ...body } = params;
+      const result = await serverlessRequest(
+        endpointId,
+        "/run",
+        "POST",
+        body
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  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).",
+    {
+      endpointId: endpointIdSchema.describe(
+        "ID of the Serverless endpoint to run synchronously"
+      ),
+      input: inputSchema,
+      wait: import_zod2.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
+    },
+    async (params) => {
+      const { endpointId, wait, ...body } = params;
+      const path2 = wait ? `/runsync?wait=${wait}` : "/runsync";
+      const result = await serverlessRequest(
+        endpointId,
+        path2,
+        "POST",
+        body
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  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.",
+    {
+      endpointId: endpointIdSchema.describe(
+        "ID of the Serverless endpoint the job belongs to"
+      ),
+      jobId: jobIdSchema.describe("ID of the job to check")
+    },
+    async (params) => {
+      const result = await serverlessRequest(
+        params.endpointId,
+        `/status/${params.jobId}`
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  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.",
+    {
+      endpointId: endpointIdSchema.describe(
+        "ID of the Serverless endpoint the job belongs to"
+      ),
+      jobId: jobIdSchema.describe("ID of the job to stream results from")
+    },
+    async (params) => {
+      const TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+        "COMPLETED",
+        "FAILED",
+        "CANCELLED",
+        "TIMED_OUT"
+      ]);
+      const MAX_POLL_TIME_MS = 5 * 60 * 1e3;
+      const POLL_INTERVAL_MS = 1e3;
+      const MAX_CONSECUTIVE_ERRORS = 5;
+      const allChunks = [];
+      let finalResult = {};
+      let consecutiveErrors = 0;
+      let lastError;
+      const startTime = Date.now();
+      while (true) {
+        try {
+          const result = await serverlessRequest(
+            params.endpointId,
+            `/stream/${params.jobId}`
+          );
+          consecutiveErrors = 0;
+          if (Array.isArray(result.stream)) {
+            allChunks.push(...result.stream);
+          }
+          finalResult = result;
+          if (TERMINAL_STATUSES.has(result.status)) {
+            break;
+          }
+        } catch (error) {
+          consecutiveErrors++;
+          lastError = error instanceof Error ? error.message : String(error);
+          if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+            finalResult.error = `Polling aborted after ${MAX_CONSECUTIVE_ERRORS} consecutive errors: ${lastError}`;
+            break;
+          }
+        }
+        if (Date.now() - startTime > MAX_POLL_TIME_MS) {
+          finalResult.pollingTimedOut = true;
+          finalResult.note = "Polling timed out after 5 minutes. Use get-job-status to check the job later.";
+          if (lastError) finalResult.lastError = lastError;
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              { ...finalResult, stream: allChunks },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "cancel-job",
+    "Cancel a Serverless job that is queued or in progress.",
+    {
+      endpointId: endpointIdSchema.describe(
+        "ID of the Serverless endpoint the job belongs to"
+      ),
+      jobId: jobIdSchema.describe("ID of the job to cancel")
+    },
+    async (params) => {
+      const result = await serverlessRequest(
+        params.endpointId,
+        `/cancel/${params.jobId}`,
+        "POST"
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  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.",
+    {
+      endpointId: endpointIdSchema.describe(
+        "ID of the Serverless endpoint the job belongs to"
+      ),
+      jobId: jobIdSchema.describe("ID of the job to retry")
+    },
+    async (params) => {
+      const result = await serverlessRequest(
+        params.endpointId,
+        `/retry/${params.jobId}`,
+        "POST"
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "endpoint-health",
+    "Get the health and operational status of a Serverless endpoint, including worker counts and job statistics.",
+    {
+      endpointId: endpointIdSchema.describe(
+        "ID of the Serverless endpoint to check health for"
+      )
+    },
+    async (params) => {
+      const result = await serverlessRequest(params.endpointId, "/health");
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  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.",
+    {
+      endpointId: endpointIdSchema.describe(
+        "ID of the Serverless endpoint to purge the queue for"
+      )
+    },
+    async (params) => {
+      const result = await serverlessRequest(
+        params.endpointId,
+        "/purge-queue",
+        "POST"
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  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.`,
+    {
+      ...listPaginationParams,
+      includeRunpodTemplates: import_zod2.z.boolean().optional().describe("Include official Runpod templates in the response"),
+      includePublicTemplates: import_zod2.z.boolean().optional().describe("Include community-made public templates in the response"),
+      includeEndpointBoundTemplates: import_zod2.z.boolean().optional().describe(
+        "Include templates bound to Serverless endpoints in the response"
+      )
+    },
+    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}` : ""}`
+      );
+      return capListResult(result, {
+        limit: params.limit,
+        cursor: params.cursor
+      });
+    }
+  );
+  server.tool(
+    "get-template",
+    {
+      templateId: import_zod2.z.string().describe("ID of the template to retrieve")
+    },
+    async (params) => {
+      const result = await runpodRequest(`/templates/${params.templateId}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "create-template",
+    {
+      name: import_zod2.z.string().describe("Name for the template"),
+      imageName: import_zod2.z.string().describe("Docker image to use"),
+      isServerless: import_zod2.z.boolean().optional().describe("Is this a serverless template"),
+      ports: import_zod2.z.array(import_zod2.z.string()).optional().describe("Ports to expose"),
+      dockerEntrypoint: import_zod2.z.array(import_zod2.z.string()).optional().describe("Docker entrypoint commands"),
+      dockerStartCmd: import_zod2.z.array(import_zod2.z.string()).optional().describe("Docker start commands"),
+      env: import_zod2.z.record(import_zod2.z.string()).optional().describe("Environment variables"),
+      containerDiskInGb: import_zod2.z.number().optional().describe("Container disk size in GB"),
+      volumeInGb: import_zod2.z.number().optional().describe("Volume size in GB"),
+      volumeMountPath: import_zod2.z.string().optional().describe("Path to mount the volume"),
+      readme: import_zod2.z.string().optional().describe("README content in markdown format"),
+      containerRegistryAuthId: import_zod2.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."
+      )
+    },
+    async (params) => {
+      const result = await runpodRequest("/templates", "POST", params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "update-template",
+    {
+      templateId: import_zod2.z.string().describe("ID of the template to update"),
+      name: import_zod2.z.string().optional().describe("New name for the template"),
+      imageName: import_zod2.z.string().optional().describe("New Docker image"),
+      ports: import_zod2.z.array(import_zod2.z.string()).optional().describe("New ports to expose"),
+      env: import_zod2.z.record(import_zod2.z.string()).optional().describe("New environment variables"),
+      readme: import_zod2.z.string().optional().describe("New README content in markdown format"),
+      containerRegistryAuthId: import_zod2.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."
+      )
+    },
+    async (params) => {
+      const { templateId, ...updateParams } = params;
+      const result = await runpodRequest(
+        `/templates/${templateId}`,
+        "PATCH",
+        updateParams
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "delete-template",
+    {
+      templateId: import_zod2.z.string().describe("ID of the template to delete")
+    },
+    async (params) => {
+      const result = await runpodRequest(
+        `/templates/${params.templateId}`,
+        "DELETE"
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool("list-network-volumes", listPaginationParams, async (params) => {
+    const result = await runpodRequest("/networkvolumes");
+    return capListResult(result, {
+      limit: params.limit,
+      cursor: params.cursor
+    });
+  });
+  server.tool(
+    "get-network-volume",
+    {
+      networkVolumeId: import_zod2.z.string().describe("ID of the network volume to retrieve")
+    },
+    async (params) => {
+      const result = await runpodRequest(
+        `/networkvolumes/${params.networkVolumeId}`
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "create-network-volume",
+    {
+      name: import_zod2.z.string().describe("Name for the network volume"),
+      size: import_zod2.z.number().describe("Size in GB (1-4000)"),
+      dataCenterId: import_zod2.z.string().describe("Data center ID")
+    },
+    async (params) => {
+      const result = await runpodRequest("/networkvolumes", "POST", params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "update-network-volume",
+    {
+      networkVolumeId: import_zod2.z.string().describe("ID of the network volume to update"),
+      name: import_zod2.z.string().optional().describe("New name for the network volume"),
+      size: import_zod2.z.number().optional().describe("New size in GB (must be larger than current)")
+    },
+    async (params) => {
+      const { networkVolumeId, ...updateParams } = params;
+      const result = await runpodRequest(
+        `/networkvolumes/${networkVolumeId}`,
+        "PATCH",
+        updateParams
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "delete-network-volume",
+    {
+      networkVolumeId: import_zod2.z.string().describe("ID of the network volume to delete")
+    },
+    async (params) => {
+      const result = await runpodRequest(
+        `/networkvolumes/${params.networkVolumeId}`,
+        "DELETE"
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list-container-registry-auths",
+    listPaginationParams,
+    async (params) => {
+      const result = await runpodRequest("/containerregistryauth");
+      return capListResult(result, {
+        limit: params.limit,
+        cursor: params.cursor
+      });
+    }
+  );
+  server.tool(
+    "get-container-registry-auth",
+    {
+      containerRegistryAuthId: import_zod2.z.string().describe("ID of the container registry auth to retrieve")
+    },
+    async (params) => {
+      const result = await runpodRequest(
+        `/containerregistryauth/${params.containerRegistryAuthId}`
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "create-container-registry-auth",
+    {
+      name: import_zod2.z.string().describe("Name for the container registry auth"),
+      username: import_zod2.z.string().describe("Registry username"),
+      password: import_zod2.z.string().describe("Registry password")
+    },
+    async (params) => {
+      const result = await runpodRequest(
+        "/containerregistryauth",
+        "POST",
+        params
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "delete-container-registry-auth",
+    {
+      containerRegistryAuthId: import_zod2.z.string().describe("ID of the container registry auth to delete")
+    },
+    async (params) => {
+      const result = await runpodRequest(
+        `/containerregistryauth/${params.containerRegistryAuthId}`,
+        "DELETE"
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/stdio.ts
+var WIZARD_SUBCOMMANDS = ["add", "remove"];
+var subcommand = process.argv[2];
+var isWizardMode = WIZARD_SUBCOMMANDS.includes(subcommand);
+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);
+  }
+  const server = createServer();
+  registerTools(server, { apiKey: API_KEY, transport: "stdio" });
+  const transport = new import_stdio.StdioServerTransport();
+  server.connect(transport);
+}
+//# sourceMappingURL=stdio.cjs.map