@runpod/mcp-server 2.0.0 → 3.0.0

package/dist/stdio.cjs

@@ -448,81 +448,6 @@ var import_node_fetch2 = __toESM(require("node-fetch"), 1);
 
 // src/server.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var SERVER_NAME = "Runpod API Server";
-var SERVER_VERSION = true ? "2.0.0" : "dev";
-function createServer(version = SERVER_VERSION) {
-  return new import_mcp.McpServer({
-    name: SERVER_NAME,
-    version,
-    capabilities: {
-      resources: {},
-      tools: {}
-    }
-  });
-}
-
-// src/tools/runtime.ts
-var import_node_fetch = __toESM(require("node-fetch"), 1);
-var import_node_crypto = require("crypto");
-
-// src/_shared/http.ts
-var HttpError = class extends Error {
-  constructor(prefix, status, body) {
-    super(`${prefix}: ${status} - ${body}`);
-    this.name = "HttpError";
-    this.status = status;
-    this.body = body;
-  }
-};
-function isJsonContentType(contentType) {
-  if (!contentType) return false;
-  const ct = contentType.toLowerCase();
-  return ct.includes("application/json") || ct.includes("+json");
-}
-function methodSendsBody(method) {
-  return method === "POST" || method === "PATCH" || method === "PUT";
-}
-function buildRequestHeaders(apiKey, tracking) {
-  return {
-    Authorization: `Bearer ${apiKey}`,
-    "Content-Type": "application/json",
-    ...tracking()
-  };
-}
-function createHttpClient(deps) {
-  return async function request(url, method = "GET", body) {
-    const init = {
-      method,
-      headers: buildRequestHeaders(deps.apiKey, deps.tracking)
-    };
-    if (body && methodSendsBody(method)) {
-      init.body = JSON.stringify(body);
-    }
-    const response = await deps.fetch(url, init);
-    if (!response.ok) {
-      throw new HttpError(
-        deps.errorPrefix,
-        response.status,
-        await response.text()
-      );
-    }
-    return isJsonContentType(response.headers.get("content-type")) ? response.json() : { success: true, status: response.status };
-  };
-}
-
-// src/_shared/tracking.ts
-function sanitizeUaToken(value) {
-  return value.replace(/[()<>@,;:\\"/[\]?={}\s]/g, "_").slice(0, 64);
-}
-function 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/_shared/mappers.ts
 function compact(obj) {
@@ -536,6 +461,9 @@ function persistentMount(size, path2) {
   if (size === void 0 || path2 === void 0) return void 0;
   return { persistent: { size, path: path2 } };
 }
+function joinStartCmd(cmd) {
+  return cmd && cmd.length ? cmd.join(" ") : void 0;
+}
 function containerConfigToV2(p2) {
   return compact({
     image: p2.imageName,
@@ -554,6 +482,13 @@ 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
@@ -610,7 +545,8 @@ function mapNetworkVolumeCreateToV2(params) {
   return compact({
     name: params.name,
     size: params.size,
-    dataCenter: params.dataCenterId
+    dataCenter: params.dataCenterId,
+    type: params.volumeType
   });
 }
 function mapTemplateCreateToV2(params) {
@@ -619,18 +555,39 @@ function mapTemplateCreateToV2(params) {
     ...compact({
       name: params.name,
       serverless: params.isServerless,
-      registry: params.containerRegistryAuthId
-    }),
-    // Required by v2 — always emit, defaulting to NVIDIA.
-    category: params.category ?? "NVIDIA"
+      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;
+}
 function mapTemplateUpdateToV2(params) {
   return {
     ...containerConfigToV2(params),
     ...compact({
       name: params.name,
-      registry: params.containerRegistryAuthId
+      registry: params.containerRegistryAuthId,
+      args: joinStartCmd(params.dockerStartCmd)
     })
   };
 }
@@ -647,7 +604,6 @@ var V2_UNWRAP_KEY = {
   dataCenters: "dataCenters",
   endpoints: "endpoints",
   jobs: "jobs",
-  tags: "tags",
   workers: "workers",
   billing: "records"
 };
@@ -661,7 +617,6 @@ var RESOURCE_ENV_KEY = {
   dataCenters: "DATA_CENTERS",
   endpoints: "ENDPOINTS",
   jobs: "JOBS",
-  tags: "TAGS",
   workers: "WORKERS",
   billing: "BILLING"
 };
@@ -677,6 +632,9 @@ function serverlessBase(env) {
 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 [];
@@ -700,6 +658,14 @@ function wantsAutoProbe(env) {
     ([k, v]) => k.startsWith("RUNPOD_REST_VERSION") && (v ?? "").toLowerCase() === "auto"
   );
 }
+function restVersionSummary(env) {
+  const raw = (env.RUNPOD_REST_VERSION ?? "").trim().toLowerCase();
+  const base = raw ? `RUNPOD_REST_VERSION=${raw}` : "RUNPOD_REST_VERSION unset (default v2)";
+  const overrides = Object.keys(env).filter(
+    (k) => k.startsWith("RUNPOD_REST_VERSION_") && (env[k] ?? "").trim() !== ""
+  ).length;
+  return overrides > 0 ? `${base}, +${overrides} per-resource` : base;
+}
 var PROBE_TIMEOUT_MS = 4e3;
 function classifyProbeStatus(status) {
   if (status >= 500) return void 0;
@@ -765,7 +731,6 @@ var CATALOG = /* @__PURE__ */ new Set([
   "dataCenters"
 ]);
 var V2_ONLY = /* @__PURE__ */ new Set([
-  "tags",
   "workers",
   "billing"
 ]);
@@ -783,7 +748,6 @@ var V2_REST_PATHS = {
     list: "/catalog/datacenters",
     get: (id) => `/catalog/datacenters/${id}`
   },
-  tags: { list: "/tags", get: (id) => `/tags/${id}` },
   // Endpoints live under /v2/serverless on v2 (NOT /v2/endpoints). The v2 list
   // response wraps rows under `endpoints` (see V2_UNWRAP_KEY), so the existing
   // unwrap key stays correct.
@@ -880,8 +844,186 @@ function resolveBackend(opts) {
   return version === "v2" ? buildV2Backend(resource, env, unwrap) : buildV1Backend(resource, env, unwrap);
 }
 
+// src/server.ts
+var SERVER_NAME = "Runpod API Server";
+var SERVER_VERSION = true ? "3.0.0" : "dev";
+function createServer(version = SERVER_VERSION) {
+  return new import_mcp.McpServer({
+    name: SERVER_NAME,
+    version: `${version} [${restVersionSummary(process.env)}]`,
+    capabilities: {
+      resources: {},
+      tools: {}
+    }
+  });
+}
+
 // src/tools/runtime.ts
-var MCP_SERVER_VERSION = true ? "2.0.0" : "dev";
+var import_node_fetch = __toESM(require("node-fetch"), 1);
+var import_node_crypto = require("crypto");
+
+// src/_shared/http.ts
+var HttpError = class extends Error {
+  constructor(prefix, status, body) {
+    const hint = status === 401 ? " (the Runpod API rejected the credential \u2014 the API key may be expired or revoked; re-authenticate or update RUNPOD_API_KEY)" : "";
+    super(`${prefix}: ${status} - ${body}${hint}`);
+    this.name = "HttpError";
+    this.status = status;
+    this.body = body;
+  }
+};
+function isJsonContentType(contentType) {
+  if (!contentType) return false;
+  const ct = contentType.toLowerCase();
+  return ct.includes("application/json") || ct.includes("+json");
+}
+function methodSendsBody(method) {
+  return method === "POST" || method === "PATCH" || method === "PUT";
+}
+function buildRequestHeaders(apiKey, tracking) {
+  return {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    ...tracking()
+  };
+}
+function createHttpClient(deps) {
+  return async function request(url, method = "GET", body) {
+    const init = {
+      method,
+      headers: buildRequestHeaders(deps.apiKey, deps.tracking)
+    };
+    if (body && methodSendsBody(method)) {
+      init.body = JSON.stringify(body);
+    }
+    const response = await deps.fetch(url, init);
+    if (!response.ok) {
+      throw new HttpError(
+        deps.errorPrefix,
+        response.status,
+        await response.text()
+      );
+    }
+    return isJsonContentType(response.headers.get("content-type")) ? response.json() : { success: true, status: response.status };
+  };
+}
+
+// src/_shared/tracking.ts
+function sanitizeUaToken(value) {
+  return value.replace(/[()<>@,;:\\"/[\]?={}\s]/g, "_").slice(0, 64);
+}
+function 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(() => "")
+      );
+    }
+    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/tools/runtime.ts
+var MCP_SERVER_VERSION = true ? "3.0.0" : "dev";
 var SESSION_ID = (0, import_node_crypto.randomUUID)();
 function trackingHeaders(server, ctx) {
   const info = server.server.getClientVersion();
@@ -918,14 +1060,18 @@ var DESTRUCTIVE = {
   idempotentHint: true,
   openWorldHint: true
 };
-async function graphqlRequest(query, tracking, fetchImpl, url) {
+async function graphqlRequest(query, tracking, fetchImpl, url, options) {
   const response = await fetchImpl(url, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
+      ...options?.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {},
       ...tracking()
     },
-    body: JSON.stringify({ query })
+    body: JSON.stringify({
+      query,
+      ...options?.variables ? { variables: options.variables } : {}
+    })
   });
   const result = await response.json();
   if (result.errors && result.errors.length > 0) {
@@ -940,7 +1086,17 @@ async function graphqlRequest(query, tracking, fetchImpl, url) {
 }
 function createToolRuntime(server, ctx, deps = {}) {
   const tracking = () => trackingHeaders(server, ctx);
-  const httpFetch = deps.fetch ?? defaultFetch;
+  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 v1Client = createHttpClient({
     apiKey: ctx.apiKey,
     fetch: httpFetch,
@@ -975,47 +1131,19 @@ function createToolRuntime(server, ctx, deps = {}) {
     "Error calling Runpod API:",
     () => restClient(url, method, body)
   );
-  const streamSse = deps.streamSse ?? (async (url, opts) => {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), opts.maxWaitMs);
-    try {
-      const res = await (0, import_node_fetch.default)(url, {
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${ctx.apiKey}`,
-          Accept: "text/event-stream",
-          ...tracking()
-        },
-        signal: controller.signal
-      });
-      if (!res.ok) {
-        throw new HttpError(
-          "Runpod API Error",
-          res.status,
-          await res.text().catch(() => "")
-        );
-      }
-      const chunks = [];
-      let bytes = 0;
-      let truncated = false;
-      try {
-        for await (const chunk of res.body) {
-          chunks.push(chunk);
-          bytes += chunk.length;
-          if (bytes >= opts.maxBytes) {
-            truncated = true;
-            controller.abort();
-            break;
-          }
-        }
-      } catch (err) {
-        if (!(err instanceof Error && err.name === "AbortError")) throw err;
-      }
-      return { raw: Buffer.concat(chunks).toString("utf8"), truncated };
-    } finally {
-      clearTimeout(timer);
-    }
-  });
+  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,
@@ -1037,9 +1165,18 @@ function createToolRuntime(server, ctx, deps = {}) {
     graphql: (query) => graphqlRequest(
       query,
       tracking,
-      httpFetch,
+      // rawFetch, not httpFetch: this call carries no credential (see above).
+      rawFetch,
       publicGraphqlBase(process.env)
     ),
+    graphqlAuthed: (query, variables) => graphqlRequest(
+      query,
+      tracking,
+      httpFetch,
+      // NOT publicGraphqlBase: this call carries the caller's API key.
+      authedGraphqlBase(process.env),
+      { variables, apiKey: ctx.apiKey }
+    ),
     runpodRequest,
     serverlessRequest,
     callRestUrl,
@@ -1051,17 +1188,17 @@ function createToolRuntime(server, ctx, deps = {}) {
 }
 
 // src/tools/catalog.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/pagination.ts
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 var DEFAULT_LIST_LIMIT = 20;
 var MAX_LIST_LIMIT = 100;
 var listPaginationParams = {
-  limit: import_zod.z.number().int().positive().max(MAX_LIST_LIMIT).optional().describe(
+  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_zod.z.string().optional().describe(
+  cursor: import_zod2.z.string().optional().describe(
     "Opaque pagination cursor from a previous response (nextCursor). Omit to start from the beginning."
   )
 };
@@ -1119,25 +1256,32 @@ function registerCatalogTools(server, rt) {
   const { jsonReply: jsonReply2, graphql, callRestUrl, backendFor } = rt;
   server.tool(
     "list-gpu-types",
-    "List available GPU types with stock/pricing and capability filters (minimum VRAM, secure/community cloud, name search). Use this to discover valid gpuTypeIds before creating a pod or endpoint. On v2 the realtime stock filter is a no-op.",
+    "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_zod2.z.number().optional().describe("Filter to GPUs with at least this much VRAM in GB"),
-      secureCloudOnly: import_zod2.z.boolean().optional().describe("Filter to only GPUs available in secure cloud"),
-      communityCloudOnly: import_zod2.z.boolean().optional().describe("Filter to only GPUs available in community cloud"),
-      searchTerm: import_zod2.z.string().optional().describe(
+      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_zod2.z.boolean().optional().describe(
-        "Include GPUs that are currently out of stock. Default is false"
+      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."
       )
     },
     { title: "List GPU types", ...READ_ONLY },
     async (params) => {
       const backend = backendFor("gpus");
       if (backend.version === "v2") {
-        const raw = await callRestUrl(`${backend.base}${backend.list}`);
+        const wantAvailability = params.includeAvailability !== false;
+        const raw = await callRestUrl(
+          `${backend.base}${backend.list}${wantAvailability ? "?include=AVAILABILITY" : ""}`
+        );
         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
@@ -1150,6 +1294,18 @@ function registerCatalogTools(server, rt) {
             (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
@@ -1179,7 +1335,7 @@ function registerCatalogTools(server, rt) {
         return !!status && status !== "Out";
       };
       let gpuTypes = data.gpuTypes.filter((gpu) => gpu.id !== "unknown");
-      if (!params.includeUnavailable) {
+      if (params.includeUnavailable === false) {
         gpuTypes = gpuTypes.filter(isAvailable);
       }
       if (params.minMemoryGb) {
@@ -1225,7 +1381,7 @@ function registerCatalogTools(server, rt) {
     "List Runpod data centers (id, name, region/location). Use this to discover valid dataCenterIds for placing pods, endpoints, or network volumes.",
     {
       ...listPaginationParams,
-      region: import_zod2.z.string().optional().describe(
+      region: import_zod3.z.string().optional().describe(
         "Filter by region/location (e.g., 'United States', 'Europe', 'Canada')"
       )
     },
@@ -1289,72 +1445,646 @@ function registerCatalogTools(server, rt) {
     }
   );
   server.tool(
-    "get-gpu-type",
-    "Get details for a single GPU type by id. v2-only \u2014 returns a 501 notice on the v1 API (use list-gpu-types there).",
+    "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."
+      )
+    },
+    { 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 path2 = backend.get(encodeURIComponent(params.gpuTypeId));
+      const query = params.includeAvailability === false ? "" : "?include=AVAILABILITY";
+      const result = await callRestUrl(`${backend.base}${path2}${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-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.",
     {
-      gpuTypeId: import_zod2.z.string().describe("ID of the GPU type to retrieve")
+      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: "Get GPU type", ...READ_ONLY },
+    { title: "Deploy Hub repo", ...WRITE },
     async (params) => {
-      const backend = backendFor("gpus");
-      if (backend.version === "v1") {
+      if (!params.repo && !params.hubReleaseId) {
         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
+          error: 'Provide either repo ("owner/name") or hubReleaseId. Use list-hub-repos to discover both.'
         });
       }
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.gpuTypeId)}`
+      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(result);
+      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(
-    "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).",
+    "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.",
     {
-      cpuTypeId: import_zod2.z.string().describe("ID of the CPU type to retrieve")
+      ...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: "Get CPU type", ...READ_ONLY },
+    { title: "List public endpoints", ...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 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);
       }
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.cpuTypeId)}`
+      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)
       );
-      return jsonReply2(result);
+      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(
-    "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).",
+    "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.",
     {
-      dataCenterId: import_zod2.z.string().describe("ID of the data center to retrieve")
+      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: "Get data center", ...READ_ONLY },
+    { title: "Set endpoint GPUs", ...WRITE, idempotentHint: true },
     async (params) => {
-      const backend = backendFor("dataCenters");
-      if (backend.version === "v1") {
+      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: "get-data-center is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2.",
-          status: 501
+          error: "Provide gpuIds (raw string) or pools (with optional excludeGpuTypeIds). See list-gpu-types for pool names and GPU type ids."
         });
       }
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.dataCenterId)}`
+      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
       );
-      return jsonReply2(result);
+      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_zod3 = require("zod");
+var import_zod7 = require("zod");
 function registerPodTools(server, rt) {
   const { jsonReply: jsonReply2, callRestUrl, backendFor, podAction, env } = rt;
   server.tool(
@@ -1362,12 +2092,12 @@ function registerPodTools(server, rt) {
     "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_zod3.z.enum(["GPU", "CPU"]).optional().describe("Filter to only GPU or only CPU Pods"),
-      gpuTypeId: import_zod3.z.array(import_zod3.z.string()).optional().describe("Filter to Pods with any of the listed GPU types"),
-      dataCenterId: import_zod3.z.array(import_zod3.z.string()).optional().describe("Filter to Pods in any of the provided data centers"),
-      name: import_zod3.z.string().optional().describe("Filter to Pods with the provided name"),
-      includeMachine: import_zod3.z.boolean().optional().describe("Include information about the machine"),
-      includeNetworkVolume: import_zod3.z.boolean().optional().describe("Include information about attached network volumes")
+      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) => {
@@ -1411,9 +2141,9 @@ function registerPodTools(server, rt) {
     "get-pod",
     "Get full details for one pod by id, optionally expanding machine and attached network-volume info.",
     {
-      podId: import_zod3.z.string().describe("ID of the pod to retrieve"),
-      includeMachine: import_zod3.z.boolean().optional().describe("Include information about the machine"),
-      includeNetworkVolume: import_zod3.z.boolean().optional().describe("Include information about attached network volumes")
+      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) => {
@@ -1441,26 +2171,44 @@ function registerPodTools(server, rt) {
   );
   server.tool(
     "create-pod",
-    'Create a new GPU/CPU pod on Runpod. Pass gpuTypeIds for a GPU pod, or computeType:"CPU" for a CPU pod (CPU pods are served by the v1 API for now). If the user does not specify an image, recommend the "Runpod Pytorch 2.8.0" image (runpod/pytorch:1.0.2-cu1281-torch280-ubuntu2404) as the default \u2014 it has the most up-to-date CUDA and PyTorch versions.',
+    'Create a new GPU/CPU pod on Runpod. Pass gpuTypeIds for a GPU pod, or computeType:"CPU" for a CPU pod (CPU pods are served by the v1 API for now). Pass either imageName or templateId (templateId deploys from an existing template \u2014 its name, image, start command, ports, env, disk, volume, and registry credential are used as defaults, and any field you also pass explicitly replaces the template value for that field, e.g. passing env replaces the whole env set rather than merging; pass containerRegistryAuthId to override or supply a private-image credential, or an empty string to deploy with none). If the user specifies neither an image nor a template, recommend the "Runpod Pytorch 2.8.0" image (runpod/pytorch:1.0.2-cu1281-torch280-ubuntu2404) as the default \u2014 it has the most up-to-date CUDA and PyTorch versions.',
     {
-      name: import_zod3.z.string().optional().describe("Name for the pod"),
-      imageName: import_zod3.z.string().describe("Docker image to use"),
-      computeType: import_zod3.z.enum(["GPU", "CPU"]).optional().describe(
+      name: import_zod7.z.string().optional().describe("Name for the pod"),
+      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_zod3.z.enum(["SECURE", "COMMUNITY"]).optional().describe("SECURE or COMMUNITY cloud"),
-      gpuTypeIds: import_zod3.z.array(import_zod3.z.string()).optional().describe("List of acceptable GPU types"),
-      gpuCount: import_zod3.z.number().optional().describe("Number of GPUs"),
-      containerDiskInGb: import_zod3.z.number().optional().describe("Container disk size in GB"),
-      volumeInGb: import_zod3.z.number().optional().describe("Volume size in GB"),
-      volumeMountPath: import_zod3.z.string().optional().describe("Path to mount the volume"),
-      ports: import_zod3.z.array(import_zod3.z.string()).optional().describe("Ports to expose (e.g., '8888/http', '22/tcp')"),
-      env: import_zod3.z.record(import_zod3.z.string()).optional().describe("Environment variables"),
-      dataCenterIds: import_zod3.z.array(import_zod3.z.string()).optional().describe("List of data centers")
+      cloudType: import_zod7.z.enum(["SECURE", "COMMUNITY"]).optional().describe("SECURE or COMMUNITY cloud"),
+      gpuTypeIds: import_zod7.z.array(import_zod7.z.string()).optional().describe("List of acceptable GPU types"),
+      gpuCount: import_zod7.z.number().optional().describe("Number of GPUs"),
+      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"),
+      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")
     },
     { title: "Create pod", ...WRITE },
     async (params) => {
       const backend = backendFor("pods");
+      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";
@@ -1485,6 +2233,12 @@ function registerPodTools(server, rt) {
           });
         }
         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 result = await callRestUrl(
               `${restV1Base(env)}/pods`,
@@ -1509,7 +2263,24 @@ function registerPodTools(server, rt) {
           }
         }
       }
-      const body = backend.mapCreate(params);
+      let body = backend.mapCreate(params);
+      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 };
+      }
       try {
         const result = await callRestUrl(
           `${backend.base}${backend.list}`,
@@ -1524,11 +2295,8 @@ function registerPodTools(server, rt) {
         }
         return jsonReply2(result);
       } catch (error) {
-        if (error instanceof HttpError && error.status === 501) {
-          return jsonReply2({
-            error: "CPU pods are not yet supported on the v2 REST API. Use a GPU pod, or create the CPU pod via the v1 API (set RUNPOD_REST_VERSION=v1).",
-            status: 501
-          });
+        if (error instanceof HttpError) {
+          return jsonReply2({ error: error.message, status: error.status });
         }
         throw error;
       }
@@ -1538,14 +2306,14 @@ function registerPodTools(server, rt) {
     "update-pod",
     "Update a pod's mutable fields (name, image, container disk, volume, ports, env). Only the fields you provide change.",
     {
-      podId: import_zod3.z.string().describe("ID of the pod to update"),
-      name: import_zod3.z.string().optional().describe("New name for the pod"),
-      imageName: import_zod3.z.string().optional().describe("New Docker image"),
-      containerDiskInGb: import_zod3.z.number().optional().describe("New container disk size in GB"),
-      volumeInGb: import_zod3.z.number().optional().describe("New volume size in GB"),
-      volumeMountPath: import_zod3.z.string().optional().describe("New path to mount the volume"),
-      ports: import_zod3.z.array(import_zod3.z.string()).optional().describe("New ports to expose"),
-      env: import_zod3.z.record(import_zod3.z.string()).optional().describe("New environment variables")
+      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) => {
@@ -1564,7 +2332,7 @@ function registerPodTools(server, rt) {
     "start-pod",
     "Start a stopped pod (resumes the same pod and its billing).",
     {
-      podId: import_zod3.z.string().describe("ID of the pod to start")
+      podId: import_zod7.z.string().describe("ID of the pod to start")
     },
     { title: "Start pod", ...WRITE, idempotentHint: true },
     async (params) => {
@@ -1576,7 +2344,7 @@ function registerPodTools(server, rt) {
     "stop-pod",
     "Stop a running pod. The pod and its disk persist; GPU billing stops.",
     {
-      podId: import_zod3.z.string().describe("ID of the pod to stop")
+      podId: import_zod7.z.string().describe("ID of the pod to stop")
     },
     { title: "Stop pod", ...WRITE, idempotentHint: true },
     async (params) => {
@@ -1588,7 +2356,7 @@ function registerPodTools(server, rt) {
     "restart-pod",
     "Restart a running pod (single PodAction call). v2-only \u2014 on the v1 API returns a 501 notice (stop then start the pod instead).",
     {
-      podId: import_zod3.z.string().describe("ID of the pod to restart")
+      podId: import_zod7.z.string().describe("ID of the pod to restart")
     },
     { title: "Restart pod", ...WRITE },
     async (params) => {
@@ -1603,11 +2371,29 @@ function registerPodTools(server, rt) {
       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_zod3.z.string().describe("ID of the pod to delete")
+      podId: import_zod7.z.string().describe("ID of the pod to delete")
     },
     { title: "Delete pod", ...DESTRUCTIVE },
     async (params) => {
@@ -1622,7 +2408,7 @@ function registerPodTools(server, rt) {
 }
 
 // src/tools/endpoints.ts
-var import_zod4 = require("zod");
+var import_zod8 = require("zod");
 function registerEndpointTools(server, rt) {
   const { jsonReply: jsonReply2, callRestUrl, backendFor } = rt;
   server.tool(
@@ -1630,8 +2416,8 @@ function registerEndpointTools(server, rt) {
     "List your Serverless endpoints, optionally expanding template and worker details (v1 only). Paginated via limit/cursor.",
     {
       ...listPaginationParams,
-      includeTemplate: import_zod4.z.boolean().optional().describe("Include template information (v1 only)"),
-      includeWorkers: import_zod4.z.boolean().optional().describe("Include information about workers (v1 only)")
+      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) => {
@@ -1664,9 +2450,9 @@ function registerEndpointTools(server, rt) {
     "get-endpoint",
     "Get one Serverless endpoint by id, optionally expanding template and worker details (v1 only).",
     {
-      endpointId: import_zod4.z.string().describe("ID of the endpoint to retrieve"),
-      includeTemplate: import_zod4.z.boolean().optional().describe("Include template information (v1 only)"),
-      includeWorkers: import_zod4.z.boolean().optional().describe("Include information about workers (v1 only)")
+      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) => {
@@ -1696,32 +2482,32 @@ function registerEndpointTools(server, rt) {
     "create-endpoint",
     "Create a Serverless endpoint. On v2 (default), pass an inline config: imageName + gpuPoolIds (GPU pool names from list-gpu-types \u2014 the `pool` field, e.g. AMPERE_80/ADA_24) plus optional workers/scaling/disk/env. On v1, pass a templateId instead. Worker min/max set autoscaling bounds (min 0 = scale to zero).",
     {
-      name: import_zod4.z.string().optional().describe("Name for the endpoint"),
+      name: import_zod8.z.string().optional().describe("Name for the endpoint"),
       // --- v2 inline-config fields ---
-      imageName: import_zod4.z.string().optional().describe("Docker image (v2). Required on v2 instead of a templateId."),
-      gpuPoolIds: import_zod4.z.array(import_zod4.z.string()).optional().describe(
+      imageName: import_zod8.z.string().optional().describe("Docker image (v2). Required on v2 instead of a templateId."),
+      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_zod4.z.number().optional().describe("GPUs per worker (v2)"),
-      args: import_zod4.z.string().optional().describe("Container start command/args (v2)"),
-      containerDiskInGb: import_zod4.z.number().optional().describe("Container disk size in GB (v2)"),
-      ports: import_zod4.z.array(import_zod4.z.string()).optional().describe("Ports to expose (v2), e.g. ['8000/http']"),
-      env: import_zod4.z.record(import_zod4.z.string()).optional().describe("Environment variables (v2)"),
-      containerRegistryAuthId: import_zod4.z.string().optional().describe("Container registry auth id for a private image (v2)"),
-      networkVolumeIds: import_zod4.z.array(import_zod4.z.string()).optional().describe("Network volume ids to attach (v2)"),
-      executionTimeoutMs: import_zod4.z.number().optional().describe("Per-job execution timeout in ms (v2)"),
-      flashboot: import_zod4.z.enum(["OFF", "FLASHBOOT", "PRIORITY_FLASHBOOT"]).optional().describe("FlashBoot mode (v2)"),
+      gpuCount: import_zod8.z.number().optional().describe("GPUs per worker (v2)"),
+      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_zod4.z.string().optional().describe("Template ID (v1). Required on v1."),
-      computeType: import_zod4.z.enum(["GPU", "CPU"]).optional().describe("GPU or CPU endpoint (v1)"),
-      gpuTypeIds: import_zod4.z.array(import_zod4.z.string()).optional().describe("List of acceptable GPU types (v1)"),
+      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_zod4.z.number().optional().describe("Minimum number of workers"),
-      workersMax: import_zod4.z.number().optional().describe("Maximum number of workers"),
-      scalerType: import_zod4.z.enum(["QUEUE_DELAY", "REQUEST_COUNT"]).optional().describe("Autoscaler type"),
-      scalerValue: import_zod4.z.number().optional().describe("Autoscaler target value"),
-      idleTimeout: import_zod4.z.number().optional().describe("Idle timeout in seconds before scaling a worker down"),
-      dataCenterIds: import_zod4.z.array(import_zod4.z.string()).optional().describe("List of preferred data centers")
+      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 type"),
+      scalerValue: import_zod8.z.number().optional().describe("Autoscaler target value"),
+      idleTimeout: import_zod8.z.number().optional().describe("Idle timeout in seconds before scaling a worker down"),
+      dataCenterIds: import_zod8.z.array(import_zod8.z.string()).optional().describe("List of preferred data centers")
     },
     { title: "Create endpoint", ...WRITE },
     async (params) => {
@@ -1784,25 +2570,25 @@ function registerEndpointTools(server, rt) {
     "update-endpoint",
     "Update a Serverless endpoint's config. On v2 you can change image/disk/env/ports/registry/workers/scaling/networkVolumes/timeout/flashboot; on v1, scaling fields (worker min/max, idle timeout, scaler type/value, name). Only provided fields change.",
     {
-      endpointId: import_zod4.z.string().describe("ID of the endpoint to update"),
-      name: import_zod4.z.string().optional().describe("New name for the endpoint"),
-      workersMin: import_zod4.z.number().optional().describe("New minimum number of workers"),
-      workersMax: import_zod4.z.number().optional().describe("New maximum number of workers"),
-      idleTimeout: import_zod4.z.number().optional().describe("New idle timeout in seconds"),
-      scalerType: import_zod4.z.enum(["QUEUE_DELAY", "REQUEST_COUNT"]).optional().describe("Scaler type"),
-      scalerValue: import_zod4.z.number().optional().describe("Scaler value"),
+      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().optional().describe("New idle timeout in seconds"),
+      scalerType: import_zod8.z.enum(["QUEUE_DELAY", "REQUEST_COUNT"]).optional().describe("Scaler type"),
+      scalerValue: import_zod8.z.number().optional().describe("Scaler value"),
       // --- v2-only inline-config fields ---
-      imageName: import_zod4.z.string().optional().describe("New Docker image (v2)"),
-      gpuPoolIds: import_zod4.z.array(import_zod4.z.string()).optional().describe('New GPU pool names (v2), e.g. ["AMPERE_80"]'),
-      gpuCount: import_zod4.z.number().optional().describe("New GPUs per worker (v2)"),
-      args: import_zod4.z.string().optional().describe("New container args (v2)"),
-      containerDiskInGb: import_zod4.z.number().optional().describe("New container disk size in GB (v2)"),
-      ports: import_zod4.z.array(import_zod4.z.string()).optional().describe("New ports (v2)"),
-      env: import_zod4.z.record(import_zod4.z.string()).optional().describe("New environment variables (v2)"),
-      containerRegistryAuthId: import_zod4.z.string().optional().describe("New container registry auth id (v2)"),
-      networkVolumeIds: import_zod4.z.array(import_zod4.z.string()).optional().describe("New network volume ids (v2)"),
-      executionTimeoutMs: import_zod4.z.number().optional().describe("New per-job execution timeout in ms (v2)"),
-      flashboot: import_zod4.z.enum(["OFF", "FLASHBOOT", "PRIORITY_FLASHBOOT"]).optional().describe("New FlashBoot mode (v2)")
+      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)"),
+      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) => {
@@ -1821,7 +2607,7 @@ function registerEndpointTools(server, rt) {
     "delete-endpoint",
     "Permanently delete a Serverless endpoint. This cannot be undone.",
     {
-      endpointId: import_zod4.z.string().describe("ID of the endpoint to delete")
+      endpointId: import_zod8.z.string().describe("ID of the endpoint to delete")
     },
     { title: "Delete endpoint", ...DESTRUCTIVE },
     async (params) => {
@@ -1833,12 +2619,39 @@ function registerEndpointTools(server, rt) {
       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. Paginated via limit/cursor.",
     {
       ...listPaginationParams,
-      endpointId: import_zod4.z.string().describe("ID of the Serverless endpoint whose workers to list")
+      endpointId: import_zod8.z.string().describe("ID of the Serverless endpoint whose workers to list")
     },
     { title: "List endpoint workers", ...READ_ONLY },
     async (params) => {
@@ -1859,30 +2672,51 @@ function registerEndpointTools(server, rt) {
       );
     }
   );
+  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. 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_zod5 = require("zod");
+var import_zod9 = require("zod");
 function registerJobTools(server, rt) {
   const { jsonReply: jsonReply2, serverlessRequest } = rt;
-  const endpointIdSchema = import_zod5.z.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid endpoint ID format");
-  const jobIdSchema = import_zod5.z.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid job ID format");
-  const inputSchema = import_zod5.z.record(import_zod5.z.unknown()).describe(
+  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_zod5.z.string().url().optional().describe(
+  const webhookSchema = import_zod9.z.string().url().optional().describe(
     "Webhook URL to receive job completion notifications instead of polling"
   );
-  const policySchema = import_zod5.z.object({
-    executionTimeout: import_zod5.z.number().optional().describe("Maximum execution time in milliseconds"),
-    lowPriority: import_zod5.z.boolean().optional().describe("Submit as a low-priority job"),
-    ttl: import_zod5.z.number().optional().describe("Time-to-live for the job result in milliseconds")
+  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_zod5.z.object({
-    accessId: import_zod5.z.string().describe("S3 access key ID"),
-    accessSecret: import_zod5.z.string().describe("S3 secret access key"),
-    bucketName: import_zod5.z.string().describe("S3 bucket name"),
-    endpointUrl: import_zod5.z.string().describe("S3 endpoint URL")
+  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",
@@ -1916,7 +2750,7 @@ function registerJobTools(server, rt) {
         "ID of the Serverless endpoint to run synchronously"
       ),
       input: inputSchema,
-      wait: import_zod5.z.number().min(1e3).max(3e5).optional().describe(
+      wait: import_zod9.z.number().min(1e3).max(3e5).optional().describe(
         "How long in milliseconds the server should wait for a result before returning a job ID to poll (1000\u2013300000). Defaults to 90000 (90 seconds)."
       ),
       webhook: webhookSchema,
@@ -2085,7 +2919,7 @@ function registerJobTools(server, rt) {
 }
 
 // src/tools/templates.ts
-var import_zod6 = require("zod");
+var import_zod10 = require("zod");
 function registerTemplateTools(server, rt) {
   const { jsonReply: jsonReply2, callRestUrl, backendFor } = rt;
   server.tool(
@@ -2093,9 +2927,9 @@ function registerTemplateTools(server, rt) {
     `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_zod6.z.boolean().optional().describe("Include official Runpod templates in the response"),
-      includePublicTemplates: import_zod6.z.boolean().optional().describe("Include community-made public templates in the response"),
-      includeEndpointBoundTemplates: import_zod6.z.boolean().optional().describe(
+      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"
       )
     },
@@ -2126,7 +2960,7 @@ function registerTemplateTools(server, rt) {
     "get-template",
     "Get one template by id (image, env, ports, disk/volume config).",
     {
-      templateId: import_zod6.z.string().describe("ID of the template to retrieve")
+      templateId: import_zod10.z.string().describe("ID of the template to retrieve")
     },
     { title: "Get template", ...READ_ONLY },
     async (params) => {
@@ -2139,23 +2973,27 @@ function registerTemplateTools(server, rt) {
   );
   server.tool(
     "create-template",
-    "Create a reusable pod/endpoint template (image, ports, env, disk/volume). On v2 a category is required and defaults to NVIDIA.",
+    "Create a reusable pod/endpoint template (image, ports, env, disk/volume). Category is optional and defaults to NVIDIA.",
     {
-      name: import_zod6.z.string().describe("Name for the template"),
-      imageName: import_zod6.z.string().describe("Docker image to use"),
-      isServerless: import_zod6.z.boolean().optional().describe("Is this a serverless template"),
-      ports: import_zod6.z.array(import_zod6.z.string()).optional().describe("Ports to expose"),
-      dockerEntrypoint: import_zod6.z.array(import_zod6.z.string()).optional().describe("Docker entrypoint commands"),
-      dockerStartCmd: import_zod6.z.array(import_zod6.z.string()).optional().describe("Docker start commands"),
-      env: import_zod6.z.record(import_zod6.z.string()).optional().describe("Environment variables"),
-      containerDiskInGb: import_zod6.z.number().optional().describe("Container disk size in GB"),
-      volumeInGb: import_zod6.z.number().optional().describe("Volume size in GB"),
-      volumeMountPath: import_zod6.z.string().optional().describe("Path to mount the volume"),
-      readme: import_zod6.z.string().optional().describe("README content in markdown format"),
-      category: import_zod6.z.enum(["CPU", "NVIDIA", "AMD"]).optional().describe(
-        "Hardware category for the template. On v2 a category is required and defaults to NVIDIA when omitted \u2014 set CPU or AMD for non-NVIDIA templates so they are not mis-categorized."
+      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 "").'
       ),
-      containerRegistryAuthId: import_zod6.z.string().optional().describe(
+      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."
       )
     },
@@ -2173,15 +3011,18 @@ function registerTemplateTools(server, rt) {
   );
   server.tool(
     "update-template",
-    "Update a template's mutable fields (name, image, ports, env, readme). Only provided fields change.",
+    "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_zod6.z.string().describe("ID of the template to update"),
-      name: import_zod6.z.string().optional().describe("New name for the template"),
-      imageName: import_zod6.z.string().optional().describe("New Docker image"),
-      ports: import_zod6.z.array(import_zod6.z.string()).optional().describe("New ports to expose"),
-      env: import_zod6.z.record(import_zod6.z.string()).optional().describe("New environment variables"),
-      readme: import_zod6.z.string().optional().describe("New README content in markdown format"),
-      containerRegistryAuthId: import_zod6.z.string().optional().describe(
+      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."
       )
     },
@@ -2202,7 +3043,7 @@ function registerTemplateTools(server, rt) {
     "delete-template",
     "Permanently delete a template. This cannot be undone.",
     {
-      templateId: import_zod6.z.string().describe("ID of the template to delete")
+      templateId: import_zod10.z.string().describe("ID of the template to delete")
     },
     { title: "Delete template", ...DESTRUCTIVE },
     async (params) => {
@@ -2217,7 +3058,7 @@ function registerTemplateTools(server, rt) {
 }
 
 // src/tools/network-volumes.ts
-var import_zod7 = require("zod");
+var import_zod11 = require("zod");
 function registerNetworkVolumeTools(server, rt) {
   const { jsonReply: jsonReply2, callRestUrl, backendFor } = rt;
   server.tool(
@@ -2238,7 +3079,7 @@ function registerNetworkVolumeTools(server, rt) {
     "get-network-volume",
     "Get one network volume by id (name, size, data center).",
     {
-      networkVolumeId: import_zod7.z.string().describe("ID of the network volume to retrieve")
+      networkVolumeId: import_zod11.z.string().describe("ID of the network volume to retrieve")
     },
     { title: "Get network volume", ...READ_ONLY },
     async (params) => {
@@ -2251,11 +3092,17 @@ function registerNetworkVolumeTools(server, rt) {
   );
   server.tool(
     "create-network-volume",
-    "Create a persistent network volume in a data center (size 1\u20134000 GB) that pods can mount.",
+    "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_zod7.z.string().describe("Name for the network volume"),
-      size: import_zod7.z.number().describe("Size in GB (1-4000)"),
-      dataCenterId: import_zod7.z.string().describe("Data center ID (see list-data-centers)")
+      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) => {
@@ -2273,9 +3120,11 @@ function registerNetworkVolumeTools(server, rt) {
     "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_zod7.z.string().describe("ID of the network volume to update"),
-      name: import_zod7.z.string().optional().describe("New name for the network volume"),
-      size: import_zod7.z.number().optional().describe("New size in GB (must be larger than current)")
+      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) => {
@@ -2294,7 +3143,7 @@ function registerNetworkVolumeTools(server, rt) {
     "delete-network-volume",
     "Permanently delete a network volume and its data. This cannot be undone.",
     {
-      networkVolumeId: import_zod7.z.string().describe("ID of the network volume to delete")
+      networkVolumeId: import_zod11.z.string().describe("ID of the network volume to delete")
     },
     { title: "Delete network volume", ...DESTRUCTIVE },
     async (params) => {
@@ -2309,9 +3158,14 @@ function registerNetworkVolumeTools(server, rt) {
 }
 
 // src/tools/registries.ts
-var import_zod8 = require("zod");
+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.",
@@ -2330,7 +3184,7 @@ function registerRegistryTools(server, rt) {
     "get-container-registry-auth",
     "Get one saved container-registry credential by id (the secret/password is not returned).",
     {
-      containerRegistryAuthId: import_zod8.z.string().describe("ID of the container registry auth to retrieve")
+      containerRegistryAuthId: import_zod12.z.string().describe("ID of the container registry auth to retrieve")
     },
     { title: "Get container registry auth", ...READ_ONLY },
     async (params) => {
@@ -2345,9 +3199,9 @@ function registerRegistryTools(server, rt) {
     "create-container-registry-auth",
     "Save container-registry credentials (username + password/token) so pods and endpoints can pull private images.",
     {
-      name: import_zod8.z.string().describe("Name for the container registry auth"),
-      username: import_zod8.z.string().describe("Registry username"),
-      password: import_zod8.z.string().describe("Registry password or access token (stored as a secret)")
+      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) => {
@@ -2365,7 +3219,7 @@ function registerRegistryTools(server, rt) {
     "delete-container-registry-auth",
     "Permanently delete a saved container-registry credential. This cannot be undone.",
     {
-      containerRegistryAuthId: import_zod8.z.string().describe("ID of the container registry auth to delete")
+      containerRegistryAuthId: import_zod12.z.string().describe("ID of the container registry auth to delete")
     },
     { title: "Delete container registry auth", ...DESTRUCTIVE },
     async (params) => {
@@ -2377,166 +3231,69 @@ function registerRegistryTools(server, rt) {
       return jsonReply2(result);
     }
   );
-}
-
-// src/tools/tags.ts
-var import_zod9 = require("zod");
-var TAG_RESOURCE_TYPES = [
-  "POD",
-  "NETWORK_VOLUME",
-  "CLUSTER",
-  "SERVERLESS_ENDPOINT"
-];
-var taggedResourceSchema = import_zod9.z.object({
-  id: import_zod9.z.string().describe("Resource identifier (e.g. a pod or endpoint id)"),
-  type: import_zod9.z.enum(TAG_RESOURCE_TYPES).describe("Type of resource to associate with the tag")
-});
-function v2OnlyNotice(tool) {
-  return {
-    error: `${tool} is only available on the v2 REST API. Set RUNPOD_REST_VERSION=v2.`,
-    status: 501
-  };
-}
-function registerTagTools(server, rt) {
-  const { jsonReply: jsonReply2, callRestUrl, backendFor } = rt;
   server.tool(
-    "list-tags",
-    "List your tags (key/value labels on pods, volumes, clusters, and endpoints). v2-only \u2014 returns a 501 notice on the v1 API. Paginated via limit/cursor.",
-    {
-      ...listPaginationParams,
-      includeResources: import_zod9.z.boolean().optional().describe("Include the resources attached to each tag in the response")
-    },
-    { title: "List tags", ...READ_ONLY },
+    "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("tags");
-      if (backend.version === "v1") return jsonReply2(v2OnlyNotice("list-tags"));
-      const query = params.includeResources ? "?include=resources" : "";
-      const raw = await callRestUrl(`${backend.base}${backend.list}${query}`);
-      return capListResult(backend.unwrap(raw), {
+      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(
-    "get-tag",
-    "Get one tag by id, optionally including its attached resources. v2-only \u2014 returns a 501 notice on the v1 API.",
+    "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.",
     {
-      tagId: import_zod9.z.string().describe("ID of the tag to retrieve"),
-      includeResources: import_zod9.z.boolean().optional().describe("Include the resources attached to this tag")
-    },
-    { title: "Get tag", ...READ_ONLY },
-    async (params) => {
-      const backend = backendFor("tags");
-      if (backend.version === "v1") return jsonReply2(v2OnlyNotice("get-tag"));
-      const query = params.includeResources ? "?include=resources" : "";
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.tagId)}${query}`
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "create-tag",
-    "Create a key/value tag, optionally attaching resources at creation. v2-only \u2014 returns a 501 notice on the v1 API.",
-    {
-      key: import_zod9.z.string().min(1).describe('Tag key (e.g. "project")'),
-      value: import_zod9.z.string().min(1).describe('Tag value (e.g. "gpt-training")'),
-      resources: import_zod9.z.array(taggedResourceSchema).optional().describe("Resources to attach to the tag at creation time")
+      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 tag", ...WRITE },
+    { title: "Create registry delegation", ...WRITE },
     async (params) => {
-      const backend = backendFor("tags");
-      if (backend.version === "v1")
-        return jsonReply2(v2OnlyNotice("create-tag"));
+      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}`,
+        `${backend.base}${backend.list}${DELEGATIONS}`,
         "POST",
-        params
+        body
       );
       return jsonReply2(result);
     }
   );
   server.tool(
-    "update-tag",
-    "Update a tag (rename its key/value, or replace its resource associations). Provide at least one of key, value, or resources. Sending resources:[] removes all associations; omitting resources leaves them unchanged. Replacing resources is NOT atomic \u2014 a failed update can leave a partially-applied set, so for small association changes prefer attach-tag/detach-tag. v2-only \u2014 returns a 501 notice on the v1 API.",
+    "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.",
     {
-      tagId: import_zod9.z.string().describe("ID of the tag to update"),
-      key: import_zod9.z.string().min(1).optional().describe("New tag key"),
-      value: import_zod9.z.string().min(1).optional().describe("New tag value"),
-      resources: import_zod9.z.array(taggedResourceSchema).optional().describe(
-        "Replace the tag's resource associations with exactly these. Omit to leave unchanged; pass [] to detach all."
+      delegationId: import_zod12.z.string().describe(
+        "ID of the delegation to revoke (from list-registry-delegations)"
       )
     },
-    // No idempotentHint: replacing `resources` is non-atomic upstream, so a
-    // retried-after-partial-failure update is not guaranteed to be a no-op.
-    { title: "Update tag", ...WRITE },
-    async (params) => {
-      const { tagId, ...updateParams } = params;
-      const backend = backendFor("tags");
-      if (backend.version === "v1")
-        return jsonReply2(v2OnlyNotice("update-tag"));
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(tagId)}`,
-        "PATCH",
-        updateParams
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "delete-tag",
-    "Permanently delete a tag (removes it from all resources it is attached to). This cannot be undone. v2-only \u2014 returns a 501 notice on the v1 API.",
-    {
-      tagId: import_zod9.z.string().describe("ID of the tag to delete")
-    },
-    { title: "Delete tag", ...DESTRUCTIVE },
-    async (params) => {
-      const backend = backendFor("tags");
-      if (backend.version === "v1")
-        return jsonReply2(v2OnlyNotice("delete-tag"));
-      const result = await callRestUrl(
-        `${backend.base}${backend.get(params.tagId)}`,
-        "DELETE"
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "attach-tag",
-    "Attach a tag to a resource (pod, network volume, cluster, or serverless endpoint). Idempotent \u2014 attaching an already-associated resource is a no-op. v2-only \u2014 returns a 501 notice on the v1 API.",
-    {
-      tagId: import_zod9.z.string().describe("ID of the tag"),
-      resourceType: import_zod9.z.enum(TAG_RESOURCE_TYPES).describe("Type of resource to attach the tag to"),
-      resourceId: import_zod9.z.string().describe("ID of the resource to attach the tag to")
-    },
-    { title: "Attach tag to resource", ...WRITE, idempotentHint: true },
-    async (params) => {
-      const backend = backendFor("tags");
-      if (backend.version === "v1")
-        return jsonReply2(v2OnlyNotice("attach-tag"));
-      const result = await callRestUrl(
-        `${backend.base}/tags/${encodeURIComponent(params.tagId)}/resources/${params.resourceType}/${encodeURIComponent(params.resourceId)}`,
-        "PUT"
-      );
-      return jsonReply2(result);
-    }
-  );
-  server.tool(
-    "detach-tag",
-    "Detach a tag from a resource (removes the association only \u2014 the resource and tag are not deleted). Idempotent \u2014 detaching a resource that is not associated is a no-op. v2-only \u2014 returns a 501 notice on the v1 API.",
-    {
-      tagId: import_zod9.z.string().describe("ID of the tag"),
-      resourceType: import_zod9.z.enum(TAG_RESOURCE_TYPES).describe("Type of resource to detach the tag from"),
-      resourceId: import_zod9.z.string().describe("ID of the resource to detach the tag from")
-    },
-    { title: "Detach tag from resource", ...WRITE, idempotentHint: true },
+    { title: "Revoke registry delegation", ...DESTRUCTIVE },
     async (params) => {
-      const backend = backendFor("tags");
-      if (backend.version === "v1")
-        return jsonReply2(v2OnlyNotice("detach-tag"));
+      const backend = backendFor("registries");
+      if (backend.version === "v1") {
+        return jsonReply2(delegationsV2OnlyNotice("delete-registry-delegation"));
+      }
       const result = await callRestUrl(
-        `${backend.base}/tags/${encodeURIComponent(params.tagId)}/resources/${params.resourceType}/${encodeURIComponent(params.resourceId)}`,
+        `${backend.base}${backend.list}${DELEGATIONS}/${encodeURIComponent(
+          params.delegationId
+        )}`,
         "DELETE"
       );
       return jsonReply2(result);
@@ -2545,7 +3302,7 @@ function registerTagTools(server, rt) {
 }
 
 // src/tools/billing.ts
-var import_zod10 = require("zod");
+var import_zod13 = require("zod");
 var BILLING_SCOPE_PATH = {
   all: "/billing",
   pods: "/billing/pods",
@@ -2561,7 +3318,7 @@ function registerBillingTools(server, rt) {
     "Get time-bucketed Runpod spend history, either aggregated across all resources or broken down by resource type (pods, serverless, endpoints, network volumes, clusters). v2-only \u2014 returns a 501 notice on the v1 API. Records are capped via limit/cursor; narrow the window with startTime/endTime or lastN.",
     {
       ...listPaginationParams,
-      scope: import_zod10.z.enum([
+      scope: import_zod13.z.enum([
         "all",
         "pods",
         "serverless",
@@ -2571,14 +3328,14 @@ function registerBillingTools(server, rt) {
       ]).optional().describe(
         'Which billing breakdown to fetch. "all" (default) is the aggregate across every resource.'
       ),
-      startTime: import_zod10.z.string().optional().describe(
+      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_zod10.z.string().optional().describe(
+      endTime: import_zod13.z.string().optional().describe(
         "End of the period (RFC 3339), exclusive. Defaults to now. Mutually exclusive with lastN."
       ),
-      bucketSize: import_zod10.z.enum(["hour", "day", "week", "month", "year"]).optional().describe("Length of each time bucket. Defaults to day."),
-      lastN: import_zod10.z.number().int().positive().optional().describe(
+      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."
       )
     },
@@ -2613,13 +3370,15 @@ function registerBillingTools(server, rt) {
 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);
-  registerTagTools(server, rt);
   registerBillingTools(server, rt);
 }