Claude Code on the free tier, GPU tests over MCP

"""Run your GPU tests on a Runcrate GPU from CI, through the same MCP tools Claude Code calls (run_job, get_job_logs, get_job).

pip install requests
RUNCRATE_API_KEY=... python gpu_tests.py tests/            exits with the tests' exit code
RUNCRATE_API_KEY=... python gpu_tests.py tests/ --dry-run  prints the run_job call and sends nothing
An agent signs in to the MCP server with OAuth. This script uses an API key, and today the server then also needs an
X-Project-Id header: any value works (the key already names your workspace) until that is fixed.
"""
import itertools, json, os, sys, time
from pathlib import Path

import requests

MCP = "https://mcp.runcrate.ai/mcp"
H = {"Authorization": f"Bearer {os.environ['RUNCRATE_API_KEY']}", "Content-Type": "application/json",
     "Accept": "application/json, text/event-stream", "X-Project-Id": "key-scoped"}
ids = itertools.count(1)

def rpc(method: str, params: dict | None = None) -> dict:
    for attempt in range(5):
        r = requests.post(MCP, headers=H, json={"jsonrpc": "2.0", "id": next(ids), "method": method, "params": params or {}}, timeout=90)
        if r.status_code in (429, 502, 503, 504):
            time.sleep(2 ** attempt); continue
        r.raise_for_status()
        body = r.json()
        if "error" in body:
            raise RuntimeError(body["error"])
        return body["result"]
    raise RuntimeError(f"{method} kept failing")

def tool(name: str, args: dict) -> dict:
    result = rpc("tools/call", {"name": name, "arguments": args})
    text = "".join(c.get("text", "") for c in result.get("content", []))
    if result.get("isError"):
        raise RuntimeError(f"{name}: {text}")
    try:
        return json.loads(text)
    except json.JSONDecodeError:
        return {"text": text}

def main(folder: str, dry_run: bool) -> int:
    rpc("initialize", {"protocolVersion": "2025-03-26", "capabilities": {}, "clientInfo": {"name": "gpu-tests", "version": "1"}})
    names = {t["name"] for t in rpc("tools/list")["tools"]}
    assert {"run_job", "get_job_logs", "get_job"} <= names, "the MCP server is missing a job tool"

    # The tests travel as files (up to 1 MB); a bigger project goes as code.git instead.
    files = {str(p.relative_to(folder)): p.read_text() for p in Path(folder).rglob("*.py")}
    args = {"gpu": ["A6000", "L40S", "A4000", "RTX4000Ada"], "template": "ubuntu-train", "max_runtime_minutes": 10,
            "command": "python3 -m pip install -q pytest && python3 -m pytest -q", "files": files,
            "name": "gpu-tests", "tags": {"ci": "gpu-tests"}}
    if dry_run:
        print(json.dumps({"tool": "run_job", "arguments": {**args, "files": {k: f"{len(v)} chars" for k, v in files.items()}}}, indent=2))
        return 0

    t0 = time.time()
    job = tool("run_job", args)
    jid = job.get("id") or job.get("job", {}).get("id")
    print(f"job {jid} on {job.get('gpu_type', '')}")
    after = 0
    while True:  # get_job_logs waits up to 25 s for new output each call
        page = tool("get_job_logs", {"id": jid, "after": after, "follow": True})
        for chunk in page.get("chunks", []):
            print(chunk.get("text", ""), end="", flush=True)
        after = page.get("cursor", after)
        if page.get("done"):
            break
    done = tool("get_job", {"id": jid})
    cost = sum((a.get("cost_usd") or 0) for a in done.get("attempts", []))
    run = {"job": jid, "status": done.get("status"), "exit_code": done.get("exit_code"), "gpu": done.get("gpu_type"),
           "seconds": round(time.time() - t0, 1), "cost_usd": cost}
    Path("run.json").write_text(json.dumps(run, indent=2))
    print(f"\n{json.dumps(run)}")
    return done.get("exit_code") if isinstance(done.get("exit_code"), int) else 1

if __name__ == "__main__":
    sys.exit(main(sys.argv[1], "--dry-run" in sys.argv))

// Run your GPU tests on a Runcrate GPU from CI, through the same MCP tools Claude Code calls (run_job, get_job_logs, get_job).
//
// No dependencies (Node 18+)
// RUNCRATE_API_KEY=... npx tsx gpu-tests.ts tests/            exits with the tests' exit code
// RUNCRATE_API_KEY=... npx tsx gpu-tests.ts tests/ --dry-run  prints the run_job call and sends nothing
// An agent signs in to the MCP server with OAuth. This script uses an API key, and today the server then also needs an
// X-Project-Id header: any value works (the key already names your workspace) until that is fixed.
import { readdirSync, readFileSync, writeFileSync } from "node:fs";
import { join, relative } from "node:path";

const MCP = "https://mcp.runcrate.ai/mcp";
const H = {
  Authorization: `Bearer ${process.env.RUNCRATE_API_KEY}`,
  "Content-Type": "application/json",
  Accept: "application/json, text/event-stream",
  "X-Project-Id": "key-scoped",
};
const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
let nextId = 1;

type RpcResult = { tools?: { name: string }[]; content?: { text?: string }[]; isError?: boolean };
type Job = { id?: string; job?: { id: string }; gpu_type?: string; status?: string; exit_code?: number | null; attempts?: { cost_usd?: number }[] };
type LogsPage = { chunks?: { text?: string }[]; cursor?: number; done?: boolean };

async function rpc(method: string, params: object = {}): Promise<RpcResult> {
  for (let attempt = 0; attempt < 5; attempt++) {
    const r = await fetch(MCP, { method: "POST", headers: H, body: JSON.stringify({ jsonrpc: "2.0", id: nextId++, method, params }) });
    if ([429, 502, 503, 504].includes(r.status)) {
      await sleep(2 ** attempt * 1000);
      continue;
    }
    if (!r.ok) throw new Error(`${method}: ${r.status} ${await r.text()}`);
    const body = (await r.json()) as { error?: unknown; result: RpcResult };
    if (body.error) throw new Error(`${method}: ${JSON.stringify(body.error)}`);
    return body.result;
  }
  throw new Error(`${method} kept failing`);
}

/** Call a tool; its text answer is the JSON of T (the shapes above are the fields this script reads). */
async function tool<T>(name: string, args: object): Promise<T> {
  const result = await rpc("tools/call", { name, arguments: args });
  const text = (result.content ?? []).map((c) => c.text ?? "").join("");
  if (result.isError) throw new Error(`${name}: ${text}`);
  return JSON.parse(text) as T;
}

const [folder, ...flags] = process.argv.slice(2);
await rpc("initialize", { protocolVersion: "2025-03-26", capabilities: {}, clientInfo: { name: "gpu-tests", version: "1" } });
const names = new Set((await rpc("tools/list")).tools?.map((t) => t.name));
for (const t of ["run_job", "get_job_logs", "get_job"]) if (!names.has(t)) throw new Error(`the MCP server is missing ${t}`);

// The tests travel as files (up to 1 MB); a bigger project goes as code.git instead.
const files: Record<string, string> = {};
for (const f of (readdirSync(folder, { recursive: true }) as string[]).filter((f) => f.endsWith(".py"))) {
  files[relative(folder, join(folder, f))] = readFileSync(join(folder, f), "utf8");
}
const args = {
  gpu: ["A6000", "L40S", "A4000", "RTX4000Ada"],
  template: "ubuntu-train",
  max_runtime_minutes: 10,
  command: "python3 -m pip install -q pytest && python3 -m pytest -q",
  files,
  name: "gpu-tests",
  tags: { ci: "gpu-tests" },
};
if (flags.includes("--dry-run")) {
  const shown = Object.fromEntries(Object.entries(files).map(([k, v]) => [k, `${v.length} chars`]));
  console.log(JSON.stringify({ tool: "run_job", arguments: { ...args, files: shown } }, null, 2));
  process.exit(0);
}

const t0 = Date.now();
const job = await tool<Job>("run_job", args);
const jid = job.id ?? job.job?.id ?? "";
console.log(`job ${jid} on ${job.gpu_type ?? ""}`);
let after = 0;
for (;;) {
  // get_job_logs waits up to 25 s for new output each call
  const page = await tool<LogsPage>("get_job_logs", { id: jid, after, follow: true });
  for (const chunk of page.chunks ?? []) process.stdout.write(chunk.text ?? "");
  after = page.cursor ?? after;
  if (page.done) break;
}
const done = await tool<Job>("get_job", { id: jid });
const cost = (done.attempts ?? []).reduce((s, a) => s + (a.cost_usd ?? 0), 0);
const run = { job: jid, status: done.status, exit_code: done.exit_code, gpu: done.gpu_type, seconds: (Date.now() - t0) / 1000, cost_usd: cost };
writeFileSync("run.json", JSON.stringify(run, null, 2));
console.log(`\n${JSON.stringify(run)}`);
process.exit(typeof done.exit_code === "number" ? done.exit_code : 1);