failproofai 1.0.7-beta.0 → 1.0.7-beta.2

package/.next/standalone/sdk/typescript/test/copies.test.ts

@@ -0,0 +1,204 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import { resolveEsm } from "../src/node-require.js";
+
+/**
+ * Which copy of a dual-published framework an adapter patches.
+ *
+ * The first release resolved every framework with `createRequire`, which can
+ * only name the CommonJS build — so in an ES-module application, the default
+ * for a new TypeScript project, `instrument()` patched a copy nothing used and
+ * recorded nothing. These tests build a fake dual package on disk and run
+ * `requireModuleCopies` from REAL entry points of each module system, because
+ * "which module system is the entry" is a property of the process and cannot be
+ * faked from inside a test runner.
+ */
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+let app: string;
+
+function write(path: string, text: string): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, text);
+}
+
+/** A copy that says which build it is and records that it was loaded. */
+const copy = (marker: string, esm: boolean): string =>
+  esm
+    ? `globalThis.__loaded = [...(globalThis.__loaded ?? []), "${marker}"];\nexport const marker = "${marker}";\nexport class Thing {}\n`
+    : `globalThis.__loaded = [...(globalThis.__loaded ?? []), "${marker}"];\nexports.marker = "${marker}";\nexports.Thing = class Thing {};\n`;
+
+beforeAll(() => {
+  app = mkdtempSync(join(tmpdir(), "failproofai-copies-"));
+  const modules = join(app, "node_modules");
+
+  // A dual package with a root entry, a subpath and a pattern, conditions
+  // nested the way real frameworks publish them (`@langchain/core` does
+  // exactly `{ import: { types, default }, require: { types, default } }`).
+  write(
+    join(modules, "dualfw", "package.json"),
+    JSON.stringify({
+      name: "dualfw",
+      version: "1.2.3",
+      exports: {
+        ".": { import: { types: "./x.d.ts", default: "./esm/index.js" }, require: "./cjs/index.cjs" },
+        "./callbacks/manager": { import: "./esm/manager.js", require: "./cjs/manager.cjs" },
+        "./tools/*": { node: { import: "./esm/tools/*.js", require: "./cjs/tools/*.cjs" } },
+      },
+    }),
+  );
+  write(join(modules, "dualfw", "esm", "index.js"), copy("esm", true));
+  write(join(modules, "dualfw", "cjs", "index.cjs"), copy("cjs", false));
+  write(join(modules, "dualfw", "esm", "manager.js"), copy("esm-manager", true));
+  write(join(modules, "dualfw", "cjs", "manager.cjs"), copy("cjs-manager", false));
+  write(join(modules, "dualfw", "esm", "tools", "search.js"), copy("esm-search", true));
+  write(join(modules, "dualfw", "cjs", "tools", "search.cjs"), copy("cjs-search", false));
+
+  // ESM-only: no `require` condition, so CommonJS resolution cannot find it.
+  write(
+    join(modules, "@scope", "esmonly", "package.json"),
+    JSON.stringify({ name: "@scope/esmonly", exports: { ".": { import: "./index.js" } } }),
+  );
+  write(join(modules, "@scope", "esmonly", "index.js"), copy("esmonly", true));
+
+  // No exports map: Node reads `main` for both, so there is one copy.
+  write(join(modules, "plainfw", "package.json"), JSON.stringify({ name: "plainfw", main: "main.js" }));
+  write(join(modules, "plainfw", "main.js"), copy("plain", false));
+});
+
+afterAll(() => {
+  rmSync(app, { recursive: true, force: true });
+});
+
+describe("resolveEsm", () => {
+  const inApp = <T>(fn: () => T): T => {
+    const cwd = process.cwd();
+    process.chdir(app);
+    try {
+      return fn();
+    } finally {
+      process.chdir(cwd);
+    }
+  };
+
+  it("names the import build of a dual package, root and subpath", () => {
+    inApp(() => {
+      expect(resolveEsm("dualfw")).toBe(join(app, "node_modules", "dualfw", "esm", "index.js"));
+      expect(resolveEsm("dualfw/callbacks/manager")).toBe(
+        join(app, "node_modules", "dualfw", "esm", "manager.js"),
+      );
+    });
+  });
+
+  it("expands a subpath pattern through nested conditions", () => {
+    inApp(() => {
+      expect(resolveEsm("dualfw/tools/search")).toBe(
+        join(app, "node_modules", "dualfw", "esm", "tools", "search.js"),
+      );
+    });
+  });
+
+  it("finds an ESM-only package that CommonJS resolution cannot", () => {
+    inApp(() => {
+      expect(resolveEsm("@scope/esmonly")).toBe(join(app, "node_modules", "@scope", "esmonly", "index.js"));
+    });
+  });
+
+  it("returns null where there is no separate ESM copy or no such module", () => {
+    inApp(() => {
+      expect(resolveEsm("plainfw")).toBeNull();
+      expect(resolveEsm("dualfw/not-exported")).toBeNull();
+      expect(resolveEsm("not-installed-anywhere")).toBeNull();
+    });
+  });
+});
+
+describe("requireModuleCopies", () => {
+  /** Run `body` in a fresh process whose ENTRY is an ES module or CommonJS. */
+  const run = (entry: "esm" | "cjs", body: string, where: { dir?: string; cwd?: string } = {}): string[] => {
+    const compat =
+      entry === "esm"
+        ? pathToFileURL(join(root, "dist", "esm", "integrations", "compat.js")).href
+        : join(root, "dist", "cjs", "integrations", "compat.js");
+    const file = join(where.dir ?? app, entry === "esm" ? "main.mjs" : "main.cjs");
+    const header =
+      entry === "esm"
+        ? `import { createRequire } from "node:module";\nimport * as compat from ${JSON.stringify(compat)};\nconst require = createRequire(import.meta.url);\n`
+        : `const compat = require(${JSON.stringify(compat)});\n`;
+    write(
+      file,
+      `${header}(async () => {\n${body}\nconsole.log(JSON.stringify({ result, loaded: globalThis.__loaded ?? [] }));\n})().catch((e) => { console.log(JSON.stringify({ error: String(e.message) })); });\n`,
+    );
+    const child = spawnSync(process.execPath, [file], { cwd: where.cwd ?? app, encoding: "utf8" });
+    expect(child.stderr).toBe("");
+    const parsed = JSON.parse(child.stdout.trim()) as { result?: string[]; loaded?: string[]; error?: string };
+    if (parsed.error !== undefined) return [`error: ${parsed.error}`];
+    return [...parsed.result!, "|", ...parsed.loaded!];
+  };
+
+  const markers = 'const result = (await compat.requireModuleCopies(SPEC, "npm i x")).map((m) => m.marker);';
+
+  it("patches the ES-module copy for an ES-module app, and loads nothing else", () => {
+    expect(run("esm", markers.replace("SPEC", '"dualfw"'))).toEqual(["esm", "|", "esm"]);
+  });
+
+  it("also patches the CommonJS copy when something already required it", () => {
+    const body = `require("dualfw");\n${markers.replace("SPEC", '"dualfw"')}`;
+    expect(run("esm", body)).toEqual(["esm", "cjs", "|", "cjs", "esm"]);
+  });
+
+  it("patches the CommonJS copy for a CommonJS app, without loading the ESM build", () => {
+    expect(run("cjs", markers.replace("SPEC", '"dualfw"'))).toEqual(["cjs", "|", "cjs"]);
+    expect(run("cjs", markers.replace("SPEC", '"dualfw/callbacks/manager"'))).toEqual([
+      "cjs-manager",
+      "|",
+      "cjs-manager",
+    ]);
+  });
+
+  it("uses the one copy an ESM-only or exports-less package has", () => {
+    expect(run("esm", markers.replace("SPEC", '"@scope/esmonly"'))).toEqual(["esmonly", "|", "esmonly"]);
+    expect(run("cjs", markers.replace("SPEC", '"@scope/esmonly"'))).toEqual(["esmonly", "|", "esmonly"]);
+    expect(run("esm", markers.replace("SPEC", '"plainfw"'))).toEqual(["plain", "|", "plain"]);
+  });
+
+  it("finds the framework from the entry script when the service runs from /", () => {
+    // systemd with no WorkingDirectory=, a container with WORKDIR unset.
+    expect(run("esm", markers.replace("SPEC", '"dualfw"'), { cwd: "/" })).toEqual(["esm", "|", "esm"]);
+    expect(run("cjs", markers.replace("SPEC", '"dualfw"'), { cwd: "/" })).toEqual(["cjs", "|", "cjs"]);
+  });
+
+  it("patches the app's own nested copy, not the one a monorepo root hoists", () => {
+    // root/node_modules/dualfw is the hoisted copy; root/apps/web has its own.
+    const web = join(app, "apps", "web");
+    const nested = join(web, "node_modules", "dualfw");
+    write(
+      join(nested, "package.json"),
+      JSON.stringify({ name: "dualfw", exports: { ".": { import: "./esm.js", require: "./cjs.cjs" } } }),
+    );
+    write(join(nested, "esm.js"), copy("nested-esm", true));
+    write(join(nested, "cjs.cjs"), copy("nested-cjs", false));
+    // Started from the monorepo root, as a root-level script runner does.
+    expect(run("esm", markers.replace("SPEC", '"dualfw"'), { dir: web, cwd: app })).toEqual([
+      "nested-esm",
+      "|",
+      "nested-esm",
+    ]);
+    expect(run("cjs", markers.replace("SPEC", '"dualfw"'), { dir: web, cwd: app })).toEqual([
+      "nested-cjs",
+      "|",
+      "nested-cjs",
+    ]);
+  });
+
+  it("throws with the install command when the framework is absent", () => {
+    const [line] = run("esm", markers.replace("SPEC", '"not-installed-anywhere"'));
+    expect(line).toMatch(/not importable\. Install it with: {2}npm i x/);
+  });
+});

package/.next/standalone/sdk/typescript/test/edge.test.ts

@@ -0,0 +1,183 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import * as edge from "../src/edge/index.js";
+import { EDGE_NOTICE, resetNotice } from "../src/edge/notice.js";
+
+/**
+ * The no-op build an Edge / Worker runtime or a browser bundle gets through the
+ * `edge-light` / `workerd` / `worker` / `browser` export conditions.
+ *
+ * Found by `integration/nextjs.test.ts`: a Next.js route with
+ * `export const runtime = "edge"` importing the SDK failed `next build`
+ * outright — "Native module not found: node:fs" — because the real entry
+ * statically imports Node builtins and an ES module cannot catch that.
+ */
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const edgeDir = join(root, "src", "edge");
+
+afterEach(() => {
+  resetNotice();
+  vi.restoreAllMocks();
+});
+
+describe("the edge build's imports", () => {
+  it("imports no Node builtin and nothing from the Node build but VERSION and types", () => {
+    for (const file of readdirSync(edgeDir).filter((name) => name.endsWith(".ts"))) {
+      const source = readFileSync(join(edgeDir, file), "utf8");
+      const imports = [...source.matchAll(/^import\s+(type\s+)?[^;]*?from\s+"([^"]+)";/gms)].map((m) => ({
+        typeOnly: m[1] !== undefined,
+        from: m[2]!,
+      }));
+      for (const { typeOnly, from } of imports) {
+        if (typeOnly) continue;
+        const allowed = from.startsWith("./") || from === "../version.js";
+        expect(allowed, `${file} imports ${from} at run time`).toBe(true);
+      }
+      expect(source, file).not.toMatch(/\bprocess\./);
+      expect(source, file).not.toMatch(/require\(/);
+    }
+  });
+});
+
+/**
+ * Exports of the Node build that are internals (test helpers, parsing
+ * functions) rather than API; an edge module need not mirror them. Anything
+ * NOT listed here must exist in the edge build, or an Edge import of it is a
+ * link error — the crash this build exists to prevent.
+ */
+const INTERNAL: Record<string, string[]> = {
+  index: [],
+  ai: ["toolCallsOf", "_internals", "usageTokens", "stopReasonOf", "responseContent"],
+  langchain: [
+    "ABANDONED_ROOT_GRACE_MS",
+    "PAUSED_SESSION_TTL_MS",
+    "_stats",
+    "captureLimitOf",
+    "interruptIdOf",
+    "isCancellation",
+    "isControlFlow",
+    "nodeOf",
+    "normalizeMessages",
+    "resetOrphanWarning",
+    "promptOf",
+    "readOptions",
+    "summarizeDocuments",
+    "toolOutput",
+    "usageOf",
+  ],
+  mastra: ["_internals"],
+  llamaindex: ["BELOW_VERSION", "MIN_VERSION", "eventCallerStorage", "parseOptions", "summarizeNodes", "usageOf"],
+};
+
+const PAIRS: Array<[string, () => Promise<Record<string, unknown>>, () => Promise<Record<string, unknown>>]> = [
+  ["index", () => import("../src/index.js"), () => import("../src/edge/index.js")],
+  ["ai", () => import("../src/integrations/ai.js"), () => import("../src/edge/ai.js")],
+  ["langchain", () => import("../src/integrations/langchain.js"), () => import("../src/edge/langchain.js")],
+  ["mastra", () => import("../src/integrations/mastra.js"), () => import("../src/edge/mastra.js")],
+  ["llamaindex", () => import("../src/integrations/llamaindex.js"), () => import("../src/edge/llamaindex.js")],
+];
+
+describe.each(PAIRS)("the edge %s module", (name, loadReal, loadEdge) => {
+  it("exports every public name the Node build does, as the same kind of value", async () => {
+    const real = await loadReal();
+    const noop = await loadEdge();
+    const missing: string[] = [];
+    for (const key of Object.keys(real)) {
+      if (INTERNAL[name]!.includes(key)) continue;
+      if (!(key in noop)) missing.push(key);
+      else expect(typeof noop[key], `${name}.${key}`).toBe(typeof real[key]);
+    }
+    expect(missing).toEqual([]);
+  });
+
+  it("is what every edge export condition selects", () => {
+    const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8")) as {
+      exports: Record<string, Record<string, unknown>>;
+    };
+    const entry = manifest.exports[name === "index" ? "." : `./${name}`]!;
+    const conditions = Object.keys(entry);
+    // Ahead of import/require: a bundler takes the FIRST condition it matches.
+    expect(conditions.slice(0, 4)).toEqual(["edge-light", "workerd", "worker", "browser"]);
+    for (const condition of conditions.slice(0, 4)) {
+      expect(entry[condition]).toEqual({
+        import: { types: expect.any(String), default: `./dist/esm/edge/${name}.js` },
+        require: { types: expect.any(String), default: `./dist/cjs/edge/${name}.js` },
+      });
+      // The REAL declarations, so code that compiles for Node compiles here.
+      const real = name === "index" ? "index" : `integrations/${name}`;
+      expect((entry[condition] as { import: { types: string } }).import.types).toBe(`./dist/esm/${real}.d.ts`);
+    }
+  });
+});
+
+describe("the edge build's behaviour", () => {
+  it("runs scope bodies and returns their values, recording nothing", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const out = await edge.session({ sessionId: "s-1" }, (sessionId) =>
+      edge.agent("planner", { goal: "g" }, (identity) =>
+        edge.toolCall("search", { toolCallId: "call-1", input: { q: 1 } }, (call) => {
+          call.output = 42;
+          return { sessionId, agent: identity.agentId, call: call.id, assigned: call.outputAssigned };
+        }),
+      ),
+    );
+    expect(out).toEqual({ sessionId: "s-1", agent: "planner", call: "call-1", assigned: true });
+    expect(edge.session(() => "no options")).toBe("no options");
+    expect(await edge.agent("a", async () => 7)).toBe(7);
+
+    const scope = edge.agent.open("planner");
+    expect(scope.agentId).toBe("planner");
+    scope.dispose();
+    edge.session.open().dispose();
+    edge.toolCall.open("t").dispose();
+
+    for (const method of Object.keys(edge.event)) {
+      expect(() => (edge.event as unknown as Record<string, (o: unknown) => void>)[method]!({})).not.toThrow();
+    }
+    expect(Object.keys(edge.event)).toHaveLength(15);
+    await expect(edge.flush()).resolves.toBeUndefined();
+    expect(await edge.instrument()).toEqual([]);
+    expect(await (edge.instrument as (name: string) => Promise<unknown[]>)("langchain")).toEqual([]);
+    expect(edge.uninstrument()).toEqual([]);
+    expect(edge.current().sessionId).toBeNull();
+    expect(edge.AUTO).toBe(Symbol.for("failproofai.AUTO"));
+
+    // Said once, on first use — and it says nothing is recorded.
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn.mock.calls[0]![0]).toBe(`[failproofai-sdk] ${EDGE_NOTICE}`);
+    expect(EDGE_NOTICE).toContain("NOTHING is recorded");
+  });
+
+  it("is silent when merely imported", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    await import("../src/edge/ai.js");
+    expect(warn).not.toHaveBeenCalled();
+  });
+
+  it("hands the frameworks values they accept and that record nothing", async () => {
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+    const ai = await import("../src/edge/ai.js");
+    expect(ai.telemetry({ functionId: "f" })).toEqual({ isEnabled: false, functionId: "f" });
+    const model = { modelId: "m" };
+    expect(await ai.wrapModel(model)).toBe(model);
+    const mw = ai.middleware();
+    expect(await mw.wrapGenerate({ doGenerate: async () => "generated" })).toBe("generated");
+    expect(await mw.wrapStream({ doStream: async () => "streamed" })).toBe("streamed");
+    const tool = { execute: () => 1 };
+    expect(ai.wrapTool("t", tool)).toBe(tool);
+    expect(ai.tracer().startActiveSpan("x", (span: { isRecording(): boolean }) => span.isRecording())).toBe(false);
+
+    const langchain = await import("../src/edge/langchain.js");
+    expect(typeof langchain.langchainHandler()).toBe("object");
+    const mastra = await import("../src/edge/mastra.js");
+    expect(mastra.workflow("w", () => "ran")).toBe("ran");
+    expect(mastra.wrapTool(tool)).toBe(tool);
+    const llamaindex = await import("../src/edge/llamaindex.js");
+    expect(typeof llamaindex.attach()).toBe("function");
+  });
+});

package/.next/standalone/sdk/typescript/test/evaluator-client.test.ts

@@ -0,0 +1,234 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { EvaluatorAPIError, EvaluatorClient } from "../src/evaluator/client.js";
+import { PROTOCOL_VERSION } from "../src/evaluator/protocol.js";
+
+/**
+ * Four properties in here are security or correctness, not style:
+ * redirects are refused, every URL is pinned to the configured origin,
+ * responses are bounded WHILE they are read, and `claim` is never retried.
+ */
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+function makeClient(options: Partial<ConstructorParameters<typeof EvaluatorClient>[0]> = {}) {
+  const fetchImpl = vi.fn(async () =>
+    jsonResponse({
+      protocol_version: PROTOCOL_VERSION,
+      evaluator_instance_id: "i1",
+      evaluator_kind: "customer",
+      heartbeat_interval_seconds: 30,
+      lease_duration_seconds: 120,
+      poll_interval_seconds: 10,
+      claim_limit: 4,
+      disabled_definitions: [],
+    }),
+  );
+  const client = new EvaluatorClient({
+    baseUrl: "https://api.example.test",
+    credential: "token",
+    fetchImpl: fetchImpl,
+    sleep: async () => undefined,
+    ...options,
+  });
+  return { client, fetchImpl };
+}
+
+describe("construction", () => {
+  it("refuses plaintext http to a non-loopback host", () => {
+    expect(() => new EvaluatorClient({ baseUrl: "http://api.example.test", credential: "t" })).toThrow(
+      /must use https unless it targets loopback/,
+    );
+  });
+
+  it("allows http to loopback, where there is no network to eavesdrop", () => {
+    for (const host of ["http://localhost:8020", "http://127.0.0.1:8020", "http://[::1]:8020"]) {
+      expect(() => new EvaluatorClient({ baseUrl: host, credential: "t" })).not.toThrow();
+    }
+  });
+
+  it("refuses a credential that would let a header be injected", () => {
+    expect(() =>
+      new EvaluatorClient({ baseUrl: "https://a.test", credential: "tok\r\nX-Evil: 1" }),
+    ).toThrow(/control characters/);
+    expect(() => new EvaluatorClient({ baseUrl: "https://a.test", credential: "  " })).toThrow(
+      /must not be empty/,
+    );
+  });
+
+  it("refuses a non-absolute base url", () => {
+    expect(() => new EvaluatorClient({ baseUrl: "/v1", credential: "t" })).toThrow(
+      /absolute http\(s\) URL/,
+    );
+  });
+});
+
+describe("requests", () => {
+  it("sends the bearer credential and refuses redirects", async () => {
+    const { client, fetchImpl } = makeClient();
+    await client.register({
+      workerId: "w1",
+      sdkVersion: "0",
+      catalogRevision: "sha256:0",
+      maxConcurrency: 1,
+      definitions: [],
+    });
+    const [, init] = fetchImpl.mock.calls[0] as unknown as [string, RequestInit];
+    expect((init.headers as Record<string, string>).Authorization).toBe("Bearer token");
+    // Following a redirect would carry the Authorization header to wherever it
+    // points, which turns a misconfigured server into credential exfiltration.
+    expect(init.redirect).toBe("error");
+  });
+
+  it("refuses a server-supplied URL outside the configured origin", async () => {
+    const { client } = makeClient();
+    await expect(
+      client.transcript(
+        {
+          assignmentId: "a1",
+          leaseGeneration: 1,
+          leaseExpiresAt: "",
+          sessionId: "s",
+          sessionRevisionId: "r",
+          agentId: "main",
+          environment: "dev",
+          triggerReason: "x",
+          eventCount: 0,
+          transcriptUrl: "https://attacker.test/transcript",
+          definitionsUrl: "",
+        },
+        "w1",
+      ),
+    ).rejects.toThrow(/outside the configured API origin/);
+  });
+
+  it("retries a retryable status and stops at the cap", async () => {
+    const fetchImpl = vi.fn(async () => jsonResponse({}, 503));
+    const client = new EvaluatorClient({
+      baseUrl: "https://api.example.test",
+      credential: "t",
+      maxRetries: 2,
+      fetchImpl: fetchImpl,
+      sleep: async () => undefined,
+    });
+    await expect(
+      client.register({
+        workerId: "w1",
+        sdkVersion: "0",
+        catalogRevision: "sha256:0",
+        maxConcurrency: 1,
+        definitions: [],
+      }),
+    ).rejects.toThrow(EvaluatorAPIError);
+    expect(fetchImpl).toHaveBeenCalledTimes(3);
+  });
+
+  it("does not retry a non-retryable status", async () => {
+    const fetchImpl = vi.fn(async () =>
+      jsonResponse(
+        {
+          protocol_version: PROTOCOL_VERSION,
+          error: { code: "invalid_credentials", message: "nope", retryable: false, request_id: "r" },
+        },
+        401,
+      ),
+    );
+    const client = new EvaluatorClient({
+      baseUrl: "https://api.example.test",
+      credential: "t",
+      fetchImpl: fetchImpl,
+      sleep: async () => undefined,
+    });
+    await expect(
+      client.register({
+        workerId: "w1",
+        sdkVersion: "0",
+        catalogRevision: "sha256:0",
+        maxConcurrency: 1,
+        definitions: [],
+      }),
+    ).rejects.toMatchObject({ code: "invalid_credentials", retryable: false });
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
+  it("NEVER retries a claim, because a lost response may already have leased work", async () => {
+    const fetchImpl = vi.fn(async () => jsonResponse({}, 503));
+    const client = new EvaluatorClient({
+      baseUrl: "https://api.example.test",
+      credential: "t",
+      maxRetries: 5,
+      fetchImpl: fetchImpl,
+      sleep: async () => undefined,
+    });
+    await expect(
+      client.claim({ workerId: "w1", catalogRevision: "sha256:0", capacity: 1 }),
+    ).rejects.toThrow();
+    expect(fetchImpl).toHaveBeenCalledTimes(1);
+  });
+
+  it("reports a non-JSON body as an invalid response rather than crashing", async () => {
+    const fetchImpl = vi.fn(async () => new Response("<html>gateway</html>", { status: 200 }));
+    const client = new EvaluatorClient({
+      baseUrl: "https://api.example.test",
+      credential: "t",
+      fetchImpl: fetchImpl,
+      sleep: async () => undefined,
+    });
+    await expect(
+      client.register({
+        workerId: "w1",
+        sdkVersion: "0",
+        catalogRevision: "sha256:0",
+        maxConcurrency: 1,
+        definitions: [],
+      }),
+    ).rejects.toMatchObject({ code: "invalid_response" });
+  });
+
+  it("stops reading a body past the limit instead of buffering it whole", async () => {
+    const huge = "x".repeat(4 * 1024 * 1024);
+    const fetchImpl = vi.fn(async () => jsonResponse({ padding: huge }));
+    const client = new EvaluatorClient({
+      baseUrl: "https://api.example.test",
+      credential: "t",
+      fetchImpl: fetchImpl,
+      sleep: async () => undefined,
+    });
+    await expect(
+      client.register({
+        workerId: "w1",
+        sdkVersion: "0",
+        catalogRevision: "sha256:0",
+        maxConcurrency: 1,
+        definitions: [],
+      }),
+    ).rejects.toMatchObject({ code: "response_too_large" });
+  });
+
+  it("classifies a transport failure as retryable", async () => {
+    const fetchImpl = vi.fn(async () => {
+      throw new Error("ECONNREFUSED");
+    });
+    const client = new EvaluatorClient({
+      baseUrl: "https://api.example.test",
+      credential: "t",
+      maxRetries: 0,
+      fetchImpl: fetchImpl,
+      sleep: async () => undefined,
+    });
+    await expect(
+      client.register({
+        workerId: "w1",
+        sdkVersion: "0",
+        catalogRevision: "sha256:0",
+        maxConcurrency: 1,
+        definitions: [],
+      }),
+    ).rejects.toMatchObject({ code: "transport_error", retryable: true });
+  });
+});