@runpod/mcp-server 3.4.0 → 4.1.0

package/dist/tools.cjs

@@ -1,3799 +0,0 @@
-"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 __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
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/tools.ts
-var tools_exports = {};
-__export(tools_exports, {
-  registerTools: () => registerTools
-});
-module.exports = __toCommonJS(tools_exports);
-
-// src/tools/runtime.ts
-var import_node_fetch = __toESM(require("node-fetch"), 1);
-var import_node_crypto = require("crypto");
-
-// src/_shared/rate-limit.ts
-var GENERIC_RATE_LIMIT_HINT = "rate limited \u2014 back off before retrying, and pace bulk operations";
-var MAX_PLAUSIBLE_WAIT_S = 7 * 86400;
-function remainingRequests(raw) {
-  const value = raw?.trim();
-  return value && /^\d+$/.test(value) ? Number(value) : null;
-}
-function waitSeconds(raw) {
-  const value = raw?.trim();
-  if (!value || !/^\d+$/.test(value)) return null;
-  const seconds = Number(value);
-  return seconds <= MAX_PLAUSIBLE_WAIT_S ? seconds : null;
-}
-var WINDOW_NAME_RE = /^(?:"([\x20-\x21\x23-\x5b\x5d-\x7e]{1,32})"|([A-Za-z*][A-Za-z0-9!#$%&'*+.^_`|~:/-]{0,31}))$/;
-function windowName(raw) {
-  const match = WINDOW_NAME_RE.exec(raw.trim());
-  return match ? match[1] ?? match[2] : null;
-}
-var QUOTED_VALUE_RE = /^"(?:[\x20-\x21\x23-\x5b\x5d-\x7e]|\\["\\])*"$/;
-var DISPLAY_VALUE_RE = /^%"(?:[\x20-\x21\x23-\x24\x26-\x5b\x5d-\x7e]|\\|%[0-9a-f]{2})*"$/;
-function isWellFormedParam(param) {
-  const eq = param.indexOf("=");
-  const key = (eq === -1 ? param : param.slice(0, eq)).trim();
-  if (key.includes('"')) return false;
-  if (eq === -1) return true;
-  const value = param.slice(eq + 1).trim();
-  if (value.startsWith('"')) return QUOTED_VALUE_RE.test(value);
-  if (value.startsWith('%"')) return DISPLAY_VALUE_RE.test(value);
-  return !/[\s"]/.test(value);
-}
-function splitOutsideStrings(input, sep) {
-  const parts = [];
-  let current = "";
-  let inString = false;
-  let inDisplay = false;
-  let escaped = false;
-  let prev = "";
-  for (const ch of input) {
-    if (escaped) escaped = false;
-    else if (inString && !inDisplay && ch === "\\") escaped = true;
-    else if (ch === '"') {
-      if (!inString) inDisplay = prev === "%";
-      inString = !inString;
-    } else if (ch === sep && !inString) {
-      parts.push(current);
-      current = "";
-      prev = ch;
-      continue;
-    }
-    current += ch;
-    prev = ch;
-  }
-  parts.push(current);
-  return parts;
-}
-function readParams(params) {
-  const values = /* @__PURE__ */ new Map();
-  let unreadable = false;
-  let valuelessAt = -1;
-  for (const [index, param] of params.entries()) {
-    const eq = param.indexOf("=");
-    const key = (eq === -1 ? param : param.slice(0, eq)).trim().toLowerCase();
-    if (!key) continue;
-    if (eq === -1) {
-      if (key === "r") unreadable = true;
-      if (key === "t") values.delete("t");
-      valuelessAt = index;
-      continue;
-    }
-    if ((key === "r" || key === "t") && (values.has(key) || valuelessAt !== -1 && index > valuelessAt)) {
-      unreadable = true;
-    }
-    values.set(key, param.slice(eq + 1));
-  }
-  return { values, unreadable };
-}
-function parseExhaustedWindows(header) {
-  if (!header) return { windows: [], dropped: false };
-  const windows = [];
-  let dropped = false;
-  for (const item of splitOutsideStrings(header, ",")) {
-    if (item.trim() === "") continue;
-    const [rawName, ...params] = splitOutsideStrings(item, ";");
-    if (!params.every(isWellFormedParam)) {
-      dropped = true;
-      continue;
-    }
-    const { values, unreadable } = readParams(params);
-    if (unreadable) {
-      dropped = true;
-      continue;
-    }
-    const remaining = remainingRequests(values.get("r"));
-    if (remaining === null) {
-      dropped = true;
-      continue;
-    }
-    if (remaining !== 0) continue;
-    windows.push({
-      window: windowName(rawName),
-      resetS: waitSeconds(values.get("t"))
-    });
-  }
-  return { windows, dropped };
-}
-function humanWait(seconds) {
-  if (seconds < 120) return `~${seconds}s`;
-  if (seconds < 3600)
-    return `~${Math.ceil(seconds / 60)} minutes (${seconds}s)`;
-  if (seconds < 2 * 86400) {
-    const hours = Math.ceil(seconds / 3600);
-    return `~${hours} hour${hours === 1 ? "" : "s"} (${seconds}s)`;
-  }
-  return `~${Math.ceil(seconds / 86400)} days (${seconds}s)`;
-}
-function rateLimitHint(rateLimitHeader, retryAfterHeader) {
-  const { windows, dropped } = parseExhaustedWindows(rateLimitHeader);
-  windows.sort((a, b) => (b.resetS ?? -1) - (a.resetS ?? -1));
-  const longestWindow = windows[0];
-  const waitCandidates = [
-    waitSeconds(retryAfterHeader),
-    longestWindow?.resetS
-  ].filter((n) => typeof n === "number" && n > 0);
-  const waitS = waitCandidates.length ? Math.max(...waitCandidates) : null;
-  const retryAfterUnreadable = typeof retryAfterHeader === "string" && retryAfterHeader.trim() !== "" && waitSeconds(retryAfterHeader) === null;
-  if (!longestWindow && waitS === null) {
-    if (!retryAfterUnreadable) return GENERIC_RATE_LIMIT_HINT;
-  }
-  const namedClause = longestWindow?.window ? `the ${longestWindow.window} quota is exhausted` : "";
-  if (waitS === null) {
-    const cause = namedClause ? `${namedClause}, but the response gave no usable reset time` : "the response gave no usable reset time";
-    return `rate limited \u2014 ${cause}; back off substantially before retrying, and pace bulk operations`;
-  }
-  const hedge = dropped || retryAfterUnreadable || windows.some((w) => w.resetS === null) ? "at least " : "";
-  const wait = `wait ${hedge}${humanWait(waitS)} before retrying, and pace bulk operations`;
-  return `rate limited \u2014 ${namedClause ? `${namedClause}; ` : ""}${wait}`;
-}
-
-// src/_shared/http.ts
-var EXPIRED_CREDENTIAL_HINT = "the Runpod API rejected the credential \u2014 the API key may be expired or revoked; re-authenticate or update RUNPOD_API_KEY";
-var HttpError = class extends Error {
-  constructor(prefix, status, body, hint) {
-    const shownBody = body.length > 2048 ? `${body.slice(0, 2048)}\u2026 [truncated ${body.length - 2048} chars]` : body;
-    super(`${prefix}: ${status} - ${shownBody}${hint ? ` (${hint})` : ""}`);
-    this.name = "HttpError";
-    this.status = status;
-    this.body = body;
-  }
-};
-var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
-var MIN_REQUEST_TIMEOUT_MS = 1e3;
-var RequestTimeoutError = class extends Error {
-  constructor(prefix, timeoutMs, method) {
-    const write = method !== "GET" && method !== "HEAD";
-    super(
-      `${prefix}: no response after ${timeoutMs}ms for ${method} (the API may be overloaded, or still be working on it). ${write ? "This request may have SUCCEEDED upstream \u2014 do not retry blindly. Check with the matching list-/get- tool first and retry only if it did not take effect." : "This was a read and changed nothing, so retrying is safe."}`
-    );
-    this.name = "RequestTimeoutError";
-    this.timeoutMs = timeoutMs;
-    this.method = method;
-  }
-};
-async function withRequestTimeout(errorPrefix, timeoutMs, method, run) {
-  const signal = AbortSignal.timeout(timeoutMs);
-  try {
-    return await run(signal);
-  } catch (error) {
-    if (error instanceof HttpError || !signal.aborted) throw error;
-    throw new RequestTimeoutError(errorPrefix, timeoutMs, method);
-  }
-}
-function isJsonContentType(contentType) {
-  if (!contentType) return false;
-  const ct = contentType.toLowerCase();
-  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 resolveCeiling(ceiling) {
-  if (ceiling === void 0) return Infinity;
-  if (typeof ceiling !== "function") return ceiling;
-  return Math.max(ceiling(), MIN_REQUEST_TIMEOUT_MS);
-}
-function clampTimeout(requestedMs, ceiling, defaultMs = DEFAULT_REQUEST_TIMEOUT_MS) {
-  return Math.min(requestedMs ?? defaultMs, resolveCeiling(ceiling));
-}
-function createHttpClient(deps) {
-  const defaultTimeoutMs = deps.defaultTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-  return async function request(url, method = "GET", body, options) {
-    const timeoutMs = clampTimeout(
-      options?.timeoutMs,
-      deps.maxTimeoutMs,
-      defaultTimeoutMs
-    );
-    return withRequestTimeout(
-      deps.errorPrefix,
-      timeoutMs,
-      method,
-      async (signal) => {
-        const init = {
-          method,
-          headers: buildRequestHeaders(deps.apiKey, deps.tracking),
-          signal
-        };
-        if (body && methodSendsBody(method)) {
-          init.body = JSON.stringify(body);
-        }
-        const response = await deps.fetch(url, init);
-        if (!response.ok) {
-          const hint = response.status === 429 ? rateLimitHint(
-            response.headers.get("ratelimit"),
-            response.headers.get("retry-after")
-          ) : response.status === 401 ? EXPIRED_CREDENTIAL_HINT : void 0;
-          const text = await response.text().catch(
-            () => "<body unavailable: the connection closed while reading it>"
-          );
-          throw new HttpError(deps.errorPrefix, response.status, text, hint);
-        }
-        return isJsonContentType(response.headers.get("content-type")) ? response.json() : { success: true, status: response.status };
-      }
-    );
-  };
-}
-
-// src/_shared/tracking.ts
-function sanitizeUaToken(value) {
-  return value.replace(/[()<>@,;:\\"/[\]?={}\s]/g, "_").slice(0, 64);
-}
-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": input.sessionId
-  };
-}
-
-// src/tools/logs.ts
-var import_zod = require("zod");
-function parseLogSse(raw) {
-  const items = [];
-  for (const block of raw.split(/\r?\n\r?\n/)) {
-    const dataLines = block.split(/\r?\n/).filter((l) => l.startsWith("data:"));
-    if (!dataLines.length) continue;
-    const payload = dataLines.map((l) => l.slice(5).replace(/^ /, "")).join("\n");
-    if (!payload.trim()) continue;
-    try {
-      const parsed = JSON.parse(payload);
-      items.push(
-        parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : { raw: payload }
-      );
-    } catch {
-      items.push({ raw: payload });
-    }
-  }
-  return items;
-}
-var LOG_STREAM_DEFAULT_WAIT_MS = 5e3;
-var LOG_STREAM_MAX_BYTES = 256 * 1024;
-async function readSseSnapshot(fetchImpl, url, headers, opts) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), opts.maxWaitMs);
-  const chunks = [];
-  let bytes = 0;
-  let truncated = false;
-  try {
-    const res = await fetchImpl(url, {
-      method: "GET",
-      headers,
-      signal: controller.signal
-    });
-    if (!res.ok) {
-      throw new HttpError(
-        "Runpod API Error",
-        res.status,
-        await res.text().catch(() => ""),
-        // This throw bypasses createHttpClient, so the status hints are built
-        // here too or these two tools alone return a bare 429/401. The 401
-        // hint applies: this request always carries Authorization (see the
-        // headers bound in runtime.ts streamSse).
-        res.status === 429 ? rateLimitHint(
-          res.headers.get("ratelimit"),
-          res.headers.get("retry-after")
-        ) : res.status === 401 ? EXPIRED_CREDENTIAL_HINT : void 0
-      );
-    }
-    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;
-  } finally {
-    clearTimeout(timer);
-  }
-  return { raw: Buffer.concat(chunks).toString("utf8"), truncated };
-}
-var logStreamParams = {
-  source: import_zod.z.enum(["container", "system", "both"]).optional().describe("Which log source to read (default: both)"),
-  tail: import_zod.z.number().int().min(0).max(5e3).optional().describe(
-    "Historical lines to backfill before live output (API default 100, max 5000; 0 = live only). Ignored when `since` is set."
-  ),
-  since: import_zod.z.string().optional().describe("RFC3339 timestamp to resume from; when set, `tail` is ignored."),
-  maxWaitMs: import_zod.z.number().int().min(500).max(3e4).optional().describe("How long to read the stream, in ms (default 5000, max 30000)")
-};
-async function collectLogSnapshot(streamSse, logsUrl, params) {
-  const qs = new URLSearchParams();
-  if (params.source && params.source !== "both")
-    qs.append("source", params.source);
-  if (params.tail !== void 0) qs.append("tail", String(params.tail));
-  if (params.since) qs.append("since", params.since);
-  const query = qs.toString() ? `?${qs}` : "";
-  const { raw, truncated } = await streamSse(`${logsUrl}${query}`, {
-    maxWaitMs: params.maxWaitMs ?? LOG_STREAM_DEFAULT_WAIT_MS,
-    maxBytes: LOG_STREAM_MAX_BYTES
-  });
-  const items = parseLogSse(raw);
-  if (truncated) items.pop();
-  return { items, count: items.length, truncated };
-}
-async function streamLogsReply(rt, tool, params) {
-  const backend = rt.backendFor(tool.resource);
-  if (backend.version === "v1") {
-    return rt.jsonReply({
-      error: `${tool.name} is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2.`,
-      status: 501
-    });
-  }
-  try {
-    return rt.jsonReply(
-      await collectLogSnapshot(rt.streamSse, tool.logsUrl(backend), params)
-    );
-  } catch (error) {
-    if (error instanceof HttpError) {
-      return rt.jsonReply({ error: error.message, status: error.status });
-    }
-    throw error;
-  }
-}
-
-// 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, path) {
-  if (size === void 0 || path === void 0) return void 0;
-  return { persistent: { size, path } };
-}
-function joinStartCmd(cmd) {
-  return cmd && cmd.length ? cmd.join(" ") : void 0;
-}
-function containerConfigToV2(p) {
-  return compact({
-    image: p.imageName,
-    disk: p.containerDiskInGb,
-    ports: p.ports,
-    env: p.env,
-    mounts: persistentMount(p.volumeInGb, p.volumeMountPath)
-  });
-}
-function gpuConfigToV2(gpuTypeIds, gpuCount, allowedCudaVersions, minCudaVersion2) {
-  const id = gpuTypeIds?.[0];
-  if (id === void 0) return void 0;
-  return compact({
-    id,
-    count: gpuCount ?? 1,
-    allowedCudaVersions,
-    minCudaVersion: minCudaVersion2
-  });
-}
-function mapPodCreateToV2(params) {
-  return compact({
-    ...containerConfigToV2(params),
-    name: params.name,
-    // Private-image registry credential (v2 ContainerConfig `registry`). When
-    // deploying from a template, this spreads over the template's registry, so
-    // passing it overrides the inherited credential. An empty string is an
-    // explicit opt-out: emit `registry: null` (v2 accepts null) to CLEAR a
-    // template's inherited credential. Undefined is dropped by compact, so an
-    // omitted param leaves the template's registry in place.
-    registry: params.containerRegistryAuthId === "" ? null : params.containerRegistryAuthId,
-    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,
-      params.allowedCudaVersions,
-      params.minCudaVersion
-    )
-  });
-}
-function mapPodUpdateToV2(params) {
-  return {
-    ...containerConfigToV2(params),
-    ...compact({ name: params.name })
-  };
-}
-var DEFAULT_ENDPOINT_TYPE = "QUEUE";
-var DEFAULT_SCALER_VALUE = 4;
-function defaultScalerType(endpointType) {
-  return endpointType === "LOAD_BALANCER" ? "REQUEST_COUNT" : "QUEUE_DELAY";
-}
-function endpointScaling(scalerType, value) {
-  return scalerType === "REQUEST_COUNT" ? { type: "REQUEST_COUNT", requestCount: value } : { type: "QUEUE_DELAY", queueDelay: value };
-}
-function endpointGpuConfig(params, mode) {
-  const gpu = compact({
-    pools: params.gpuPoolIds?.length ? params.gpuPoolIds : void 0,
-    count: params.gpuCount,
-    allowedCudaVersions: params.allowedCudaVersions,
-    minCudaVersion: params.minCudaVersion
-  });
-  if (mode === "create" && !("pools" in gpu)) return void 0;
-  return Object.keys(gpu).length ? gpu : void 0;
-}
-function endpointWorkers(params) {
-  const workers = compact({
-    min: params.workersMin,
-    max: params.workersMax,
-    idleTimeout: params.idleTimeout
-  });
-  return Object.keys(workers).length ? workers : void 0;
-}
-function endpointCommonToV2(params, mode) {
-  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, mode),
-    workers: endpointWorkers(params),
-    dataCenterIds: params.dataCenterIds?.length ? params.dataCenterIds : void 0,
-    networkVolumes: params.networkVolumeIds?.length ? params.networkVolumeIds : void 0,
-    timeout: params.executionTimeoutMs,
-    flashboot: params.flashboot
-  });
-}
-function mapEndpointCreateToV2(params) {
-  const endpointType = params.endpointType ?? DEFAULT_ENDPOINT_TYPE;
-  return compact({
-    ...endpointCommonToV2(params, "create"),
-    type: endpointType,
-    scaling: endpointScaling(
-      params.scalerType ?? defaultScalerType(endpointType),
-      params.scalerValue ?? DEFAULT_SCALER_VALUE
-    )
-  });
-}
-function mapEndpointUpdateToV2(params) {
-  return compact({
-    ...endpointCommonToV2(params, "update"),
-    scaling: params.scalerType ? endpointScaling(
-      params.scalerType,
-      params.scalerValue ?? DEFAULT_SCALER_VALUE
-    ) : void 0
-  });
-}
-var CUDA_MAJOR_MINOR = /^\d+\.\d+$/;
-function cudaConstraintError(params, opts = {}) {
-  const { allowedCudaVersions, minCudaVersion: minCudaVersion2 } = params;
-  if (allowedCudaVersions?.length && minCudaVersion2) {
-    return "allowedCudaVersions and minCudaVersion are mutually exclusive \u2014 pass either an exact set or an open-ended floor, not both.";
-  }
-  if (minCudaVersion2 !== void 0 && !CUDA_MAJOR_MINOR.test(minCudaVersion2) && !(opts.allowClear && minCudaVersion2 === "")) {
-    return `minCudaVersion must be major.minor (e.g. "12.0", not "12")${opts.allowClear ? "; an empty string clears the floor" : ""}.`;
-  }
-  const bad = allowedCudaVersions?.find((v) => !CUDA_MAJOR_MINOR.test(v));
-  if (bad !== void 0) {
-    return `allowedCudaVersions entries must be major.minor (e.g. "12.8"); got "${bad}". Discover valid values via get-capacity or list-gpu-types.`;
-  }
-  return void 0;
-}
-function mapNetworkVolumeCreateToV2(params) {
-  return compact({
-    name: params.name,
-    size: params.size,
-    dataCenter: params.dataCenterId,
-    type: params.volumeType
-  });
-}
-function mapTemplateCreateToV2(params) {
-  return {
-    ...containerConfigToV2(params),
-    ...compact({
-      name: params.name,
-      serverless: params.isServerless,
-      registry: params.containerRegistryAuthId,
-      args: joinStartCmd(params.dockerStartCmd),
-      // No longer required by v2 (it defaults to NVIDIA server-side), so an
-      // unset category is dropped by compact instead of being forced here.
-      category: params.category
-    })
-  };
-}
-function podBodyFromTemplate(template) {
-  const out = {};
-  const keys = [
-    "name",
-    "image",
-    "args",
-    "disk",
-    "ports",
-    "env",
-    "mounts",
-    "registry"
-  ];
-  for (const key of keys) {
-    const value = template[key];
-    if (value !== void 0 && value !== null) out[key] = value;
-  }
-  return out;
-}
-var SSH_PUBLIC_KEY_LINE = /^(ssh-[a-z0-9-]+|ecdsa-[a-z0-9-]+|sk-[a-z0-9@.-]+)\s+\S+/i;
-var PRIVATE_KEY_MARKER = /private[-\s]?key|PuTTY-User-Key-File/i;
-function normalizeSshPublicKey(input) {
-  if (PRIVATE_KEY_MARKER.test(input))
-    return {
-      ok: false,
-      error: 'sshPublicKey looks like a PRIVATE key. Pass the PUBLIC key instead \u2014 the contents of your ~/.ssh/<key>.pub file (e.g. "ssh-ed25519 AAAA\u2026").'
-    };
-  const lines = input.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
-  if (lines.length === 0)
-    return {
-      ok: false,
-      error: "sshPublicKey is empty. Pass the contents of your ~/.ssh/<key>.pub file, or omit the parameter entirely to create the pod without SSH."
-    };
-  if (lines.some((line) => !SSH_PUBLIC_KEY_LINE.test(line)))
-    return {
-      ok: false,
-      error: 'sshPublicKey is not an SSH public key. Expected the CONTENTS of your ~/.ssh/<key>.pub file \u2014 a line like "ssh-ed25519 AAAAC3Nza\u2026 you@host" (ssh-*, ecdsa-*, or sk-* followed by the base64 key) \u2014 not a file path, a SHA256 fingerprint, or a bare base64 blob. Newline-separate multiple keys.'
-    };
-  return { ok: true, key: lines.join("\n") };
-}
-function applySshPublicKey(body, sshPublicKey) {
-  const ports = Array.isArray(body.ports) ? body.ports : [];
-  const hasSshPort = ports.some((p) => /^\s*22\/tcp\s*$/i.test(String(p)));
-  const env = { ...body.env ?? {} };
-  const key = sshPublicKey.trim();
-  if (!env.PUBLIC_KEY) env.PUBLIC_KEY = key;
-  else if (!env.PUBLIC_KEY.includes(key))
-    env.PUBLIC_KEY = `${env.PUBLIC_KEY}
-${key}`;
-  return {
-    ...body,
-    ports: hasSshPort ? ports : [...ports, "22/tcp"],
-    env
-  };
-}
-function mapTemplateUpdateToV2(params) {
-  return {
-    ...containerConfigToV2(params),
-    ...compact({
-      name: params.name,
-      registry: params.containerRegistryAuthId,
-      args: joinStartCmd(params.dockerStartCmd)
-    })
-  };
-}
-
-// 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",
-  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",
-  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://api.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 authedGraphqlBase(env) {
-  return env.RUNPOD_AUTHED_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";
-}
-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([
-  "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}`
-  },
-  // 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 ? "3.4.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 HTTP_TRANSPORT_BUDGET_MS = 5e4;
-function invocationBudget(totalMs) {
-  const startedAt = Date.now();
-  return () => totalMs - (Date.now() - startedAt);
-}
-var defaultFetch = import_node_fetch.default;
-async function withApiErrorLog(label, call) {
-  try {
-    return await call();
-  } catch (error) {
-    console.error(label, error);
-    throw error;
-  }
-}
-function jsonReply(result) {
-  return {
-    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-  };
-}
-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, options) {
-  return withRequestTimeout(
-    "Runpod GraphQL Error",
-    clampTimeout(options?.timeoutMs, options?.maxTimeoutMs),
-    // GraphQL is POST on the wire whatever it carries, but the retry advice keys
-    // off the method, and telling a caller its list-gpu-types "may have
-    // SUCCEEDED upstream — check with the matching list-/get- tool first" points
-    // it back at the tool that just failed. The operation keyword is what
-    // actually says whether anything could have been written.
-    isGraphqlMutation(query) ? "POST" : "GET",
-    (signal) => runGraphql(query, tracking, fetchImpl, url, signal, options)
-  );
-}
-function isGraphqlMutation(query) {
-  const firstMeaningful = query.split("\n").map((line) => line.trim()).find((line) => line.length > 0 && !line.startsWith("#"));
-  return /^mutation\b/.test(firstMeaningful ?? "");
-}
-async function runGraphql(query, tracking, fetchImpl, url, signal, options) {
-  const response = await fetchImpl(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      ...options?.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {},
-      ...tracking()
-    },
-    body: JSON.stringify({
-      query,
-      ...options?.variables ? { variables: options.variables } : {}
-    }),
-    signal
-  });
-  if (!response.ok) {
-    const bodyText = await response.text();
-    let gqlErrors;
-    try {
-      gqlErrors = JSON.parse(bodyText).errors;
-    } catch {
-    }
-    if (Array.isArray(gqlErrors) && gqlErrors.length > 0 && response.status !== 401 && response.status !== 429) {
-      throw new HttpError(
-        "Runpod GraphQL Error",
-        response.status,
-        gqlErrors.map((e) => String(e?.message ?? JSON.stringify(e))).join(", ")
-      );
-    }
-    throw new HttpError(
-      "Runpod GraphQL Error",
-      response.status,
-      bodyText,
-      response.status === 429 ? rateLimitHint(
-        response.headers.get("ratelimit"),
-        response.headers.get("retry-after")
-      ) : (
-        // Only when this request actually carried the caller's API key: the
-        // public path sends no Authorization header, so a 401 from that
-        // host (WAF, misconfigured RUNPOD_PUBLIC_GRAPHQL_URL) says nothing
-        // about the credential — same rationale as observeUnauthorized.
-        response.status === 401 && options?.apiKey ? EXPIRED_CREDENTIAL_HINT : void 0
-      )
-    );
-  }
-  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 createToolRuntime(server, ctx, deps = {}) {
-  const tracking = () => trackingHeaders(server, ctx);
-  function observeUnauthorized(fn) {
-    const notify = ctx.onUnauthorized;
-    if (!notify) return fn;
-    return async (...args) => {
-      const response = await fn(...args);
-      if (response.status === 401) notify();
-      return response;
-    };
-  }
-  const rawFetch = deps.fetch ?? defaultFetch;
-  const httpFetch = observeUnauthorized(rawFetch);
-  const remainingHttpBudgetMs = invocationBudget(HTTP_TRANSPORT_BUDGET_MS);
-  const timeouts = {
-    defaultTimeoutMs: deps.defaultTimeoutMs,
-    maxTimeoutMs: deps.maxTimeoutMs ?? (ctx.transport === "http" ? remainingHttpBudgetMs : void 0)
-  };
-  const v1Client = createHttpClient({
-    apiKey: ctx.apiKey,
-    fetch: httpFetch,
-    tracking,
-    errorPrefix: "Runpod API Error",
-    ...timeouts
-  });
-  const runpodRequest = (endpoint, method = "GET", body, options) => withApiErrorLog(
-    "Error calling Runpod API:",
-    () => v1Client(
-      `${restV1Base(process.env)}${endpoint}`,
-      method,
-      body,
-      options
-    )
-  );
-  const serverlessClient = createHttpClient({
-    apiKey: ctx.apiKey,
-    fetch: httpFetch,
-    tracking,
-    errorPrefix: "Runpod Serverless API Error",
-    ...timeouts
-  });
-  const serverlessRequest = (endpointId, path, method = "GET", body, options) => withApiErrorLog(
-    "Error calling Runpod Serverless API:",
-    () => serverlessClient(
-      `${serverlessBase(process.env)}/${endpointId}${path}`,
-      method,
-      body,
-      options
-    )
-  );
-  const restClient = createHttpClient({
-    apiKey: ctx.apiKey,
-    fetch: httpFetch,
-    tracking,
-    errorPrefix: "Runpod API Error",
-    ...timeouts
-  });
-  const callRestUrl = (url, method = "GET", body, options) => withApiErrorLog(
-    "Error calling Runpod API:",
-    () => restClient(url, method, body, options)
-  );
-  const sseFetch = observeUnauthorized(
-    deps.sseFetch ?? import_node_fetch.default
-  );
-  const streamSse = deps.streamSse ?? ((url, opts) => readSseSnapshot(
-    sseFetch,
-    url,
-    {
-      Authorization: `Bearer ${ctx.apiKey}`,
-      Accept: "text/event-stream",
-      ...tracking()
-    },
-    opts
-  ));
-  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,
-    // No GraphQL caller overrides a deadline, but both are still capped by the
-    // shared budget: deploy-hub-repo spends one of each back to back.
-    graphql: (query) => graphqlRequest(
-      query,
-      tracking,
-      // rawFetch, not httpFetch: this call carries no credential (see above).
-      rawFetch,
-      publicGraphqlBase(process.env),
-      {
-        timeoutMs: deps.defaultTimeoutMs,
-        maxTimeoutMs: timeouts.maxTimeoutMs
-      }
-    ),
-    graphqlAuthed: (query, variables) => graphqlRequest(
-      query,
-      tracking,
-      httpFetch,
-      // NOT publicGraphqlBase: this call carries the caller's API key.
-      authedGraphqlBase(process.env),
-      {
-        variables,
-        apiKey: ctx.apiKey,
-        timeoutMs: deps.defaultTimeoutMs,
-        maxTimeoutMs: timeouts.maxTimeoutMs
-      }
-    ),
-    runpodRequest,
-    serverlessRequest,
-    callRestUrl,
-    backendFor,
-    streamSse,
-    podAction,
-    env: process.env,
-    transport: ctx.transport
-  };
-}
-
-// src/tools/catalog.ts
-var import_zod3 = require("zod");
-
-// src/pagination.ts
-var import_zod2 = require("zod");
-var DEFAULT_LIST_LIMIT = 20;
-var MAX_LIST_LIMIT = 100;
-var listPaginationParams = {
-  limit: import_zod2.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_zod2.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) }
-      ]
-    };
-  }
-  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) }
-    ]
-  };
-}
-
-// src/tools/catalog.ts
-var GPU_PRODUCTS = /* @__PURE__ */ new Set(["POD", "CLUSTER", "SERVERLESS"]);
-function registerCatalogTools(server, rt) {
-  const { jsonReply: jsonReply2, graphql, callRestUrl, backendFor } = rt;
-  server.tool(
-    "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. By default the full catalog is returned: each result includes an `availability` summary (HIGH/MEDIUM/LOW/NONE) and results are sorted with the most-available GPUs first, but nothing is hidden. Set includeUnavailable:false to drop out-of-stock GPUs and list only deployable ones (set includeAvailability:false to skip the stock lookup entirely). For per-datacenter availability (to pick a dataCenterIds), use get-gpu-type.",
-    {
-      ...listPaginationParams,
-      minMemoryGb: import_zod3.z.number().optional().describe("Filter to GPUs with at least this much VRAM in GB"),
-      secureCloudOnly: import_zod3.z.boolean().optional().describe("Filter to only GPUs available in secure cloud"),
-      communityCloudOnly: import_zod3.z.boolean().optional().describe("Filter to only GPUs available in community cloud"),
-      searchTerm: import_zod3.z.string().optional().describe(
-        "Search term to filter GPUs by name (e.g., 'A100', 'RTX 4090')"
-      ),
-      includeUnavailable: import_zod3.z.boolean().optional().describe(
-        "Out-of-stock GPUs are included by default (annotated availability:NONE and sorted last). Set false to hide them and list only currently-deployable GPUs."
-      ),
-      includeAvailability: import_zod3.z.boolean().optional().describe(
-        "Request realtime stock and annotate each GPU with an availability summary (HIGH/MEDIUM/LOW/NONE). Default true. Set false to skip the availability lookup \u2014 then out-of-stock GPUs cannot be filtered."
-      ),
-      product: import_zod3.z.enum(["POD", "CLUSTER", "SERVERLESS"]).optional().describe(
-        "Product context for the availability lookup \u2014 the same GPU can be scarce for Pods and plentiful for Serverless. Default POD. Use SERVERLESS when picking a GPU for an endpoint, CLUSTER for Instant Clusters. Ignored when includeAvailability is false."
-      ),
-      minCudaVersion: import_zod3.z.string().optional().describe(
-        'Scope the availability lookup to hosts at or above this CUDA version (v2 only). Integer major or major.minor \u2014 "12" means any 12.x release; unlike the create-pod/create-endpoint body fields, a bare major is accepted here because the filter only widens a read. Requires includeAvailability (the default).'
-      )
-    },
-    { title: "List GPU types", ...READ_ONLY },
-    async (params) => {
-      const backend = backendFor("gpus");
-      if (params.minCudaVersion !== void 0 && backend.version !== "v2") {
-        return jsonReply2({
-          error: "The minCudaVersion filter is only supported on the v2 REST API. Set RUNPOD_REST_VERSION=v2, or use get-capacity for per-CUDA-version availability.",
-          status: 501
-        });
-      }
-      if (backend.version === "v2") {
-        const wantAvailability = params.includeAvailability !== false;
-        const product = GPU_PRODUCTS.has(String(params.product)) ? String(params.product) : "POD";
-        if (params.minCudaVersion !== void 0) {
-          if (!wantAvailability) {
-            return jsonReply2({
-              error: "minCudaVersion filters the availability lookup, so it requires includeAvailability (the default). Drop includeAvailability:false or the filter.",
-              status: 400
-            });
-          }
-          if (!/^\d+(\.\d+)?$/.test(params.minCudaVersion)) {
-            return jsonReply2({
-              error: 'minCudaVersion must be an integer major ("12") or major.minor ("12.1").',
-              status: 400
-            });
-          }
-        }
-        const query = new URLSearchParams();
-        if (wantAvailability) {
-          query.set("include", "AVAILABILITY");
-          query.set("product", product);
-          if (params.minCudaVersion !== void 0) {
-            query.set("minCudaVersion", params.minCudaVersion);
-          }
-        }
-        const raw = await callRestUrl(
-          `${backend.base}${backend.list}${query.size ? `?${query}` : ""}`
-        );
-        let gpus = backend.unwrap(raw);
-        gpus = gpus.filter((g) => g.id !== "unknown");
-        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)
-          );
-        }
-        if (params.includeUnavailable === false)
-          gpus = gpus.filter((g) => g.availability !== "NONE");
-        const rank = {
-          HIGH: 3,
-          MEDIUM: 2,
-          LOW: 1,
-          NONE: 0
-        };
-        gpus.sort(
-          (a, b) => (rank[String(b.availability)] ?? 0) - (rank[String(a.availability)] ?? 0)
-        );
-        gpus = gpus.map(({ dataCenters: _dataCenters, ...rest }) => rest);
-        return capListResult(gpus, {
-          limit: params.limit,
-          cursor: params.cursor
-        });
-      }
-      const data = await graphql(`
-        query {
-          gpuTypes {
-            id
-            displayName
-            memoryInGb
-            secureCloud
-            communityCloud
-            lowestPrice(input: { gpuCount: 1 }) {
-              stockStatus
-            }
-          }
-        }
-      `);
-      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 === false) {
-        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 capListResult(result, {
-        limit: params.limit,
-        cursor: params.cursor
-      });
-    }
-  );
-  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.",
-    {
-      ...listPaginationParams,
-      region: import_zod3.z.string().optional().describe(
-        "Filter by region/location (e.g., 'United States', 'Europe', 'Canada')"
-      )
-    },
-    { title: "List data centers", ...READ_ONLY },
-    async (params) => {
-      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
-            name
-            location
-          }
-        }
-      `);
-      let dataCenters = data.dataCenters;
-      if (params.region) {
-        const term = params.region.toLowerCase();
-        dataCenters = dataCenters.filter(
-          (dc) => dc.location.toLowerCase().includes(term)
-        );
-      }
-      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, including per-datacenter availability. v2-only \u2014 returns a 501 notice on the v1 API (use list-gpu-types there). Use the returned dataCenters[].availability to pick a dataCenterIds with stock before creating a pod.",
-    {
-      gpuTypeId: import_zod3.z.string().describe("ID of the GPU type to retrieve"),
-      includeAvailability: import_zod3.z.boolean().optional().describe(
-        "Include realtime per-datacenter availability (HIGH/MEDIUM/LOW/NONE). Default true."
-      ),
-      product: import_zod3.z.enum(["POD", "CLUSTER", "SERVERLESS"]).optional().describe(
-        "Product context for the availability lookup \u2014 stock differs by product. Default POD. Use SERVERLESS when picking a GPU for an endpoint, CLUSTER for Instant Clusters. Ignored when includeAvailability is false."
-      )
-    },
-    { title: "Get GPU type", ...READ_ONLY },
-    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 path = backend.get(encodeURIComponent(params.gpuTypeId));
-      const product = GPU_PRODUCTS.has(String(params.product)) ? String(params.product) : "POD";
-      const query = params.includeAvailability === false ? "" : `?include=AVAILABILITY&product=${product}`;
-      const result = await callRestUrl(`${backend.base}${path}${query}`);
-      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_zod3.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);
-    }
-  );
-  server.tool(
-    "get-capacity",
-    "GPU capacity across host CUDA versions, as a matrix. Use this to choose an endpoint's allowedCudaVersions/minCudaVersion (or diagnose/widen a capacity-starved one) and to distinguish capacity problems from compatibility problems. Default mode is one call returning, per GPU type, overall stock plus AVAILABLE/UNAVAILABLE per host-reported CUDA version. Pass cudaVersions to deep-probe instead: one stock lookup per listed version, returning graded stock (High/Medium/Low/Out) and the lowest on-demand price per version; a probe that fails transiently reports a per-version error instead of failing the call. Nothing is hidden by default \u2014 set includeUnavailable:false to drop GPUs with no stock on any listed version. Credential-free public catalog data; works on both v1 and v2 APIs. Stock is live, so page cursors can shift between calls. Note: the matrix reflects host-reported versions, but endpoint allowedCudaVersions only accepts values from the platform enum \u2014 check create-endpoint/update-endpoint for the accepted list.",
-    {
-      ...listPaginationParams,
-      cudaVersions: import_zod3.z.array(import_zod3.z.string().regex(/^\d{1,2}\.\d{1,2}$/)).min(1).max(12).optional().describe(
-        'Deep-probe these host CUDA versions (e.g. ["12.8", "13.0"], max 12): one stock lookup per version returns graded stock and price. Omit for the single-call AVAILABLE/UNAVAILABLE matrix across all versions the fleet currently reports.'
-      ),
-      includeUnavailable: import_zod3.z.boolean().optional().describe(
-        'Out-of-stock GPUs are included by default (explicit "Out" cells / all-UNAVAILABLE rows, sorted last). Set false to hide GPUs with no stock on any listed version.'
-      ),
-      gpuTypeIds: import_zod3.z.array(import_zod3.z.string()).optional().describe(
-        "Filter to GPU types matching any of these ids or display names (case-insensitive substring, e.g. ['NVIDIA GeForce RTX 4090'] or ['4090', 'H200'])."
-      ),
-      gpuCount: import_zod3.z.number().int().min(1).max(8).optional().describe("GPUs per worker/pod to check stock for (default 1)."),
-      secureCloudOnly: import_zod3.z.boolean().optional().describe("Restrict the stock lookup to Secure Cloud hosts.")
-    },
-    { title: "Get GPU capacity by CUDA version", ...READ_ONLY },
-    async (params) => {
-      const gpuCount = Math.min(
-        8,
-        Math.max(1, Math.floor(Number(params.gpuCount)) || 1)
-      );
-      const secureArg = params.secureCloudOnly ? ", secureCloud: true" : "";
-      const filterTerms = (params.gpuTypeIds ?? []).filter((t) => typeof t === "string" && t.trim().length > 0).map((t) => t.toLowerCase());
-      const matchesFilter = (gpu) => {
-        if (filterTerms.length === 0) return true;
-        const id = gpu.id.toLowerCase();
-        const name = gpu.displayName.toLowerCase();
-        return filterTerms.some(
-          (term) => id.includes(term) || name.includes(term)
-        );
-      };
-      const stockPriority = {
-        High: 3,
-        Medium: 2,
-        Low: 1
-      };
-      if (!params.cudaVersions?.length) {
-        const data = await graphql(`
-          query {
-            gpuTypes {
-              id
-              displayName
-              memoryInGb
-              secureCloud
-              communityCloud
-              lowestPrice(input: { gpuCount: ${gpuCount}${secureArg} }) {
-                stockStatus
-                uninterruptablePrice
-                gpuTypeCudaVersions {
-                  cudaVersion
-                  availability
-                }
-              }
-            }
-          }
-        `);
-        let rows2 = data.gpuTypes.filter((gpu) => gpu.id !== "unknown" && matchesFilter(gpu)).map((gpu) => {
-          const cuda = {};
-          for (const c of gpu.lowestPrice?.gpuTypeCudaVersions ?? []) {
-            cuda[c.cudaVersion] = c.availability;
-          }
-          return {
-            id: gpu.id,
-            displayName: gpu.displayName,
-            memoryGb: gpu.memoryInGb,
-            secureCloud: gpu.secureCloud,
-            communityCloud: gpu.communityCloud,
-            stockStatus: gpu.lowestPrice?.stockStatus || "unavailable",
-            pricePerHr: gpu.lowestPrice?.uninterruptablePrice ?? null,
-            cudaVersions: cuda
-          };
-        });
-        const availableCount = (r) => Object.values(r.cudaVersions).filter((a) => a === "AVAILABLE").length;
-        if (params.includeUnavailable === false)
-          rows2 = rows2.filter((r) => availableCount(r) > 0);
-        rows2.sort((a, b) => {
-          const diff = availableCount(b) - availableCount(a);
-          if (diff !== 0) return diff;
-          const stockDiff = (stockPriority[b.stockStatus] || 0) - (stockPriority[a.stockStatus] || 0);
-          if (stockDiff !== 0) return stockDiff;
-          return b.memoryGb - a.memoryGb;
-        });
-        return capListResult(rows2, {
-          limit: params.limit,
-          cursor: params.cursor
-        });
-      }
-      const versions = [...new Set(params.cudaVersions)].slice(0, 12);
-      const invalid = versions.filter((v) => !/^\d{1,2}\.\d{1,2}$/.test(v));
-      if (invalid.length > 0) {
-        return jsonReply2({
-          error: `Invalid CUDA version format: ${invalid.join(", ")}. Use "major.minor" strings like "12.8".`,
-          status: 400
-        });
-      }
-      const perVersion = await Promise.allSettled(
-        versions.map(
-          (v) => graphql(`
-            query {
-              gpuTypes {
-                id
-                displayName
-                memoryInGb
-                secureCloud
-                communityCloud
-                lowestPrice(input: { gpuCount: ${gpuCount}, allowedCudaVersions: ["${v}"]${secureArg} }) {
-                  stockStatus
-                  uninterruptablePrice
-                }
-              }
-            }
-          `)
-        )
-      );
-      const probeErrors = {};
-      const byId = /* @__PURE__ */ new Map();
-      versions.forEach((v, i) => {
-        const settled = perVersion[i];
-        if (settled.status === "rejected") {
-          probeErrors[v] = settled.reason instanceof Error ? settled.reason.message : String(settled.reason);
-          return;
-        }
-        for (const gpu of settled.value.gpuTypes) {
-          if (gpu.id === "unknown" || !matchesFilter(gpu)) continue;
-          let row = byId.get(gpu.id);
-          if (!row) {
-            row = {
-              id: gpu.id,
-              displayName: gpu.displayName,
-              memoryGb: gpu.memoryInGb,
-              secureCloud: gpu.secureCloud,
-              communityCloud: gpu.communityCloud,
-              cudaVersions: {}
-            };
-            byId.set(gpu.id, row);
-          }
-          const stock = gpu.lowestPrice?.stockStatus;
-          row.cudaVersions[v] = !stock || stock === "Out" ? { stock: "Out", pricePerHr: null } : {
-            stock,
-            pricePerHr: gpu.lowestPrice?.uninterruptablePrice ?? null
-          };
-        }
-      });
-      let rows = [...byId.values()];
-      const inStockCount = (r) => Object.values(r.cudaVersions).filter((c) => c.stock !== "Out").length;
-      if (params.includeUnavailable === false)
-        rows = rows.filter((r) => inStockCount(r) > 0);
-      rows.sort((a, b) => {
-        const diff = inStockCount(b) - inStockCount(a);
-        if (diff !== 0) return diff;
-        const best = (r) => Math.max(
-          0,
-          ...Object.values(r.cudaVersions).map(
-            (c) => stockPriority[c.stock] || 0
-          )
-        );
-        const bestDiff = best(b) - best(a);
-        if (bestDiff !== 0) return bestDiff;
-        return b.memoryGb - a.memoryGb;
-      });
-      return capListResult(
-        rows,
-        { limit: params.limit, cursor: params.cursor },
-        {
-          probedCudaVersions: versions,
-          ...Object.keys(probeErrors).length > 0 ? { probeErrors } : {}
-        }
-      );
-    }
-  );
-  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_zod3.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/hub.ts
-var import_zod4 = require("zod");
-function parseReleaseConfig(config) {
-  if (!config) return void 0;
-  try {
-    return JSON.parse(config);
-  } catch {
-    return config;
-  }
-}
-function listingsQuery(withConfig) {
-  return `
-    query {
-      listings(input: {}) {
-        id
-        repoId
-        title
-        description
-        repoName
-        repoOwner
-        createdAt
-        updatedAt
-        views
-        stars
-        deploys
-        language
-        category
-        tags
-        type
-        listedRelease {
-          id
-          name
-          tagName
-          createdAt${withConfig ? "\n          config" : ""}
-          build {
-            id
-            imageName
-          }
-        }
-      }
-    }
-  `;
-}
-function serializeBoolean(value, input) {
-  if (value === "true") return input.trueValue ?? "true";
-  if (value === "false") return input.falseValue ?? "false";
-  return value;
-}
-function buildHubEnv(config, overrides) {
-  const env = [];
-  const missingRequired = [];
-  const remaining = { ...overrides };
-  for (const entry of config.env ?? []) {
-    const input = entry.input ?? {};
-    const override = entry.key in remaining ? remaining[entry.key] : void 0;
-    delete remaining[entry.key];
-    if (override !== void 0 && override !== "") {
-      env.push({
-        key: entry.key,
-        value: input.type === "boolean" ? serializeBoolean(override, input) : override
-      });
-      continue;
-    }
-    if (input.default !== void 0 && input.default !== null) {
-      env.push({
-        key: entry.key,
-        value: typeof input.default === "boolean" ? input.default ? input.trueValue ?? "true" : input.falseValue ?? "false" : String(input.default)
-      });
-      continue;
-    }
-    if (input.required) {
-      missingRequired.push(entry.key);
-      env.push({ key: entry.key, value: "" });
-      continue;
-    }
-  }
-  for (const [key, value] of Object.entries(remaining)) {
-    env.push({ key, value });
-  }
-  return { env, missingRequired };
-}
-function minCudaVersion(versions) {
-  if (!versions || versions.length === 0) return null;
-  const compare = (a, b) => {
-    const pa = a.split(".").map(Number);
-    const pb = b.split(".").map(Number);
-    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-      const d = (pa[i] ?? 0) - (pb[i] ?? 0);
-      if (d !== 0) return d;
-    }
-    return 0;
-  };
-  return [...versions].sort(compare)[0];
-}
-function randomSuffix() {
-  return Math.random().toString(36).slice(2, 8);
-}
-function registerHubTools(server, rt) {
-  const { graphql, graphqlAuthed, jsonReply: jsonReply2 } = rt;
-  server.tool(
-    "list-hub-repos",
-    "List repos published to the Runpod Hub (prebuilt Serverless workers and Pod templates, e.g. vLLM, ComfyUI). Public catalog \u2014 no auth required. Each result includes the currently listed release with its hubReleaseId and prebuilt image name. Results are sorted by deploy count (most popular first). Set includeConfig:true to also return the release config (hardware requirements and environment-variable schema) \u2014 it is large, so prefer requesting it for a single repo via the repoOwner/searchTerm filters.",
-    {
-      ...listPaginationParams,
-      searchTerm: import_zod4.z.string().optional().describe(
-        "Case-insensitive search across title, description, repo name, owner, and tags (e.g. 'vllm', 'comfyui', 'fine-tuning')"
-      ),
-      category: import_zod4.z.string().optional().describe(
-        "Filter by category (e.g. 'language', 'image', 'audio', 'video', 'embedding')"
-      ),
-      type: import_zod4.z.enum(["SERVERLESS", "POD"]).optional().describe(
-        "Filter by listing type: SERVERLESS (endpoint workers) or POD (pod templates)"
-      ),
-      repoOwner: import_zod4.z.string().optional().describe(
-        "Filter to listings from this GitHub owner/org (e.g. 'runpod-workers', 'axolotl-ai-cloud')"
-      ),
-      includeConfig: import_zod4.z.boolean().optional().describe(
-        "Include the listed release config (hardware requirements + env-var input schema, parsed from .runpod/hub.json). Large \u2014 off by default."
-      )
-    },
-    { title: "List Hub repos", ...READ_ONLY },
-    async (params) => {
-      const data = await graphql(
-        listingsQuery(params.includeConfig === true)
-      );
-      let listings = data.listings;
-      if (params.type) {
-        listings = listings.filter(
-          (l) => (l.type ?? "").toUpperCase() === params.type
-        );
-      }
-      if (params.category) {
-        const term = params.category.toLowerCase();
-        listings = listings.filter(
-          (l) => (l.category ?? "").toLowerCase() === term
-        );
-      }
-      if (params.repoOwner) {
-        const term = params.repoOwner.toLowerCase();
-        listings = listings.filter(
-          (l) => (l.repoOwner ?? "").toLowerCase() === term
-        );
-      }
-      if (params.searchTerm) {
-        const term = params.searchTerm.toLowerCase();
-        listings = listings.filter(
-          (l) => [
-            l.title,
-            l.description,
-            l.repoName,
-            l.repoOwner,
-            ...l.tags ?? []
-          ].some((field) => (field ?? "").toLowerCase().includes(term))
-        );
-      }
-      listings = [...listings].sort(
-        (a, b) => (b.deploys ?? 0) - (a.deploys ?? 0) || a.id.localeCompare(b.id)
-      );
-      const result = listings.map((l) => ({
-        id: l.id,
-        repo: `${l.repoOwner}/${l.repoName}`,
-        title: l.title,
-        description: l.description,
-        type: l.type,
-        category: l.category,
-        tags: l.tags,
-        language: l.language,
-        stars: l.stars,
-        deploys: l.deploys,
-        views: l.views,
-        githubUrl: `https://github.com/${l.repoOwner}/${l.repoName}`,
-        hubUrl: `https://console.runpod.io/hub/${l.repoOwner}/${l.repoName}`,
-        createdAt: l.createdAt,
-        updatedAt: l.updatedAt,
-        listedRelease: l.listedRelease ? {
-          hubReleaseId: l.listedRelease.id,
-          name: l.listedRelease.name,
-          tagName: l.listedRelease.tagName,
-          createdAt: l.listedRelease.createdAt,
-          imageName: l.listedRelease.build?.imageName,
-          ...params.includeConfig ? { config: parseReleaseConfig(l.listedRelease.config) } : {}
-        } : null
-      }));
-      return capListResult(result, {
-        limit: params.limit,
-        cursor: params.cursor
-      });
-    }
-  );
-  server.tool(
-    "deploy-hub-repo",
-    "Deploy a Runpod Hub repo's listed release as a new Serverless endpoint (the same as clicking Deploy on the Hub). Identify the repo by `repo` (\"owner/name\" from list-hub-repos) or by `hubReleaseId`. The release supplies the prebuilt image, container disk, CUDA constraints, and env-var defaults; pass `env` to override or fill in values (required keys without a default must be provided \u2014 check list-hub-repos with includeConfig:true for the schema). GPU selection comes from the release config when it specifies one; otherwise pass gpuIds (GPU pool names, e.g. 'ADA_24' or 'ADA_80_PRO,AMPERE_80'). Uses the authenticated GraphQL API (no REST home for Hub deploys yet), so it works the same on v1 and v2.",
-    {
-      repo: import_zod4.z.string().optional().describe(
-        `The Hub repo to deploy as "owner/name" (e.g. 'runpod-workers/worker-comfyui'). Deploys its currently listed release. Provide this or hubReleaseId.`
-      ),
-      hubReleaseId: import_zod4.z.string().optional().describe(
-        "The Hub release ID to deploy (from list-hub-repos listedRelease.hubReleaseId). Provide this or repo."
-      ),
-      name: import_zod4.z.string().optional().describe(
-        "Name for the new endpoint. Defaults to '<listing title> <release tag>'."
-      ),
-      env: import_zod4.z.record(import_zod4.z.string()).optional().describe(
-        "Environment variable overrides, merged over the release config defaults. Keys not in the release schema are passed through as-is."
-      ),
-      gpuIds: import_zod4.z.string().optional().describe(
-        "Comma-separated GPU pool names for workers (e.g. 'ADA_24' or 'ADA_80_PRO,AMPERE_80'). To pin specific GPU SKUs within a pool, append exclusions prefixed with '-' using GPU type ids from list-gpu-types (e.g. 'AMPERE_16,-NVIDIA RTX 2000 Ada Generation,-NVIDIA RTX A4500' allows only the pool's remaining SKUs). Defaults to the release config's gpuIds; required when the config does not specify one."
-      ),
-      gpuCount: import_zod4.z.number().int().positive().optional().describe("GPUs per worker. Defaults to the release config (or 1)."),
-      containerDiskInGb: import_zod4.z.number().int().positive().optional().describe("Container disk size in GB. Defaults to the release config."),
-      workersMin: import_zod4.z.number().int().min(0).optional().describe("Minimum workers (default 0 \u2014 scale to zero)."),
-      workersMax: import_zod4.z.number().int().positive().optional().describe("Maximum workers (default: account default)."),
-      idleTimeout: import_zod4.z.number().int().positive().optional().describe("Seconds a worker idles before scaling down (default 5)."),
-      scalerType: import_zod4.z.enum(["QUEUE_DELAY", "REQUEST_COUNT"]).optional().describe("Autoscaler type (default QUEUE_DELAY)."),
-      scalerValue: import_zod4.z.number().optional().describe("Autoscaler target value (default 4)."),
-      executionTimeoutMs: import_zod4.z.number().int().positive().optional().describe("Per-job execution timeout in ms (default 600000)."),
-      flashboot: import_zod4.z.enum(["OFF", "FLASHBOOT", "PRIORITY_FLASHBOOT"]).optional().describe("FlashBoot mode (default FLASHBOOT).")
-    },
-    { title: "Deploy Hub repo", ...WRITE },
-    async (params) => {
-      if (!params.repo && !params.hubReleaseId) {
-        return jsonReply2({
-          error: 'Provide either repo ("owner/name") or hubReleaseId. Use list-hub-repos to discover both.'
-        });
-      }
-      const catalog = await graphql(listingsQuery(true));
-      let listing;
-      if (params.hubReleaseId) {
-        listing = catalog.listings.find(
-          (l) => l.listedRelease?.id === params.hubReleaseId
-        );
-      } else {
-        const repoKey = params.repo.toLowerCase();
-        listing = catalog.listings.find(
-          (l) => `${l.repoOwner}/${l.repoName}`.toLowerCase() === repoKey
-        );
-      }
-      if (!listing) {
-        return jsonReply2({
-          error: `No Hub listing found for ${params.hubReleaseId ? `hubReleaseId "${params.hubReleaseId}" (only each repo's currently listed release is deployable)` : `repo "${params.repo}"`}. Use list-hub-repos to see the catalog.`
-        });
-      }
-      const release = listing.listedRelease;
-      if (!release?.build?.imageName) {
-        return jsonReply2({
-          error: `Hub repo ${listing.repoOwner}/${listing.repoName} has no listed release with a built image, so it cannot be deployed.`
-        });
-      }
-      if ((listing.type ?? "").toUpperCase() !== "SERVERLESS") {
-        return jsonReply2({
-          error: `Hub repo ${listing.repoOwner}/${listing.repoName} is a ${listing.type} listing \u2014 only SERVERLESS listings deploy as endpoints.`
-        });
-      }
-      const config = parseReleaseConfig(release.config) ?? {};
-      const gpuIds = params.gpuIds ?? config.gpuIds;
-      if (!gpuIds) {
-        return jsonReply2({
-          error: 'This release does not specify a GPU pool \u2014 pass gpuIds (comma-separated pool names, e.g. "ADA_80_PRO,AMPERE_80"; see the pool field on list-gpu-types).'
-        });
-      }
-      const { env, missingRequired } = buildHubEnv(config, params.env ?? {});
-      if (missingRequired.length > 0) {
-        return jsonReply2({
-          error: `Missing required environment variables for this release: ${missingRequired.join(
-            ", "
-          )}. Pass them via the env parameter.`
-        });
-      }
-      const endpointName = params.name ?? `${listing.title} ${release.tagName}`;
-      const minCuda = minCudaVersion(config.allowedCudaVersions);
-      const input = {
-        name: endpointName,
-        hubReleaseId: release.id,
-        type: "QB",
-        gpuIds,
-        gpuCount: params.gpuCount ?? config.gpuCount ?? 1,
-        workersMin: params.workersMin ?? 0,
-        workersMax: params.workersMax ?? null,
-        idleTimeout: params.idleTimeout ?? 5,
-        scalerType: params.scalerType ?? "QUEUE_DELAY",
-        scalerValue: params.scalerValue ?? 4,
-        executionTimeoutMs: params.executionTimeoutMs ?? 6e5,
-        flashBootType: params.flashboot ?? "FLASHBOOT",
-        locations: null,
-        networkVolumeIds: null,
-        compliance: [],
-        modelReferences: [],
-        ...minCuda ? {
-          minCudaVersion: minCuda,
-          allowedCudaVersions: config.allowedCudaVersions.join(",")
-        } : {},
-        template: {
-          name: `${endpointName}__template__${randomSuffix()}`,
-          imageName: release.build.imageName,
-          containerDiskInGb: params.containerDiskInGb ?? config.containerDiskInGb ?? 20,
-          containerRegistryAuthId: "",
-          dockerArgs: "",
-          startScript: "",
-          ports: "",
-          env
-        }
-      };
-      const data = await graphqlAuthed(
-        `
-          mutation saveEndpoint($input: EndpointInput!) {
-            saveEndpoint(input: $input) {
-              id
-              name
-              gpuIds
-              gpuCount
-              workersMin
-              workersMax
-              idleTimeout
-              scalerType
-              scalerValue
-              flashBootType
-              templateId
-            }
-          }
-        `,
-        { input }
-      );
-      return jsonReply2({
-        endpoint: data.saveEndpoint,
-        deployed: {
-          repo: `${listing.repoOwner}/${listing.repoName}`,
-          release: release.tagName,
-          hubReleaseId: release.id,
-          imageName: release.build.imageName
-        },
-        note: `Endpoint created. Submit jobs with run-endpoint/runsync-endpoint using endpointId "${data.saveEndpoint.id}".`
-      });
-    }
-  );
-}
-
-// src/tools/public-endpoints.ts
-var import_zod5 = require("zod");
-function parseMetadata(metadata) {
-  if (!metadata) return {};
-  try {
-    const parsed = JSON.parse(metadata);
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function registerPublicEndpointTools(server, rt) {
-  const { graphql } = rt;
-  server.tool(
-    "list-public-endpoints",
-    "List Runpod Public Endpoints \u2014 managed, pay-per-use model APIs (text, image, video, audio) that require no deployment. Public catalog, no auth required. Each result includes the endpointId to call with run-endpoint/runsync-endpoint (or via https://api.runpod.ai/v2/{endpointId}), the model name, modality, owner, and pricing. Only live endpoints are returned by default; set includeOffline:true to also list ones that are not currently live.",
-    {
-      ...listPaginationParams,
-      searchTerm: import_zod5.z.string().optional().describe(
-        "Case-insensitive search across display name, model name, endpoint id, description, owner, and tag (e.g. 'kimi', 'video', 'flux')"
-      ),
-      modality: import_zod5.z.string().optional().describe(
-        "Filter by modality/category (the metadata source field, e.g. 'language', 'image', 'video', 'audio')"
-      ),
-      owner: import_zod5.z.string().optional().describe(
-        "Filter by model owner (e.g. 'moonshot', 'minimax', 'google')"
-      ),
-      includeOffline: import_zod5.z.boolean().optional().describe(
-        "Include endpoints that are not currently live (isLive:false). Default false \u2014 only live endpoints are listed."
-      )
-    },
-    { title: "List public endpoints", ...READ_ONLY },
-    async (params) => {
-      const data = await graphql(`
-        query {
-          allAiApiPublicConfigs {
-            id
-            aiApiId
-            modelName
-            displayName
-            description
-            metadata
-            isLive
-            createdAt
-            updatedAt
-          }
-        }
-      `);
-      let configs = data.allAiApiPublicConfigs.map((c) => ({
-        config: c,
-        meta: parseMetadata(c.metadata)
-      }));
-      if (!params.includeOffline) {
-        configs = configs.filter(({ config }) => config.isLive);
-      }
-      if (params.modality) {
-        const term = params.modality.toLowerCase();
-        configs = configs.filter(
-          ({ meta }) => (meta.source ?? "").toLowerCase() === term
-        );
-      }
-      if (params.owner) {
-        const term = params.owner.toLowerCase();
-        configs = configs.filter(
-          ({ meta }) => (meta.owner ?? "").toLowerCase() === term
-        );
-      }
-      if (params.searchTerm) {
-        const term = params.searchTerm.toLowerCase();
-        configs = configs.filter(
-          ({ config, meta }) => [
-            config.displayName,
-            config.modelName,
-            config.aiApiId,
-            config.description,
-            meta.owner,
-            meta.tag,
-            meta.source
-          ].some((field) => (field ?? "").toLowerCase().includes(term))
-        );
-      }
-      configs = [...configs].sort(
-        (a, b) => a.config.displayName.localeCompare(b.config.displayName)
-      );
-      const result = configs.map(({ config, meta }) => ({
-        endpointId: config.aiApiId,
-        displayName: config.displayName,
-        modelName: config.modelName,
-        description: config.description,
-        modality: meta.source,
-        tag: meta.tag,
-        owner: meta.owner,
-        pricing: meta.priceString,
-        isLive: config.isLive,
-        baseUrl: `https://api.runpod.ai/v2/${config.aiApiId}`,
-        createdAt: config.createdAt,
-        updatedAt: config.updatedAt
-      }));
-      return capListResult(result, {
-        limit: params.limit,
-        cursor: params.cursor
-      });
-    }
-  );
-}
-
-// src/tools/endpoint-gpus.ts
-var import_zod6 = require("zod");
-function registerEndpointGpuTools(server, rt) {
-  const { graphqlAuthed, jsonReply: jsonReply2 } = rt;
-  server.tool(
-    "set-endpoint-gpus",
-    "Set which GPUs a Serverless endpoint's workers run on \u2014 including pinning specific GPU SKUs, which create-endpoint/update-endpoint cannot express. Provide either a raw gpuIds string, or pools plus optional excludeGpuTypeIds (GPU type ids from list-gpu-types) and the exclusion string is built for you: a pool allows every SKU in it, and excluding all but one SKU pins that SKU exactly (e.g. pools:['AMPERE_16'], excludeGpuTypeIds:['NVIDIA RTX 2000 Ada Generation','NVIDIA RTX 4000 Ada Generation','NVIDIA RTX A4500'] pins RTX A4000). All other endpoint settings (workers, scaling, timeouts, template) are read first and preserved. Works on any Serverless endpoint via the authenticated GraphQL API.",
-    {
-      endpointId: import_zod6.z.string().describe("ID of the Serverless endpoint to update"),
-      gpuIds: import_zod6.z.string().optional().describe(
-        "Raw gpuIds string, e.g. 'ADA_24' or 'AMPERE_16,-NVIDIA RTX A4500'. Takes precedence over pools/excludeGpuTypeIds."
-      ),
-      pools: import_zod6.z.array(import_zod6.z.string()).optional().describe(
-        "GPU pool names workers may use (e.g. ['ADA_80_PRO','AMPERE_80']). The pool field from list-gpu-types."
-      ),
-      excludeGpuTypeIds: import_zod6.z.array(import_zod6.z.string()).optional().describe(
-        "GPU type ids to exclude from the allowed pools (e.g. ['NVIDIA H100 NVL']). Use with pools to pin specific SKUs."
-      ),
-      gpuCount: import_zod6.z.number().int().positive().optional().describe("GPUs per worker. Omit to keep the current value."),
-      minCudaVersion: import_zod6.z.string().optional().describe(
-        "Minimum host CUDA version workers may run on (e.g. '12.4'). Omit to keep the current value."
-      ),
-      allowedCudaVersions: import_zod6.z.string().optional().describe(
-        "Comma-separated allowed host CUDA versions (e.g. '12.8,12.7,12.6'). Omit to keep the current value. CUDA compatibility is part of GPU selection \u2014 a narrow list can leave an endpoint unable to schedule workers."
-      )
-    },
-    { title: "Set endpoint GPUs", ...WRITE, idempotentHint: true },
-    async (params) => {
-      const gpuIds = params.gpuIds ?? (params.pools && params.pools.length > 0 ? [
-        ...params.pools,
-        ...(params.excludeGpuTypeIds ?? []).map((id) => `-${id}`)
-      ].join(",") : void 0);
-      if (!gpuIds) {
-        return jsonReply2({
-          error: "Provide gpuIds (raw string) or pools (with optional excludeGpuTypeIds). See list-gpu-types for pool names and GPU type ids."
-        });
-      }
-      const data = await graphqlAuthed(`
-        query {
-          myself {
-            endpoints {
-              id
-              name
-              gpuIds
-              gpuCount
-              workersMin
-              workersMax
-              idleTimeout
-              scalerType
-              scalerValue
-              executionTimeoutMs
-              flashBootType
-              type
-              locations
-              templateId
-              allowedCudaVersions
-              minCudaVersion
-              compliance
-              modelReferences
-              networkVolumeIds {
-                networkVolumeId
-                dataCenterId
-              }
-            }
-          }
-        }
-      `);
-      const current = data.myself.endpoints.find(
-        (e) => e.id === params.endpointId
-      );
-      if (!current) {
-        return jsonReply2({
-          error: `No Serverless endpoint found with id "${params.endpointId}". Use list-endpoints to see your endpoints.`
-        });
-      }
-      const input = {
-        id: current.id,
-        name: current.name,
-        gpuIds,
-        gpuCount: params.gpuCount ?? current.gpuCount,
-        workersMin: current.workersMin,
-        workersMax: current.workersMax,
-        idleTimeout: current.idleTimeout,
-        scalerType: current.scalerType,
-        scalerValue: current.scalerValue,
-        executionTimeoutMs: current.executionTimeoutMs,
-        flashBootType: current.flashBootType,
-        type: current.type,
-        locations: current.locations,
-        networkVolumeIds: current.networkVolumeIds && current.networkVolumeIds.length > 0 ? (
-          // Drop dataCenterId: NetworkVolumeIdsInput takes networkVolumeId
-          // ONLY, and the read shape is rejected outright.
-          current.networkVolumeIds.map((v) => ({
-            networkVolumeId: v.networkVolumeId
-          }))
-        ) : null
-      };
-      for (const [key, value] of Object.entries({
-        templateId: current.templateId,
-        allowedCudaVersions: params.allowedCudaVersions ?? current.allowedCudaVersions,
-        minCudaVersion: params.minCudaVersion ?? current.minCudaVersion,
-        compliance: current.compliance,
-        modelReferences: current.modelReferences
-      })) {
-        if (value !== null && value !== void 0) input[key] = value;
-      }
-      const result = await graphqlAuthed(
-        `
-          mutation saveEndpoint($input: EndpointInput!) {
-            saveEndpoint(input: $input) {
-              id
-              name
-              gpuIds
-              gpuCount
-              workersMin
-              workersMax
-            }
-          }
-        `,
-        { input }
-      );
-      return jsonReply2({
-        endpoint: result.saveEndpoint,
-        previousGpuIds: current.gpuIds
-      });
-    }
-  );
-}
-
-// src/tools/pods.ts
-var import_zod7 = 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.",
-    {
-      ...listPaginationParams,
-      computeType: import_zod7.z.enum(["GPU", "CPU"]).optional().describe("Filter to only GPU or only CPU Pods"),
-      gpuTypeId: import_zod7.z.array(import_zod7.z.string()).optional().describe("Filter to Pods with any of the listed GPU types"),
-      dataCenterId: import_zod7.z.array(import_zod7.z.string()).optional().describe("Filter to Pods in any of the provided data centers"),
-      name: import_zod7.z.string().optional().describe("Filter to Pods with the provided name"),
-      includeMachine: import_zod7.z.boolean().optional().describe("Include information about the machine"),
-      includeNetworkVolume: import_zod7.z.boolean().optional().describe("Include information about attached network volumes")
-    },
-    { title: "List pods", ...READ_ONLY },
-    async (params) => {
-      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
-      });
-    }
-  );
-  server.tool(
-    "get-pod",
-    "Get full details for one pod by id, optionally expanding machine and attached network-volume info.",
-    {
-      podId: import_zod7.z.string().describe("ID of the pod to retrieve"),
-      includeMachine: import_zod7.z.boolean().optional().describe("Include information about the machine"),
-      includeNetworkVolume: import_zod7.z.boolean().optional().describe("Include information about attached network volumes")
-    },
-    { title: "Get pod", ...READ_ONLY },
-    async (params) => {
-      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);
-    }
-  );
-  server.tool(
-    "create-pod",
-    'Create a new GPU/CPU pod on Runpod. Pass gpuTypeIds for a GPU pod, or computeType:"CPU" for a CPU pod (CPU pods are served by the v1 API for now). Pass either imageName or templateId (templateId deploys from an existing template \u2014 its name, image, start command, ports, env, disk, volume, and registry credential are used as defaults, and any field you also pass explicitly replaces the template value for that field, e.g. passing env replaces the whole env set rather than merging; pass containerRegistryAuthId to override or supply a private-image credential, or an empty string to deploy with none). For full SSH access (including SCP/SFTP/rsync), pass sshPublicKey \u2014 it sets the PUBLIC_KEY env var and exposes 22/tcp, which official Runpod images turn into a running sshd with the key authorized. If the user specifies neither an image nor a template, recommend the "Runpod Pytorch 2.8.0" image (runpod/pytorch:1.0.2-cu1281-torch280-ubuntu2404) as the default \u2014 it has the most up-to-date CUDA and PyTorch versions.',
-    {
-      name: import_zod7.z.string().optional().describe(
-        "Name for the pod. Required on v2 unless deploying from a templateId (the template supplies its name as the default)."
-      ),
-      imageName: import_zod7.z.string().optional().describe("Docker image to use. Optional when templateId is provided."),
-      templateId: import_zod7.z.string().optional().describe(
-        "Deploy from an existing template (see list-templates / get-template). The template supplies name, image, start command, ports, env, disk, volume, and registry credential as defaults; any field you also pass replaces the template value for that field (whole-field, not a merge). Override the registry credential with containerRegistryAuthId. Requires the v2 REST API. Still pass gpuTypeIds or computeType to choose the compute \u2014 a template does not pin the pod compute."
-      ),
-      computeType: import_zod7.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_zod7.z.enum(["SECURE", "COMMUNITY"]).optional().describe("SECURE or COMMUNITY cloud"),
-      gpuTypeIds: import_zod7.z.array(import_zod7.z.string()).optional().describe("List of acceptable GPU types"),
-      // v2 GpuConfig.count is `integer, minimum: 1`. Without these bounds a 0,
-      // a negative, or a fractional count reached the wire as-is and came back
-      // as a raw 422; reject it here with a message that names the field.
-      gpuCount: import_zod7.z.number().int().min(1).optional().describe("Number of GPUs (minimum 1)"),
-      containerDiskInGb: import_zod7.z.number().optional().describe("Container disk size in GB"),
-      volumeInGb: import_zod7.z.number().optional().describe("Volume size in GB"),
-      volumeMountPath: import_zod7.z.string().optional().describe("Path to mount the volume"),
-      ports: import_zod7.z.array(import_zod7.z.string()).optional().describe("Ports to expose (e.g., '8888/http', '22/tcp')"),
-      env: import_zod7.z.record(import_zod7.z.string()).optional().describe("Environment variables"),
-      sshPublicKey: import_zod7.z.string().optional().describe(
-        'SSH PUBLIC key(s) to authorize on the pod \u2014 the CONTENTS of your ~/.ssh/<key>.pub file, i.e. a literal "ssh-ed25519 AAAAC3Nza\u2026 you@host" line, NOT a path to the file, a fingerprint, or the private key; newline-separate multiple keys. Merges the key into the PUBLIC_KEY env var and ensures 22/tcp is exposed, enabling full SSH (SCP/SFTP/rsync) on any image that honors the PUBLIC_KEY convention \u2014 all runpod/* official images do. Extends template ports/env rather than replacing them.'
-      ),
-      containerRegistryAuthId: import_zod7.z.string().optional().describe(
-        "Container registry credential ID for pulling a private image (see list-container-registry-auths). When deploying from a templateId, this overrides the credential the template carries; pass an empty string to deploy with NO credential (clears a template\u2019s inherited registry)."
-      ),
-      dataCenterIds: import_zod7.z.array(import_zod7.z.string()).optional().describe("List of data centers"),
-      allowedCudaVersions: import_zod7.z.array(import_zod7.z.string()).optional().describe(
-        'Acceptable host CUDA versions as major.minor, e.g. ["12.8","12.6"] (v2, GPU pods only). Exact match \u2014 discover valid values per GPU type with get-capacity. Mutually exclusive with minCudaVersion.'
-      ),
-      minCudaVersion: import_zod7.z.string().optional().describe(
-        'Lowest acceptable host CUDA version as major.minor, e.g. "12.4" (v2, GPU pods only). A bare major like "12" is rejected. Open-ended floor; mutually exclusive with a non-empty allowedCudaVersions.'
-      )
-    },
-    { title: "Create pod", ...WRITE },
-    async (params) => {
-      const backend = backendFor("pods");
-      const { sshPublicKey, ...podParams } = params;
-      let sshKey;
-      if (sshPublicKey !== void 0) {
-        const validated = normalizeSshPublicKey(sshPublicKey);
-        if (!validated.ok)
-          return jsonReply2({ error: validated.error, status: 400 });
-        sshKey = validated.key;
-      }
-      const sshNote = "sshPublicKey applied: PUBLIC_KEY env set and 22/tcp exposed. Full SSH (incl. SCP/SFTP/rsync) also requires an image that installs PUBLIC_KEY into authorized_keys and starts sshd (all runpod/* official images do) and a machine with a public IP \u2014 read the pod\u2019s portMappings for port 22 once it is running.";
-      const hasCudaParams = params.allowedCudaVersions !== void 0 || params.minCudaVersion !== void 0;
-      if (hasCudaParams && backend.version !== "v2") {
-        return jsonReply2({
-          error: "allowedCudaVersions/minCudaVersion are only supported on the v2 REST API. Set RUNPOD_REST_VERSION=v2.",
-          status: 501
-        });
-      }
-      if (params.templateId && backend.version !== "v2") {
-        return jsonReply2({
-          error: "Deploying a pod from a templateId is only supported on the v2 REST API. Set RUNPOD_REST_VERSION=v2, or pass imageName instead.",
-          status: 501
-        });
-      }
-      if (!params.imageName && !params.templateId) {
-        return jsonReply2({
-          error: "Provide imageName, or templateId to deploy from an existing template.",
-          status: 400
-        });
-      }
-      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 (hasCudaParams && !wantsGpu) {
-          return jsonReply2({
-            error: "allowedCudaVersions/minCudaVersion apply to GPU pods only \u2014 pass gpuTypeIds (see list-gpu-types).",
-            status: 400
-          });
-        }
-        if (hasCudaParams) {
-          const cudaError = cudaConstraintError(params);
-          if (cudaError) return jsonReply2({ error: cudaError, status: 400 });
-        }
-        if (!wantsCpu && !params.name && !params.templateId) {
-          return jsonReply2({
-            error: "Provide a name for the pod (deploying from a templateId inherits the template name).",
-            status: 400
-          });
-        }
-        if (wantsCpu) {
-          if (params.templateId) {
-            return jsonReply2({
-              error: "Template-based deploy is currently supported only for GPU pods on the v2 API. Create the CPU pod with an explicit imageName instead.",
-              status: 400
-            });
-          }
-          try {
-            const cpuBody = sshKey ? applySshPublicKey(podParams, sshKey) : podParams;
-            const result = await callRestUrl(
-              `${restV1Base(env)}/pods`,
-              "POST",
-              cpuBody
-            );
-            return jsonReply2({
-              ...result,
-              ...sshKey ? { _ssh: sshNote } : {},
-              _servedBy: "v1",
-              _note: "CPU pod: created on the v1 API, because the v2 REST API does not support CPU pods yet."
-            });
-          } 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;
-          }
-        }
-      }
-      let body = backend.mapCreate(podParams);
-      if (params.templateId) {
-        let template;
-        try {
-          template = await callRestUrl(
-            `${restV2Base(env)}/templates/${params.templateId}`
-          );
-        } catch (error) {
-          if (error instanceof HttpError) {
-            return jsonReply2({
-              error: `Failed to load template ${params.templateId}: ${error.message}`,
-              status: error.status
-            });
-          }
-          throw error;
-        }
-        body = { ...podBodyFromTemplate(template), ...body };
-      }
-      if (sshKey) body = applySshPublicKey(body, sshKey);
-      try {
-        const result = await callRestUrl(
-          `${backend.base}${backend.list}`,
-          "POST",
-          body
-        );
-        const extras = {};
-        if (sshKey) extras._ssh = sshNote;
-        if (backend.version === "v2" && (params.gpuTypeIds?.length ?? 0) > 1) {
-          extras._warning = `v2 accepts one GPU type per pod; used "${params.gpuTypeIds[0]}" and ignored ${params.gpuTypeIds.length - 1} other(s): ${params.gpuTypeIds.slice(1).join(", ")}.`;
-        }
-        return jsonReply2(
-          Object.keys(extras).length ? { ...result, ...extras } : result
-        );
-      } catch (error) {
-        if (error instanceof HttpError) {
-          return jsonReply2({ error: error.message, status: error.status });
-        }
-        throw error;
-      }
-    }
-  );
-  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_zod7.z.string().describe("ID of the pod to update"),
-      name: import_zod7.z.string().optional().describe("New name for the pod"),
-      imageName: import_zod7.z.string().optional().describe("New Docker image"),
-      containerDiskInGb: import_zod7.z.number().optional().describe("New container disk size in GB"),
-      volumeInGb: import_zod7.z.number().optional().describe("New volume size in GB"),
-      volumeMountPath: import_zod7.z.string().optional().describe("New path to mount the volume"),
-      ports: import_zod7.z.array(import_zod7.z.string()).optional().describe("New ports to expose"),
-      env: import_zod7.z.record(import_zod7.z.string()).optional().describe("New environment variables")
-    },
-    { title: "Update pod", ...WRITE, idempotentHint: true },
-    async (params) => {
-      const { podId, ...updateParams } = params;
-      const backend = backendFor("pods");
-      const body = backend.mapUpdate(updateParams);
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(podId)}`,
-        "PATCH",
-        body
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "start-pod",
-    "Start a stopped pod (resumes the same pod and its billing).",
-    {
-      podId: import_zod7.z.string().describe("ID of the pod to start")
-    },
-    { title: "Start pod", ...WRITE, idempotentHint: true },
-    async (params) => {
-      const result = await podAction(params.podId, "start");
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "stop-pod",
-    "Stop a running pod. The pod and its disk persist; GPU billing stops.",
-    {
-      podId: import_zod7.z.string().describe("ID of the pod to stop")
-    },
-    { title: "Stop pod", ...WRITE, idempotentHint: true },
-    async (params) => {
-      const result = await podAction(params.podId, "stop");
-      return jsonReply2(result);
-    }
-  );
-  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_zod7.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(
-    "stream-pod-logs",
-    "Fetch a bounded snapshot of a pod's live logs (container and/or system) via Server-Sent Events. v2-only \u2014 returns a 501 notice on the v1 API. Reads for up to maxWaitMs (default 5s) and returns the collected log lines; use `tail` to backfill recent lines first. Large output is truncated (see the `truncated` flag).",
-    {
-      podId: import_zod7.z.string().describe("ID of the pod whose logs to stream"),
-      ...logStreamParams
-    },
-    { title: "Stream pod logs", ...READ_ONLY },
-    (params) => streamLogsReply(
-      rt,
-      {
-        name: "stream-pod-logs",
-        resource: "pods",
-        logsUrl: (backend) => `${backend.base}${backend.get(encodeURIComponent(params.podId))}/logs`
-      },
-      params
-    )
-  );
-  server.tool(
-    "delete-pod",
-    "Permanently delete a pod and its data. This cannot be undone.",
-    {
-      podId: import_zod7.z.string().describe("ID of the pod to delete")
-    },
-    { title: "Delete pod", ...DESTRUCTIVE },
-    async (params) => {
-      const backend = backendFor("pods");
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.podId)}`,
-        "DELETE"
-      );
-      return jsonReply2(result);
-    }
-  );
-}
-
-// src/tools/endpoints.ts
-var import_zod8 = require("zod");
-var MIN_QUEUE_DELAY = 0.5;
-var MIN_REQUEST_COUNT = 1;
-function isRequestCountScaler(type) {
-  return type === "REQUEST_COUNT";
-}
-var MIN_IDLE_TIMEOUT = 1;
-var MAX_IDLE_TIMEOUT = 3600;
-function scalerValueError(scalerType, scalerValue) {
-  if (scalerType !== "REQUEST_COUNT" || scalerValue === void 0) return;
-  if (!Number.isInteger(scalerValue) || scalerValue < MIN_REQUEST_COUNT) {
-    return `REQUEST_COUNT scales on whole in-flight requests per worker, so scalerValue must be an integer >= ${MIN_REQUEST_COUNT} (got ${scalerValue}). For a fractional target use scalerType QUEUE_DELAY, which takes seconds >= ${MIN_QUEUE_DELAY}.`;
-  }
-  return;
-}
-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. On v2 each endpoint carries its request routing in `type` and the URLs to call it in `requestUrls`.",
-    {
-      ...listPaginationParams,
-      includeTemplate: import_zod8.z.boolean().optional().describe("Include template information (v1 only)"),
-      includeWorkers: import_zod8.z.boolean().optional().describe("Include information about workers (v1 only)")
-    },
-    { title: "List endpoints", ...READ_ONLY },
-    async (params) => {
-      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
-      });
-    }
-  );
-  server.tool(
-    "get-endpoint",
-    "Get one Serverless endpoint by id, optionally expanding template and worker details (v1 only). On v2 the reply carries `type` (queue-based vs load-balancing routing) and `requestUrls` \u2014 the run/runsync/status/... URLs for a queue endpoint, or the base + health URLs for a load-balancing one. Read those rather than constructing endpoint URLs by hand.",
-    {
-      endpointId: import_zod8.z.string().describe("ID of the endpoint to retrieve"),
-      includeTemplate: import_zod8.z.boolean().optional().describe("Include template information (v1 only)"),
-      includeWorkers: import_zod8.z.boolean().optional().describe("Include information about workers (v1 only)")
-    },
-    { title: "Get endpoint", ...READ_ONLY },
-    async (params) => {
-      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 jsonReply2(result);
-    }
-  );
-  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). Use endpointType to pick queue-based (default) or load-balancing request routing; the response `requestUrls` carries the URLs to call the endpoint with.",
-    {
-      name: import_zod8.z.string().optional().describe("Name for the endpoint"),
-      // --- v2 inline-config fields ---
-      imageName: import_zod8.z.string().optional().describe("Docker image (v2). Required on v2 instead of a templateId."),
-      endpointType: import_zod8.z.enum(["QUEUE", "LOAD_BALANCER"]).optional().describe(
-        "How requests reach the workers (v2). QUEUE (default) = submit jobs through the managed queue (run/runsync/status/...). LOAD_BALANCER = send HTTP requests straight to worker-defined paths, and forces scalerType REQUEST_COUNT. Fixed at creation \u2014 update-endpoint cannot change it."
-      ),
-      gpuPoolIds: import_zod8.z.array(import_zod8.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_zod8.z.number().optional().describe("GPUs per worker (v2)"),
-      allowedCudaVersions: import_zod8.z.array(import_zod8.z.string()).optional().describe(
-        'Acceptable host CUDA versions for worker placement as major.minor, e.g. ["12.8"] (v2). Exact match \u2014 see get-capacity for which versions have stock. Mutually exclusive with minCudaVersion.'
-      ),
-      minCudaVersion: import_zod8.z.string().optional().describe(
-        'Lowest acceptable host CUDA version as major.minor, e.g. "12.4" (v2). A bare major like "12" is rejected. Mutually exclusive with a non-empty allowedCudaVersions.'
-      ),
-      args: import_zod8.z.string().optional().describe("Container start command/args (v2)"),
-      containerDiskInGb: import_zod8.z.number().optional().describe("Container disk size in GB (v2)"),
-      ports: import_zod8.z.array(import_zod8.z.string()).optional().describe("Ports to expose (v2), e.g. ['8000/http']"),
-      env: import_zod8.z.record(import_zod8.z.string()).optional().describe("Environment variables (v2)"),
-      containerRegistryAuthId: import_zod8.z.string().optional().describe("Container registry auth id for a private image (v2)"),
-      networkVolumeIds: import_zod8.z.array(import_zod8.z.string()).optional().describe("Network volume ids to attach (v2)"),
-      executionTimeoutMs: import_zod8.z.number().optional().describe("Per-job execution timeout in ms (v2)"),
-      flashboot: import_zod8.z.enum(["OFF", "FLASHBOOT", "PRIORITY_FLASHBOOT"]).optional().describe("FlashBoot mode (v2)"),
-      // --- v1 template-based fields ---
-      templateId: import_zod8.z.string().optional().describe("Template ID (v1). Required on v1."),
-      computeType: import_zod8.z.enum(["GPU", "CPU"]).optional().describe("GPU or CPU endpoint (v1)"),
-      gpuTypeIds: import_zod8.z.array(import_zod8.z.string()).optional().describe("List of acceptable GPU types (v1)"),
-      // --- shared autoscaling fields ---
-      workersMin: import_zod8.z.number().optional().describe("Minimum number of workers"),
-      workersMax: import_zod8.z.number().optional().describe("Maximum number of workers"),
-      scalerType: import_zod8.z.enum(["QUEUE_DELAY", "REQUEST_COUNT"]).optional().describe(
-        "Autoscaler signal. QUEUE_DELAY scales on how long requests wait in the queue (queue endpoints only); REQUEST_COUNT scales on in-flight requests per worker. Defaults to QUEUE_DELAY for QUEUE endpoints and REQUEST_COUNT for LOAD_BALANCER ones."
-      ),
-      scalerValue: import_zod8.z.number().min(MIN_QUEUE_DELAY).optional().describe(
-        "Autoscaler target for the chosen scalerType \u2014 seconds of queue delay (min 0.5) or in-flight requests per worker (integer, min 1). Defaults to 4."
-      ),
-      idleTimeout: import_zod8.z.number().int().min(MIN_IDLE_TIMEOUT).max(MAX_IDLE_TIMEOUT).optional().describe(
-        "Idle timeout in seconds before scaling a worker down (1-3600). Does not apply to QUEUE endpoints scaling on REQUEST_COUNT."
-      ),
-      dataCenterIds: import_zod8.z.array(import_zod8.z.string()).optional().describe("List of preferred data centers")
-    },
-    { title: "Create endpoint", ...WRITE },
-    async (params) => {
-      const backend = backendFor("endpoints");
-      const hasCudaParams = params.allowedCudaVersions !== void 0 || params.minCudaVersion !== void 0;
-      if (hasCudaParams && backend.version !== "v2") {
-        return jsonReply2({
-          error: "allowedCudaVersions/minCudaVersion are only supported on the v2 REST API. Set RUNPOD_REST_VERSION=v2.",
-          status: 501
-        });
-      }
-      if (backend.version === "v2") {
-        if (!params.name) {
-          return jsonReply2({
-            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
-          });
-        }
-        if (params.endpointType === "LOAD_BALANCER" && params.scalerType === "QUEUE_DELAY") {
-          return jsonReply2({
-            error: "LOAD_BALANCER endpoints have no request queue, so they cannot scale on QUEUE_DELAY. Use scalerType REQUEST_COUNT (the default for this endpoint type), or create a QUEUE endpoint instead.",
-            status: 400
-          });
-        }
-        const scalerError = scalerValueError(
-          params.scalerType ?? (params.endpointType === "LOAD_BALANCER" ? "REQUEST_COUNT" : void 0),
-          params.scalerValue
-        );
-        if (scalerError) {
-          return jsonReply2({ error: scalerError, status: 400 });
-        }
-        if (hasCudaParams) {
-          const cudaError = cudaConstraintError(params);
-          if (cudaError) return jsonReply2({ error: cudaError, status: 400 });
-        }
-        const body = backend.mapCreate(params);
-        const result2 = await callRestUrl(
-          `${backend.base}${backend.list}`,
-          "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);
-    }
-  );
-  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, plus the GPU selection (gpuPoolIds/gpuCount) and its CUDA constraints (allowedCudaVersions/minCudaVersion) \u2014 CUDA-only or count-only changes do not require resending gpuPoolIds; on v1, scaling fields (worker min/max, idle timeout, scaler type/value, name). Only provided fields change. An endpoint's request routing (queue vs load balancer) is fixed at creation and cannot be changed here \u2014 recreate the endpoint instead. Note: passing gpuPoolIds replaces the GPU selection wholesale, which clears any GPU-type exclusions set elsewhere (console or set-endpoint-gpus) \u2014 the reply carries a _warning when that happens.",
-    {
-      endpointId: import_zod8.z.string().describe("ID of the endpoint to update"),
-      name: import_zod8.z.string().optional().describe("New name for the endpoint"),
-      workersMin: import_zod8.z.number().optional().describe("New minimum number of workers"),
-      workersMax: import_zod8.z.number().optional().describe("New maximum number of workers"),
-      idleTimeout: import_zod8.z.number().int().min(MIN_IDLE_TIMEOUT).max(MAX_IDLE_TIMEOUT).optional().describe(
-        "New idle timeout in seconds (1-3600). Does not apply to queue endpoints scaling on REQUEST_COUNT."
-      ),
-      scalerType: import_zod8.z.enum(["QUEUE_DELAY", "REQUEST_COUNT"]).optional().describe(
-        "New autoscaler signal. Switchable on queue endpoints; load-balancing endpoints only accept REQUEST_COUNT."
-      ),
-      scalerValue: import_zod8.z.number().min(MIN_QUEUE_DELAY).optional().describe(
-        "New autoscaler target \u2014 seconds of queue delay (min 0.5) or in-flight requests per worker (integer, min 1). Applies to the endpoint's current scalerType unless you also pass a new one."
-      ),
-      // --- v2-only inline-config fields ---
-      imageName: import_zod8.z.string().optional().describe("New Docker image (v2)"),
-      gpuPoolIds: import_zod8.z.array(import_zod8.z.string()).optional().describe('New GPU pool names (v2), e.g. ["AMPERE_80"]'),
-      gpuCount: import_zod8.z.number().optional().describe("New GPUs per worker (v2)"),
-      allowedCudaVersions: import_zod8.z.array(import_zod8.z.string()).optional().describe(
-        "New acceptable host CUDA versions as major.minor (v2). Changing only this does not require resending gpuPoolIds. An explicit [] clears the constraint. Mutually exclusive with minCudaVersion."
-      ),
-      minCudaVersion: import_zod8.z.string().optional().describe(
-        'New lowest acceptable host CUDA version as major.minor (v2). An empty string clears the floor; a bare major like "12" is rejected. Mutually exclusive with a non-empty allowedCudaVersions.'
-      ),
-      args: import_zod8.z.string().optional().describe("New container args (v2)"),
-      containerDiskInGb: import_zod8.z.number().optional().describe("New container disk size in GB (v2)"),
-      ports: import_zod8.z.array(import_zod8.z.string()).optional().describe("New ports (v2)"),
-      env: import_zod8.z.record(import_zod8.z.string()).optional().describe("New environment variables (v2)"),
-      containerRegistryAuthId: import_zod8.z.string().optional().describe("New container registry auth id (v2)"),
-      networkVolumeIds: import_zod8.z.array(import_zod8.z.string()).optional().describe("New network volume ids (v2)"),
-      executionTimeoutMs: import_zod8.z.number().optional().describe("New per-job execution timeout in ms (v2)"),
-      flashboot: import_zod8.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 backend = backendFor("endpoints");
-      const url = `${backend.base}${backend.get(endpointId)}`;
-      const hasCudaParams = updateParams.allowedCudaVersions !== void 0 || updateParams.minCudaVersion !== void 0;
-      if (backend.version !== "v2") {
-        if (hasCudaParams) {
-          return jsonReply2({
-            error: "allowedCudaVersions/minCudaVersion are only supported on the v2 REST API. Set RUNPOD_REST_VERSION=v2.",
-            status: 501
-          });
-        }
-        const body2 = backend.mapUpdate(updateParams);
-        return jsonReply2(await callRestUrl(url, "PATCH", body2));
-      }
-      if (hasCudaParams) {
-        const cudaError = cudaConstraintError(updateParams, {
-          allowClear: true
-        });
-        if (cudaError) return jsonReply2({ error: cudaError, status: 400 });
-      }
-      if (updateParams.gpuPoolIds !== void 0 && !updateParams.gpuPoolIds.length) {
-        return jsonReply2({
-          error: "gpuPoolIds cannot be empty \u2014 omit it to keep the current GPU selection.",
-          status: 400
-        });
-      }
-      let scalerType = updateParams.scalerType;
-      const needScalerRead = scalerType === void 0 && updateParams.scalerValue !== void 0;
-      const needExclusionRead = (updateParams.gpuPoolIds?.length ?? 0) > 0;
-      let clearedExclusions = [];
-      if (needScalerRead || needExclusionRead) {
-        const current = await callRestUrl(url);
-        if (needScalerRead) {
-          scalerType = isRequestCountScaler(current?.scaling?.type) ? "REQUEST_COUNT" : "QUEUE_DELAY";
-        }
-        if (needExclusionRead && current?.gpu?.excludedTypes?.length) {
-          clearedExclusions = current.gpu.excludedTypes;
-        }
-      }
-      const scalerError = scalerValueError(
-        scalerType,
-        updateParams.scalerValue
-      );
-      if (scalerError) {
-        return jsonReply2({ error: scalerError, status: 400 });
-      }
-      const body = backend.mapUpdate({
-        ...updateParams,
-        scalerType
-      });
-      const result = await callRestUrl(url, "PATCH", body);
-      if (clearedExclusions.length) {
-        return jsonReply2({
-          ...result,
-          _warning: `Supplying gpuPoolIds replaced the GPU selection wholesale, clearing ${clearedExclusions.length} GPU-type exclusion(s) previously set on this endpoint: ${clearedExclusions.join(", ")}. Re-apply them with set-endpoint-gpus if still wanted.`
-        });
-      }
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "delete-endpoint",
-    "Permanently delete a Serverless endpoint. This cannot be undone.",
-    {
-      endpointId: import_zod8.z.string().describe("ID of the endpoint to delete")
-    },
-    { title: "Delete endpoint", ...DESTRUCTIVE },
-    async (params) => {
-      const backend = backendFor("endpoints");
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.endpointId)}`,
-        "DELETE"
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "list-endpoint-releases",
-    "List a Serverless endpoint's release history and current rollout status (workers on the latest version). v2-only \u2014 returns a 501 notice on the v1 API. Paginated via limit/cursor.",
-    {
-      ...listPaginationParams,
-      endpointId: import_zod8.z.string().describe("ID of the Serverless endpoint whose releases to list")
-    },
-    { title: "List endpoint releases", ...READ_ONLY },
-    async (params) => {
-      const backend = backendFor("endpoints");
-      if (backend.version === "v1") {
-        return jsonReply2({
-          error: "list-endpoint-releases is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2.",
-          status: 501
-        });
-      }
-      const raw = await callRestUrl(
-        `${backend.base}/serverless/${params.endpointId}/releases`
-      );
-      const releases = Array.isArray(raw?.releases) ? raw.releases : [];
-      return capListResult(
-        releases,
-        { limit: params.limit, cursor: params.cursor },
-        { rollout: raw?.rollout, endpointVersion: raw?.endpointVersion }
-      );
-    }
-  );
-  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. An UNHEALTHY worker usually means the container is crash-looping (repeated starts that exit before the handler runs) \u2014 jobs on the endpoint will sit IN_QUEUE even though this is a worker failure, not a capacity shortage; inspect it with stream-worker-logs. Zero workers while jobs queue means the endpoint is waiting for GPU capacity. Paginated via limit/cursor.",
-    {
-      ...listPaginationParams,
-      endpointId: import_zod8.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 }
-      );
-    }
-  );
-  server.tool(
-    "stream-worker-logs",
-    "Fetch a bounded snapshot of a serverless worker's live logs (container and/or system) via Server-Sent Events. v2-only \u2014 returns a 501 notice on the v1 API. Get the workerId from list-endpoint-workers. Use this to diagnose UNHEALTHY workers: repeated `start container` system lines with no container output is the crash-loop signature (the container exits before the handler runs). Reads for up to maxWaitMs (default 5s) and returns the collected log lines; use `tail` to backfill recent lines first. Large output is truncated (see the `truncated` flag).",
-    {
-      endpointId: import_zod8.z.string().describe("ID of the Serverless endpoint the worker belongs to"),
-      workerId: import_zod8.z.string().describe(
-        "ID of the worker whose logs to stream (from list-endpoint-workers)"
-      ),
-      ...logStreamParams
-    },
-    { title: "Stream worker logs", ...READ_ONLY },
-    (params) => streamLogsReply(
-      rt,
-      {
-        name: "stream-worker-logs",
-        resource: "workers",
-        logsUrl: (backend) => `${backend.base}/serverless/${encodeURIComponent(params.endpointId)}/workers/${encodeURIComponent(params.workerId)}/logs`
-      },
-      params
-    )
-  );
-}
-
-// src/tools/jobs.ts
-var import_zod9 = require("zod");
-var DIAGNOSIS_TTL_MS = 15e3;
-var MAX_DIAGNOSIS_ENTRIES = 500;
-var diagnosisCache = /* @__PURE__ */ new Map();
-var HTTP_LONG_POLL_BUDGET_MS = 45e3;
-var STDIO_STREAM_BUDGET_MS = 5 * 60 * 1e3;
-var RUNSYNC_UPSTREAM_DEFAULT_WAIT_MS = 9e4;
-var STREAM_UPSTREAM_DEFAULT_WAIT_MS = 1e4;
-var HTTP_STREAM_POLL_WAIT_MS = 1e3;
-var STREAM_JOB_POLL_INTERVAL_MS = 1e3;
-var MAX_CONSECUTIVE_STREAM_ERRORS = 5;
-var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
-  "COMPLETED",
-  "FAILED",
-  "CANCELLED",
-  "TIMED_OUT"
-]);
-function isUnfinishedJobReply(result) {
-  return result !== null && typeof result === "object" && !Array.isArray(result) && !("waitClamped" in result) && !TERMINAL_STATUSES.has(result.status ?? "");
-}
-function formatBudget(ms) {
-  return ms >= 12e4 ? `${Math.round(ms / 6e4)} minutes` : `${Math.round(ms / 1e3)} seconds`;
-}
-var UPSTREAM_HOLD_SLACK_MS = 5e3;
-var MIN_STREAM_POLL_TIMEOUT_MS = 2e3;
-var QUEUED_DIAGNOSIS_TIMEOUT_MS = 5e3;
-function streamPollTimeoutMs(remainingMs, holdMs) {
-  return Math.max(
-    Math.min(remainingMs, holdMs + UPSTREAM_HOLD_SLACK_MS),
-    MIN_STREAM_POLL_TIMEOUT_MS
-  );
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function streamPollPlan(hosted) {
-  return hosted ? {
-    budgetMs: HTTP_LONG_POLL_BUDGET_MS,
-    holdMs: HTTP_STREAM_POLL_WAIT_MS,
-    query: `?wait=${HTTP_STREAM_POLL_WAIT_MS}`
-  } : {
-    budgetMs: STDIO_STREAM_BUDGET_MS,
-    holdMs: STREAM_UPSTREAM_DEFAULT_WAIT_MS,
-    query: ""
-  };
-}
-var RESUME_ADVICE = "Call stream-job again to continue collecting output, get-job-status to check the job without streaming, or stream without a budget by calling the runtime API directly (GET https://api.runpod.ai/v2/{endpointId}/stream/{jobId} with a Bearer API key).";
-function budgetExhaustedNote(budgetMs, lastError) {
-  return {
-    pollingTimedOut: true,
-    note: `Polling stopped after ${formatBudget(
-      budgetMs
-    )} with the job possibly still running. ${RESUME_ADVICE}`,
-    // Surface the trailing error (if any) instead of discarding it — the last
-    // polls may have been failing (e.g. job expired) even though earlier ones
-    // succeeded. Cleared on success, so this is never a stale error from
-    // minutes of healthy streaming ago.
-    ...lastError ? { lastError } : {}
-  };
-}
-function errorCapNote(lastError) {
-  return {
-    error: `Polling aborted after ${MAX_CONSECUTIVE_STREAM_ERRORS} consecutive errors: ${lastError}`,
-    note: `Polling stopped after ${MAX_CONSECUTIVE_STREAM_ERRORS} consecutive errors with the job possibly still running. ${RESUME_ADVICE}`
-  };
-}
-async function collectJobStream(deps) {
-  const { poll, budgetMs, holdMs } = deps;
-  const startedAt = Date.now();
-  const elapsed = () => Date.now() - startedAt;
-  const chunks = [];
-  let result = {};
-  let consecutiveErrors = 0;
-  let lastError;
-  while (true) {
-    try {
-      const reply = await poll(
-        streamPollTimeoutMs(budgetMs - elapsed(), holdMs)
-      );
-      consecutiveErrors = 0;
-      lastError = void 0;
-      if (Array.isArray(reply.stream)) chunks.push(...reply.stream);
-      result = reply;
-      if (TERMINAL_STATUSES.has(reply.status)) break;
-    } catch (error) {
-      consecutiveErrors++;
-      lastError = error instanceof Error ? error.message : String(error);
-      if (consecutiveErrors >= MAX_CONSECUTIVE_STREAM_ERRORS) {
-        result = { ...result, ...errorCapNote(lastError) };
-        break;
-      }
-    }
-    if (elapsed() > budgetMs) {
-      result = { ...result, ...budgetExhaustedNote(budgetMs, lastError) };
-      break;
-    }
-    await sleep(STREAM_JOB_POLL_INTERVAL_MS);
-  }
-  return { result, chunks };
-}
-function registerJobTools(server, rt) {
-  const { jsonReply: jsonReply2, serverlessRequest, backendFor, callRestUrl } = rt;
-  const hosted = rt.transport === "http";
-  const streamBudget = formatBudget(
-    hosted ? HTTP_LONG_POLL_BUDGET_MS : STDIO_STREAM_BUDGET_MS
-  );
-  async function diagnoseQueuedJob(endpointId) {
-    const cached = diagnosisCache.get(endpointId);
-    if (cached && cached.expiresAt > Date.now()) {
-      return cached.value;
-    }
-    diagnosisCache.delete(endpointId);
-    try {
-      const backend = backendFor("workers");
-      if (backend.version !== "v2") return null;
-      const raw = await callRestUrl(
-        `${backend.base}/serverless/${endpointId}/workers`,
-        "GET",
-        void 0,
-        { timeoutMs: QUEUED_DIAGNOSIS_TIMEOUT_MS }
-      );
-      const summary = raw?.summary;
-      const workers = raw?.workers ?? [];
-      if (!summary) return null;
-      const remember = (value) => {
-        if (diagnosisCache.size >= MAX_DIAGNOSIS_ENTRIES) {
-          const oldest = diagnosisCache.keys().next().value;
-          if (oldest !== void 0) diagnosisCache.delete(oldest);
-        }
-        diagnosisCache.set(endpointId, {
-          value,
-          expiresAt: Date.now() + DIAGNOSIS_TTL_MS
-        });
-        return value;
-      };
-      if ((summary.unhealthy ?? 0) > 0) {
-        const badIds = workers.filter((w) => w.status === "UNHEALTHY").map((w) => w.id).join(", ");
-        return remember({
-          workerHealth: summary,
-          hint: `${summary.unhealthy} of ${summary.total} worker(s) on this endpoint are UNHEALTHY \u2014 the container is likely crash-looping (repeated starts that exit before the handler runs). The job can stay IN_QUEUE indefinitely; this is a worker failure, NOT a capacity shortage. Inspect the logs with stream-worker-logs${badIds ? ` (workerId: ${badIds})` : ""}.`
-        });
-      }
-      if ((summary.total ?? 0) === 0) {
-        return remember({
-          workerHealth: summary,
-          hint: "No workers are scheduled for this endpoint yet \u2014 it may simply be scaling up from zero (normal for the first seconds of a cold start), or it is waiting for GPU capacity / its GPU-CUDA constraints exclude the currently-available hosts. If this persists, check availability with list-gpu-types or widen the gpuIds/CUDA settings."
-        });
-      }
-      if ((summary.throttled ?? 0) > 0 && (summary.running ?? 0) === 0) {
-        return remember({
-          workerHealth: summary,
-          hint: "Workers exist but are throttled \u2014 the hosts are at capacity right now; the job should start when capacity frees up."
-        });
-      }
-      if ((summary.initializing ?? 0) > 0) {
-        return remember({
-          workerHealth: summary,
-          hint: "A worker is initializing \u2014 likely a cold start (image pull / model load); the job should start soon."
-        });
-      }
-      return remember({ workerHealth: summary, hint: "" });
-    } catch {
-      return null;
-    }
-  }
-  const endpointIdSchema = import_zod9.z.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid endpoint ID format");
-  const jobIdSchema = import_zod9.z.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid job ID format");
-  const inputSchema = import_zod9.z.record(import_zod9.z.unknown()).describe(
-    "Input payload for the worker handler. The expected fields depend on the deployed model or worker."
-  );
-  const webhookSchema = import_zod9.z.string().url().optional().describe(
-    "Webhook URL to receive job completion notifications instead of polling"
-  );
-  const policySchema = import_zod9.z.object({
-    executionTimeout: import_zod9.z.number().optional().describe("Maximum execution time in milliseconds"),
-    lowPriority: import_zod9.z.boolean().optional().describe("Submit as a low-priority job"),
-    ttl: import_zod9.z.number().optional().describe("Time-to-live for the job result in milliseconds")
-  }).optional().describe("Execution policy options");
-  const s3ConfigSchema = import_zod9.z.object({
-    accessId: import_zod9.z.string().describe("S3 access key ID"),
-    accessSecret: import_zod9.z.string().describe("S3 secret access key"),
-    bucketName: import_zod9.z.string().describe("S3 bucket name"),
-    endpointUrl: import_zod9.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
-    },
-    { title: "Run endpoint (async)", ...WRITE },
-    async (params) => {
-      const { endpointId, ...body } = params;
-      const result = await serverlessRequest(
-        endpointId,
-        "/run",
-        "POST",
-        body
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "runsync-endpoint",
-    `Submit a synchronous job to a Serverless endpoint and wait for the result. Best for fast tasks: if the job outlives the wait, the response returns a job ID and a non-terminal status (IN_QUEUE or IN_PROGRESS) to poll with get-job-status. Max payload 20 MB; results expire after 1 minute. ${hosted ? `This server waits up to ${HTTP_LONG_POLL_BUDGET_MS} ms \u2014 it runs behind a 60-second gateway deadline, so that is both the default and the ceiling for the wait parameter. For longer jobs use run-endpoint + get-job-status, or POST https://api.runpod.ai/v2/{endpointId}/runsync?wait=300000 directly with a Bearer API key.` : "The wait parameter extends the server-side wait to up to 5 minutes (300000 ms); it defaults to 90000 (90 seconds)."}`,
-    {
-      endpointId: endpointIdSchema.describe(
-        "ID of the Serverless endpoint to run synchronously"
-      ),
-      input: inputSchema,
-      wait: import_zod9.z.number().min(1e3).max(3e5).optional().describe(
-        hosted ? `How long in milliseconds the server should wait for a result before returning a job ID to poll. Accepted range 1000\u2013300000, but this server clamps anything above ${HTTP_LONG_POLL_BUDGET_MS} down to ${HTTP_LONG_POLL_BUDGET_MS}, which is also the effective default.` : "How long in milliseconds the server should wait for a result before returning a job ID to poll (1000\u2013300000). Defaults to 90000 (90 seconds)."
-      ),
-      webhook: webhookSchema,
-      policy: policySchema,
-      s3Config: s3ConfigSchema
-    },
-    { title: "Run endpoint (sync)", ...WRITE },
-    async (params) => {
-      const { endpointId, wait, ...body } = params;
-      const effectiveWait = hosted ? Math.min(
-        wait ?? RUNSYNC_UPSTREAM_DEFAULT_WAIT_MS,
-        HTTP_LONG_POLL_BUDGET_MS
-      ) : wait;
-      const waitQuery = effectiveWait === void 0 ? "" : `?wait=${effectiveWait}`;
-      const path = `/runsync${waitQuery}`;
-      const result = await serverlessRequest(
-        endpointId,
-        path,
-        "POST",
-        body,
-        {
-          // From the wait actually sent — on http the clamped 45s, not the
-          // 300s the caller may have asked for.
-          timeoutMs: (effectiveWait ?? RUNSYNC_UPSTREAM_DEFAULT_WAIT_MS) + UPSTREAM_HOLD_SLACK_MS
-        }
-      );
-      const requestedWait = wait ?? RUNSYNC_UPSTREAM_DEFAULT_WAIT_MS;
-      if (hosted && requestedWait > HTTP_LONG_POLL_BUDGET_MS && isUnfinishedJobReply(result)) {
-        return jsonReply2({
-          ...result,
-          waitClamped: {
-            requestedMs: requestedWait,
-            effectiveMs: effectiveWait,
-            reason: `This server runs behind a 60-second gateway deadline, so a non-terminal status here means the job outlived ${formatBudget(
-              HTTP_LONG_POLL_BUDGET_MS
-            )}, not the requested wait \u2014 poll get-job-status rather than treating it as stuck.`
-          }
-        });
-      }
-      return jsonReply2(result);
-    }
-  );
-  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. IMPORTANT: a job stuck IN_QUEUE does not necessarily mean a capacity shortage \u2014 a worker may have spun up and crash-looped (the platform marks it UNHEALTHY while the job stays queued). When the job is IN_QUEUE this tool attaches a workerHealth summary and a hint; to dig deeper, call list-endpoint-workers (look for UNHEALTHY) and stream-worker-logs.",
-    {
-      endpointId: endpointIdSchema.describe(
-        "ID of the Serverless endpoint the job belongs to"
-      ),
-      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}`
-      );
-      if (result && typeof result === "object" && result.status === "IN_QUEUE") {
-        const diagnosis = await diagnoseQueuedJob(params.endpointId);
-        if (diagnosis) {
-          return jsonReply2({
-            ...result,
-            workerHealth: diagnosis.workerHealth,
-            ...diagnosis.hint ? { hint: diagnosis.hint } : {}
-          });
-        }
-      }
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "stream-job",
-    `Retrieve streaming output from a Serverless job. The worker must support streaming output. Polls /stream/{jobId} and collects chunks until the status is COMPLETED, FAILED, CANCELLED, or TIMED_OUT, for up to ${streamBudget}${hosted ? " (this server runs behind a 60-second gateway deadline)" : ""}. If the budget expires first, returns the chunks collected so far with pollingTimedOut: true \u2014 call stream-job again to resume where it left off, or get-job-status to check without streaming.${hosted ? " To collect with no budget, poll GET https://api.runpod.ai/v2/{endpointId}/stream/{jobId} yourself with a Bearer API key until the status is terminal \u2014 each request drains only the chunks buffered so far, so a single request is not the whole output." : ""}`,
-    {
-      endpointId: endpointIdSchema.describe(
-        "ID of the Serverless endpoint the job belongs to"
-      ),
-      jobId: jobIdSchema.describe("ID of the job to stream results from")
-    },
-    { title: "Stream job", ...READ_ONLY },
-    async (params) => {
-      const plan = streamPollPlan(hosted);
-      const streamPath = `/stream/${params.jobId}${plan.query}`;
-      const { result, chunks } = await collectJobStream({
-        budgetMs: plan.budgetMs,
-        holdMs: plan.holdMs,
-        poll: (timeoutMs) => serverlessRequest(params.endpointId, streamPath, "GET", void 0, {
-          timeoutMs
-        })
-      });
-      return jsonReply2({ ...result, stream: chunks });
-    }
-  );
-  server.tool(
-    "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")
-    },
-    { title: "Cancel job", ...WRITE, idempotentHint: true },
-    async (params) => {
-      const result = await serverlessRequest(
-        params.endpointId,
-        `/cancel/${params.jobId}`,
-        "POST"
-      );
-      return jsonReply2(result);
-    }
-  );
-  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")
-    },
-    { title: "Retry job", ...WRITE },
-    async (params) => {
-      const result = await serverlessRequest(
-        params.endpointId,
-        `/retry/${params.jobId}`,
-        "POST"
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "endpoint-health",
-    "Get the health and operational status of a Serverless endpoint, including worker counts and job statistics. Use this when jobs are stuck IN_QUEUE: unhealthy workers mean a crash-looping container (a worker failure \u2014 inspect with stream-worker-logs), while zero workers means the endpoint is waiting for GPU capacity.",
-    {
-      endpointId: endpointIdSchema.describe(
-        "ID of the Serverless endpoint to check health for"
-      )
-    },
-    { title: "Endpoint health", ...READ_ONLY },
-    async (params) => {
-      const result = await serverlessRequest(params.endpointId, "/health");
-      return jsonReply2(result);
-    }
-  );
-  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"
-      )
-    },
-    { title: "Purge endpoint queue", ...WRITE, idempotentHint: true },
-    async (params) => {
-      const result = await serverlessRequest(
-        params.endpointId,
-        "/purge-queue",
-        "POST"
-      );
-      return jsonReply2(result);
-    }
-  );
-}
-
-// src/tools/templates.ts
-var import_zod10 = 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.`,
-    {
-      ...listPaginationParams,
-      includeRunpodTemplates: import_zod10.z.boolean().optional().describe("Include official Runpod templates in the response"),
-      includePublicTemplates: import_zod10.z.boolean().optional().describe("Include community-made public templates in the response"),
-      includeEndpointBoundTemplates: import_zod10.z.boolean().optional().describe(
-        "Include templates bound to Serverless endpoints in the response"
-      )
-    },
-    { title: "List templates", ...READ_ONLY },
-    async (params) => {
-      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 capListResult(backend.unwrap(result), {
-        limit: params.limit,
-        cursor: params.cursor
-      });
-    }
-  );
-  server.tool(
-    "get-template",
-    "Get one template by id (image, env, ports, disk/volume config).",
-    {
-      templateId: import_zod10.z.string().describe("ID of the template to retrieve")
-    },
-    { title: "Get template", ...READ_ONLY },
-    async (params) => {
-      const backend = backendFor("templates");
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.templateId)}`
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "create-template",
-    "Create a reusable pod/endpoint template (image, ports, env, disk/volume). Category is optional and defaults to NVIDIA.",
-    {
-      name: import_zod10.z.string().describe("Name for the template"),
-      imageName: import_zod10.z.string().describe("Docker image to use"),
-      isServerless: import_zod10.z.boolean().optional().describe("Is this a serverless template"),
-      ports: import_zod10.z.array(import_zod10.z.string()).optional().describe("Ports to expose"),
-      dockerEntrypoint: import_zod10.z.array(import_zod10.z.string()).optional().describe(
-        "Docker entrypoint commands. Note: not persisted on the v2 REST API, which has no separate entrypoint field (only a start command)."
-      ),
-      dockerStartCmd: import_zod10.z.array(import_zod10.z.string()).optional().describe(
-        'Container start command. On v2 this is stored as the template\'s `args` string; a multi-element array is joined with spaces (e.g. ["python","-u","app.py"] \u2192 "python -u app.py"). The join is lossy: an element that itself contains spaces is NOT preserved as one argument \u2014 e.g. ["sh","-c","echo hi"] becomes "sh -c echo hi", so pass a shell command as a single pre-quoted element if that distinction matters. Omit or pass an empty array to leave the command unset (never overwrites with "").'
-      ),
-      env: import_zod10.z.record(import_zod10.z.string()).optional().describe("Environment variables"),
-      containerDiskInGb: import_zod10.z.number().optional().describe("Container disk size in GB"),
-      volumeInGb: import_zod10.z.number().optional().describe("Volume size in GB"),
-      volumeMountPath: import_zod10.z.string().optional().describe("Path to mount the volume"),
-      readme: import_zod10.z.string().optional().describe("README content in markdown format"),
-      category: import_zod10.z.enum(["CPU", "NVIDIA", "AMD"]).optional().describe(
-        "How the template is grouped and filtered in the Runpod console \u2014 it does NOT affect hardware selection, scheduling, or billing. Optional; defaults to NVIDIA. Set CPU or AMD only to file the template correctly in the console."
-      ),
-      containerRegistryAuthId: import_zod10.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 backend = backendFor("templates");
-      const body = backend.mapCreate(params);
-      const result = await callRestUrl(
-        `${backend.base}${backend.list}`,
-        "POST",
-        body
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "update-template",
-    "Update a template's mutable fields (name, image, ports, env, start command, registry auth). Only provided fields change; omitted fields are left untouched.",
-    {
-      templateId: import_zod10.z.string().describe("ID of the template to update"),
-      name: import_zod10.z.string().optional().describe("New name for the template"),
-      imageName: import_zod10.z.string().optional().describe("New Docker image"),
-      dockerStartCmd: import_zod10.z.array(import_zod10.z.string()).optional().describe(
-        "New container start command. On v2 stored as the template's `args` string; a multi-element array is joined with spaces (lossy \u2014 an element containing spaces is split into separate tokens). Note: this can only set a command, not clear one \u2014 an empty or absent array is ignored so the existing command is preserved."
-      ),
-      ports: import_zod10.z.array(import_zod10.z.string()).optional().describe("New ports to expose"),
-      env: import_zod10.z.record(import_zod10.z.string()).optional().describe("New environment variables"),
-      readme: import_zod10.z.string().optional().describe("New README content in markdown format"),
-      containerRegistryAuthId: import_zod10.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 backend = backendFor("templates");
-      const body = backend.mapUpdate(updateParams);
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(templateId)}`,
-        "PATCH",
-        body
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "delete-template",
-    "Permanently delete a template. This cannot be undone.",
-    {
-      templateId: import_zod10.z.string().describe("ID of the template to delete")
-    },
-    { title: "Delete template", ...DESTRUCTIVE },
-    async (params) => {
-      const backend = backendFor("templates");
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.templateId)}`,
-        "DELETE"
-      );
-      return jsonReply2(result);
-    }
-  );
-}
-
-// src/tools/network-volumes.ts
-var import_zod11 = 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_zod11.z.string().describe("ID of the network volume to retrieve")
-    },
-    { title: "Get network volume", ...READ_ONLY },
-    async (params) => {
-      const backend = backendFor("networkVolumes");
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.networkVolumeId)}`
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "create-network-volume",
-    "Create a persistent network volume in a data center (size 10\u20134096 GB) that pods can mount. Pass volumeType to pick a storage tier; omit it to get the data center default.",
-    {
-      name: import_zod11.z.string().describe("Name for the network volume"),
-      // Bounds mirror the v2 spec (integer, minimum 10, maximum 4096). Enforced
-      // here as well as described, so an out-of-range value fails locally
-      // instead of costing an API roundtrip.
-      size: import_zod11.z.number().int().min(10).max(4096).describe("Size in GB (10-4096)"),
-      dataCenterId: import_zod11.z.string().describe("Data center ID (see list-data-centers)"),
-      volumeType: import_zod11.z.enum(["STANDARD", "HIGH_PERFORMANCE"]).optional().describe(
-        "Storage tier. Omit for the data center's default (primary) tier. HIGH_PERFORMANCE provisions an HPS volume. Immutable after creation \u2014 update-network-volume cannot change it."
-      )
-    },
-    { title: "Create network volume", ...WRITE },
-    async (params) => {
-      const backend = backendFor("networkVolumes");
-      const body = backend.mapCreate(params);
-      const result = await callRestUrl(
-        `${backend.base}${backend.list}`,
-        "POST",
-        body
-      );
-      return jsonReply2(result);
-    }
-  );
-  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_zod11.z.string().describe("ID of the network volume to update"),
-      name: import_zod11.z.string().optional().describe("New name for the network volume"),
-      // Same absolute bounds as create. "Larger than current" stays server-side —
-      // we do not hold the current size here, so only the range is checked.
-      size: import_zod11.z.number().int().min(10).max(4096).optional().describe("New size in GB, 10-4096 (must be larger than current)")
-    },
-    { title: "Update network volume", ...WRITE, idempotentHint: true },
-    async (params) => {
-      const { networkVolumeId, ...updateParams } = params;
-      const backend = backendFor("networkVolumes");
-      const body = backend.mapUpdate(updateParams);
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(networkVolumeId)}`,
-        "PATCH",
-        body
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "delete-network-volume",
-    "Permanently delete a network volume and its data. This cannot be undone.",
-    {
-      networkVolumeId: import_zod11.z.string().describe("ID of the network volume to delete")
-    },
-    { title: "Delete network volume", ...DESTRUCTIVE },
-    async (params) => {
-      const backend = backendFor("networkVolumes");
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.networkVolumeId)}`,
-        "DELETE"
-      );
-      return jsonReply2(result);
-    }
-  );
-}
-
-// src/tools/registries.ts
-var import_zod12 = require("zod");
-var DELEGATIONS = "/delegations";
-function registerRegistryTools(server, rt) {
-  const { jsonReply: jsonReply2, callRestUrl, backendFor } = rt;
-  const delegationsV2OnlyNotice = (tool) => ({
-    error: `${tool} is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2.`,
-    status: 501
-  });
-  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_zod12.z.string().describe("ID of the container registry auth to retrieve")
-    },
-    { title: "Get container registry auth", ...READ_ONLY },
-    async (params) => {
-      const backend = backendFor("registries");
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.containerRegistryAuthId)}`
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "create-container-registry-auth",
-    "Save container-registry credentials (username + password/token) so pods and endpoints can pull private images.",
-    {
-      name: import_zod12.z.string().describe("Name for the container registry auth"),
-      username: import_zod12.z.string().describe("Registry username"),
-      password: import_zod12.z.string().describe("Registry password or access token (stored as a secret)")
-    },
-    { title: "Create container registry auth", ...WRITE },
-    async (params) => {
-      const backend = backendFor("registries");
-      const body = backend.mapCreate(params);
-      const result = await callRestUrl(
-        `${backend.base}${backend.list}`,
-        "POST",
-        body
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "delete-container-registry-auth",
-    "Permanently delete a saved container-registry credential. This cannot be undone.",
-    {
-      containerRegistryAuthId: import_zod12.z.string().describe("ID of the container registry auth to delete")
-    },
-    { title: "Delete container registry auth", ...DESTRUCTIVE },
-    async (params) => {
-      const backend = backendFor("registries");
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.containerRegistryAuthId)}`,
-        "DELETE"
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "list-registry-delegations",
-    "List your AWS ECR delegations \u2014 ECR repositories Runpod has been granted scoped pull access to, so private ECR images can be pulled without storing AWS credentials. Each entry includes the `dockerRegistryUri` to pull from. v2-only \u2014 returns a 501 notice on the v1 API. Paginated via limit/cursor.",
-    listPaginationParams,
-    { title: "List registry delegations", ...READ_ONLY },
-    async (params) => {
-      const backend = backendFor("registries");
-      if (backend.version === "v1") {
-        return jsonReply2(delegationsV2OnlyNotice("list-registry-delegations"));
-      }
-      const raw = await callRestUrl(
-        `${backend.base}${backend.list}${DELEGATIONS}`
-      );
-      const delegations = Array.isArray(raw?.delegations) ? raw.delegations : [];
-      return capListResult(delegations, {
-        limit: params.limit,
-        cursor: params.cursor
-      });
-    }
-  );
-  server.tool(
-    "create-registry-delegation",
-    "Register an AWS ECR repository so Runpod can pull private images from it without stored credentials. Pass the repository ARN; the reply carries the `dockerRegistryUri`, resolved repository/tag, and AWS region. v2-only \u2014 returns a 501 notice on the v1 API. For a non-ECR private registry use create-container-registry-auth instead.",
-    {
-      resource: import_zod12.z.string().min(1).describe(
-        'ECR resource ARN, e.g. "arn:aws:ecr:us-east-2:123456789012:repository/my-org/my-image"'
-      ),
-      name: import_zod12.z.string().optional().describe("Optional human-readable name for the delegation")
-    },
-    { title: "Create registry delegation", ...WRITE },
-    async (params) => {
-      const backend = backendFor("registries");
-      if (backend.version === "v1") {
-        return jsonReply2(delegationsV2OnlyNotice("create-registry-delegation"));
-      }
-      const body = { resource: params.resource };
-      if (params.name !== void 0) body.name = params.name;
-      const result = await callRestUrl(
-        `${backend.base}${backend.list}${DELEGATIONS}`,
-        "POST",
-        body
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "delete-registry-delegation",
-    "Revoke an AWS ECR delegation, withdrawing Runpod's pull access to that repository. Existing workers keep running; future pulls fail. v2-only \u2014 returns a 501 notice on the v1 API. This cannot be undone.",
-    {
-      delegationId: import_zod12.z.string().describe(
-        "ID of the delegation to revoke (from list-registry-delegations)"
-      )
-    },
-    { title: "Revoke registry delegation", ...DESTRUCTIVE },
-    async (params) => {
-      const backend = backendFor("registries");
-      if (backend.version === "v1") {
-        return jsonReply2(delegationsV2OnlyNotice("delete-registry-delegation"));
-      }
-      const result = await callRestUrl(
-        `${backend.base}${backend.list}${DELEGATIONS}/${encodeURIComponent(
-          params.delegationId
-        )}`,
-        "DELETE"
-      );
-      return jsonReply2(result);
-    }
-  );
-}
-
-// src/tools/billing.ts
-var import_zod13 = 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_zod13.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_zod13.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_zod13.z.string().optional().describe(
-        "End of the period (RFC 3339), exclusive. Defaults to now. Mutually exclusive with lastN."
-      ),
-      bucketSize: import_zod13.z.enum(["hour", "day", "week", "month", "year"]).optional().describe("Length of each time bucket. Defaults to day."),
-      lastN: import_zod13.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);
-  registerHubTools(server, rt);
-  registerPublicEndpointTools(server, rt);
-  registerPodTools(server, rt);
-  registerEndpointTools(server, rt);
-  registerEndpointGpuTools(server, rt);
-  registerJobTools(server, rt);
-  registerTemplateTools(server, rt);
-  registerNetworkVolumeTools(server, rt);
-  registerRegistryTools(server, rt);
-  registerBillingTools(server, rt);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  registerTools
-});
-//# sourceMappingURL=tools.cjs.map