@runpod/mcp-server 4.10.1 → 4.11.0

package/dist/hosted.cjs

@@ -337,25 +337,16 @@ async function dispatchGeneratedTool(client, tool, args) {
     const value = args[param.name];
     query[param.name] = param.explode === false && Array.isArray(value) ? value.join(",") : value;
   }
-  let requestBody = args.body;
-  if (tool.hasBody && typeof requestBody === "string") {
-    try {
-      requestBody = JSON.parse(requestBody);
-    } catch {
-      return {
-        ok: false,
-        status: 400,
-        payload: {
-          error: "The body argument arrived as a string that is not valid JSON. Send body as an object."
-        }
-      };
-    }
-  }
-  if (tool.hasBody && requestBody !== void 0) {
-    const properties = tool.inputSchema.properties ?? {};
-    const defs = tool.inputSchema.$defs ?? {};
-    requestBody = coerceScalars(requestBody, properties.body, defs);
-  }
+  const sent = tool.hasBody ? bodyAsSent(tool, args.body) : { body: args.body };
+  if (!sent)
+    return {
+      ok: false,
+      status: 400,
+      payload: {
+        error: "The body argument arrived as a string that is not valid JSON. Send body as an object."
+      }
+    };
+  const requestBody = sent.body;
   const verbs = client;
   const { data, error, response } = await verbs[tool.method](tool.path, {
     params: { path: pathParams, query },
@@ -368,6 +359,32 @@ async function dispatchGeneratedTool(client, tool, args) {
     payload: data ?? { status: response.status }
   };
 }
+function bodyAsSent(tool, body) {
+  let parsed = body;
+  if (typeof parsed === "string") {
+    try {
+      parsed = JSON.parse(parsed);
+    } catch {
+      return null;
+    }
+  }
+  if (parsed === void 0) return { body: parsed };
+  const properties = tool.inputSchema.properties ?? {};
+  const defs = tool.inputSchema.$defs ?? {};
+  return { body: coerceScalars(parsed, properties.body, defs) };
+}
+function argsAsSent(tool, args) {
+  if (!tool.hasBody || args.body === void 0) return args;
+  const sent = bodyAsSent(tool, args.body);
+  return sent ? { ...args, body: sent.body } : null;
+}
+function omittedEmptyQueryArg(tool) {
+  const required = new Set(tool.inputSchema.required ?? []);
+  const query = new Set(
+    tool.params.filter((p) => p.location === "query").map((p) => p.name)
+  );
+  return (name, value) => query.has(name) && !required.has(name) && isEmptyValue(value);
+}
 function isEmptyValue(value) {
   return value === null || value === "" || Array.isArray(value) && !value.length;
 }
@@ -2804,6 +2821,109 @@ var generatedTools = [
       }
     }
   },
+  {
+    name: "exec-pod",
+    title: "Run a command in a Pod",
+    operationId: "execPod",
+    description: `Run one command inside a running Pod's container and get stdout, stderr and the exit code back. No SSH key, public IP or exposed port is needed. command is an argv array run without a shell: pass ["sh", "-c", "..."] for pipes, redirects, globs or &&. One call waits at most timeoutSeconds (1-25, default 20). timedOut true means the call stopped waiting, NOT that the command stopped: it keeps running in the container. For anything longer (model downloads, pip installs, builds), start it in the background and log to a file, e.g. ["sh", "-c", "nohup wget -c -O /workspace/m.safetensors URL > /tmp/dl.log 2>&1 &"], then check progress with later calls (ls -la, du -h, tail /tmp/dl.log). stdout and stderr are each capped at 1 MiB (truncated true). Right after a create, the Pod can answer 404 "Pod not found" for about 10 seconds even with the right id, then 409 while its container starts: retry in about 10 seconds, a few times at most. A Pod that is not running answers 409. A host not yet updated for exec answers 503. Reaches only Pods owned by the API key's own account. Commands can change or delete data in the Pod: run write commands only for what the user asked.`,
+    directoryDescription: "Run one command inside a running Pod's container and return stdout, stderr and the exit code. The command is an argv array run without a shell. One call waits at most timeoutSeconds (1-25, default 20); a command still running then keeps running in the container, and the result says timedOut. stdout and stderr are each capped at 1 MiB. A Pod that is not running answers 409, and a host not yet updated for exec answers 503. Reaches only Pods owned by the caller's own account. The command can change or delete data in the Pod.",
+    method: "POST",
+    path: "/v2/pods/{id}/exec",
+    params: [
+      {
+        name: "id",
+        location: "path"
+      }
+    ],
+    hasBody: true,
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: true
+    },
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "Pod identifier"
+        },
+        body: {
+          $ref: "#/$defs/PodExecRequest",
+          type: "object"
+        }
+      },
+      required: ["id", "body"],
+      $defs: {
+        PodExecRequest: {
+          type: "object",
+          additionalProperties: false,
+          required: ["command"],
+          properties: {
+            command: {
+              type: "array",
+              minItems: 1,
+              maxItems: 256,
+              prefixItems: [
+                {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 4096,
+                  pattern: "^[^\\x00]*[^\\t-\\r \x85\xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\\x00][^\\x00]*$"
+                }
+              ],
+              items: {
+                type: "string",
+                maxLength: 4096,
+                pattern: "^[^\\x00]*$"
+              },
+              description: 'Command to run, as an argv array of 1-256 arguments of at most 4096 characters each. It is run directly, never through a shell; for pipes, redirects or globbing pass `["sh", "-c", "..."]`.',
+              examples: [
+                ["nvidia-smi", "--query-gpu=name,memory.used", "--format=csv"]
+              ]
+            },
+            timeoutSeconds: {
+              type: "integer",
+              minimum: 1,
+              maximum: 25,
+              default: 20,
+              description: "How long the call waits for the command to finish, in seconds. A command still running at this point returns with `timedOut: true`.",
+              examples: [10]
+            },
+            cwd: {
+              type: "string",
+              pattern: "^/[^\\x00-\\x1f\\x7f]*$",
+              maxLength: 1024,
+              description: "Absolute working directory for the command, at most 1024 characters and without control characters. Defaults to the image's `WORKDIR`.",
+              examples: ["/workspace"]
+            },
+            env: {
+              type: "object",
+              maxProperties: 64,
+              propertyNames: {
+                type: "string",
+                minLength: 1,
+                maxLength: 256,
+                pattern: "^[^=\\x00]+$"
+              },
+              additionalProperties: {
+                type: "string",
+                maxLength: 16384,
+                pattern: "^[^\\x00]*$"
+              },
+              description: "Up to 64 environment variables added to the container's environment for this command only. A name is 1-256 characters and must not contain `=` or a NUL character; a value is at most 16384 characters and must not contain a NUL character.",
+              examples: [
+                {
+                  HF_HOME: "/workspace/hf"
+                }
+              ]
+            }
+          }
+        }
+      }
+    }
+  },
   {
     name: "get-cluster",
     title: "Get cluster",
@@ -6866,6 +6986,122 @@ var generatedTools = [
   }
 ];
 
+// src/specgen/validate.ts
+var import__ = require("ajv/dist/2020.js");
+function schemaValidationMode(value = process.env.MCP_SCHEMA_VALIDATION) {
+  const mode = value?.trim().toLowerCase();
+  return mode === "off" || mode === "enforce" ? mode : "shadow";
+}
+var ajv = new import__.Ajv2020({
+  strict: false,
+  allErrors: true,
+  validateFormats: false
+});
+var compiled = /* @__PURE__ */ new WeakMap();
+function validatorFor(schema) {
+  let validate = compiled.get(schema);
+  if (!validate) {
+    validate = ajv.compile(structuredClone(schema));
+    compiled.set(schema, validate);
+  }
+  return validate;
+}
+var MAX_NULL_PASSES = 8;
+function isNullTypeError(error, data) {
+  return error.keyword === "type" && error.instancePath !== "" && valueAt(data, error.instancePath) === null;
+}
+function pointerSegments(pointer) {
+  return pointer.split("/").slice(1).map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function valueAt(data, pointer) {
+  let node = data;
+  for (const key of pointerSegments(pointer)) {
+    if (node === null || typeof node !== "object") return void 0;
+    node = node[key];
+  }
+  return node;
+}
+function removeAt(data, pointer) {
+  const segments = pointerSegments(pointer);
+  const last = segments.pop();
+  const parent = valueAt(data, segments.length ? `/${segments.join("/")}` : "");
+  if (last === void 0 || parent === null || typeof parent !== "object")
+    return false;
+  if (Array.isArray(parent)) return false;
+  delete parent[last];
+  return true;
+}
+var WRAPPER_KEYWORDS = /* @__PURE__ */ new Set(["if"]);
+function toViolation(error) {
+  const base = pointerSegments(error.instancePath);
+  let path = base.join(".");
+  let message = error.message ?? "is invalid";
+  const params = error.params;
+  if (error.keyword === "required" && typeof params.missingProperty === "string") {
+    path = [...base, params.missingProperty].join(".");
+    message = "is required";
+  } else if (error.keyword === "additionalProperties" && typeof params.additionalProperty === "string") {
+    path = [...base, params.additionalProperty].join(".");
+    message = "is not an accepted argument here";
+  } else if (error.keyword === "pattern") {
+    message = "is not in an accepted format";
+  }
+  const allowed = error.keyword === "enum" ? params.allowedValues : error.keyword === "const" ? [params.allowedValue] : void 0;
+  return {
+    path,
+    keyword: error.keyword,
+    message,
+    ...allowed ? { allowed } : {},
+    schemaPath: error.schemaPath
+  };
+}
+function schemaViolations(schema, args, omitted = () => false) {
+  const validate = validatorFor(schema);
+  const data = structuredClone(
+    Object.fromEntries(
+      Object.entries(args).filter(([name, value]) => !omitted(name, value))
+    )
+  );
+  for (let pass = 0; ; pass++) {
+    if (validate(data)) return [];
+    const errors = validate.errors ?? [];
+    let removed = false;
+    if (pass < MAX_NULL_PASSES) {
+      for (const error of errors.filter((e) => isNullTypeError(e, data)))
+        removed = removeAt(data, error.instancePath) || removed;
+    }
+    if (!removed) {
+      return errors.filter((e) => !WRAPPER_KEYWORDS.has(e.keyword)).map(toViolation);
+    }
+  }
+}
+var INVALID_ARGUMENTS_HINT = "Fix the listed fields and call again.";
+function invalidArgumentsPayload(violations) {
+  return {
+    error: "Invalid arguments",
+    code: "invalid_arguments",
+    fields: violations.map(({ path, message, allowed }) => ({
+      path,
+      problem: message,
+      ...allowed ? { allowed } : {}
+    })),
+    hint: INVALID_ARGUMENTS_HINT
+  };
+}
+function logSchemaViolations(tool, mode, violations) {
+  console.error(
+    "schema_violation",
+    JSON.stringify({
+      tool,
+      mode,
+      violations: violations.map(({ keyword, schemaPath }) => ({
+        keyword,
+        schemaPath
+      }))
+    })
+  );
+}
+
 // src/specgen/tools/annotations.ts
 var readOnly = {
   readOnlyHint: true,
@@ -7080,6 +7316,8 @@ var DIRECTORY_TOOLS = {
   "deploy-hub-repo": IN,
   "detach-cost-center-resource": IN,
   "endpoint-health": IN,
+  // env can carry tokens (HF_TOKEN for a model download), so the directory omits it.
+  "exec-pod": { include: true, omitInputs: ["body.env"] },
   "get-capacity": IN,
   "get-cluster": IN,
   "get-cost-center": IN,
@@ -7199,6 +7437,21 @@ function directoryOmittedInputs(name) {
   const decision = DIRECTORY_TOOLS[name];
   return decision?.include ? decision.omitInputs ?? [] : [];
 }
+function omittedInputsIn(omit, args) {
+  return omit.filter((key) => {
+    const [parent, child] = key.split(".");
+    if (child === void 0) return parent in args;
+    let value = args[parent];
+    if (typeof value === "string") {
+      try {
+        value = JSON.parse(value);
+      } catch {
+        return false;
+      }
+    }
+    return !!value && typeof value === "object" && child in value;
+  });
+}
 function profileForPath(pathname) {
   return pathname.replace(/\/+$/, "") === DIRECTORY_PATH ? "directory" : "default";
 }
@@ -10788,13 +11041,40 @@ function withoutCredentialExamples(schema) {
   };
   return strip(schema);
 }
-function withoutInputs(schema, omit) {
-  if (!omit.length) return schema;
+function withoutKeys(schema, omit) {
   const properties = { ...schema.properties ?? {} };
   for (const key of omit) delete properties[key];
   const required = Array.isArray(schema.required) ? schema.required.filter((key) => !omit.includes(key)) : schema.required;
   return { ...schema, properties, ...required ? { required } : {} };
 }
+function withoutInputs(schema, omit) {
+  if (!omit.length) return schema;
+  let out = withoutKeys(
+    schema,
+    omit.filter((key) => !key.includes("."))
+  );
+  for (const key of omit.filter((k) => k.includes("."))) {
+    const [parent, child] = key.split(".");
+    const properties = out.properties ?? {};
+    const node = properties[parent];
+    if (!node) continue;
+    const ref = typeof node.$ref === "string" ? node.$ref : void 0;
+    const defName = ref?.startsWith("#/$defs/") ? ref.slice(8) : void 0;
+    const defs = out.$defs ?? {};
+    if (defName && defs[defName]) {
+      out = {
+        ...out,
+        $defs: { ...defs, [defName]: withoutKeys(defs[defName], [child]) }
+      };
+    } else {
+      out = {
+        ...out,
+        properties: { ...properties, [parent]: withoutKeys(node, [child]) }
+      };
+    }
+  }
+  return out;
+}
 function callShape(schema) {
   const defs = schema.$defs ?? {};
   const resolve = (node) => {
@@ -10896,7 +11176,7 @@ function words2(name) {
 
 // src/server.ts
 var SERVER_NAME = "Runpod API Server";
-var SERVER_VERSION = true ? "4.10.1" : "dev";
+var SERVER_VERSION = true ? "4.11.0" : "dev";
 
 // src/specgen/analytics.ts
 var import_node_crypto = require("crypto");
@@ -11607,6 +11887,7 @@ function createSpecgenServer(ctx, version = "0.1.0", opts = {}) {
   const caller = callerId(ctx.apiKey);
   const profile = opts.profile ?? "default";
   const directory = profile === "directory";
+  const schemaMode = schemaValidationMode();
   const alp = directory ? void 0 : opts.alp;
   const servedGeneratedTools = directory ? generatedTools.filter((tool) => directoryIncludes(tool.name)) : generatedTools;
   const servedCuratedTools = [
@@ -11713,7 +11994,7 @@ function createSpecgenServer(ctx, version = "0.1.0", opts = {}) {
       (tool) => tool.name === request.params.name
     );
     const curatedArgs = curated ? withoutNullOptionals(curated.inputSchema, args) : args;
-    const omitted = directory ? directoryOmittedInputs(request.params.name).filter((key) => key in args) : [];
+    const omitted = directory ? omittedInputsIn(directoryOmittedInputs(request.params.name), args) : [];
     const rejected = omitted.length ? {
       ok: false,
       status: 400,
@@ -11723,8 +12004,26 @@ function createSpecgenServer(ctx, version = "0.1.0", opts = {}) {
     } : curated && !curated.lenientArguments ? validateArguments(
       curated.inputSchema,
       curatedArgs
-    ) : null;
-    const result = rejected ?? await runTool(
+    ) : generated ? validateArguments(generated.inputSchema, args) : null;
+    let schemaRejected = null;
+    if (!rejected && schemaMode !== "off") {
+      const sent = generated ? argsAsSent(generated, args) : null;
+      const violations = curated ? curated.lenientArguments ? [] : schemaViolations(curated.inputSchema, curatedArgs) : generated && sent ? schemaViolations(
+        generated.inputSchema,
+        sent,
+        omittedEmptyQueryArg(generated)
+      ) : [];
+      if (violations.length) {
+        logSchemaViolations(request.params.name, schemaMode, violations);
+        if (schemaMode === "enforce")
+          schemaRejected = {
+            ok: false,
+            status: 400,
+            payload: invalidArgumentsPayload(violations)
+          };
+      }
+    }
+    const result = rejected ?? schemaRejected ?? await runTool(
       () => curated ? curated.handler(ctx, curatedArgs) : dispatchTool(generated, request.params.name, args)
     );
     logToolCall({
@@ -12063,6 +12362,7 @@ function createToolContext(options = {}) {
 
 // src/specgen/not-found-limiter.ts
 var SINK_TIMEOUT_MS2 = 3e3;
+var LOOP_LIMITED_TOOLS = /* @__PURE__ */ new Set(["get-pod"]);
 var NOT_FOUND_LOOP = "not_found_loop";
 var blocked = /* @__PURE__ */ new Map();
 function notFoundSinkUrl(submitUrl) {
@@ -12087,7 +12387,7 @@ function createNotFoundLimiter(opts) {
       };
     },
     onToolResult: (tool, status) => {
-      if (status !== 404) return;
+      if (status !== 404 || !LOOP_LIMITED_TOOLS.has(tool)) return;
       const pair = `${opts.key}|${tool}`;
       void fetchImpl(opts.sinkUrl, {
         method: "POST",