@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/src/tests/runner-legacy-resume-prompt.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { CHILD_PROCESS_TEST_BUDGET_MS, expectChildOk, runChild } from "./test-proc";
+
+// Must match src/tests/fixtures/runner-legacy-resume-prompt.ts.
+const REQUESTER_SENTINEL = "RESUME_REQUESTER_SENTINEL_7f3a";
+const MISSING_DIR = "/nonexistent/legacy-resume-dir-7f3a";
+
+describe("runner legacy paused-task resume prompt", () => {
+  test(
+    "resumed session gets the requester profile and missing-dir warning in its task prompt",
+    async () => {
+      const directory = mkdtempSync(join(tmpdir(), "runner-legacy-resume-"));
+      try {
+        expectChildOk(
+          await runChild(
+            [
+              process.execPath,
+              join(import.meta.dir, "fixtures/runner-legacy-resume-prompt.ts"),
+              directory,
+            ],
+            {
+              cwd: directory,
+              env: {
+                PATH: process.env.PATH,
+                HOME: directory,
+                AGENT_ID: "11111111-1111-4111-8111-111111111111",
+                API_KEY: "example-fixture-key",
+                MCP_BASE_URL: "http://runner.invalid",
+                HARNESS_PROVIDER: "pi",
+                CRED_CHECK_DISABLE: "1",
+                DATABASE_PATH: ":memory:",
+                ANONYMIZED_TELEMETRY: "false",
+                STEERING_ENABLED: "false",
+              },
+            },
+          ),
+          "Runner legacy resume fixture",
+        );
+        const result = JSON.parse(readFileSync(join(directory, "result.json"), "utf8")) as {
+          taskId: string;
+          prompt: string;
+          systemPrompt: string;
+        };
+
+        expect(result.taskId).toBe("44444444-4444-4444-8444-444444444444");
+        expect(result.prompt).toContain(REQUESTER_SENTINEL);
+        expect(result.prompt).toContain("Fixture Requester");
+        // The same text the fresh task path sends (missingTaskDirWarning).
+        expect(result.prompt).toContain(
+          `Note: The task requested working directory "${MISSING_DIR}" but it does not exist. Falling back to default directory.`,
+        );
+        // Per-task context stays out of the cacheable system prompt.
+        expect(result.systemPrompt).not.toContain(REQUESTER_SENTINEL);
+        expect(result.systemPrompt).not.toContain(MISSING_DIR);
+      } finally {
+        rmSync(directory, { recursive: true, force: true });
+      }
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+});

package/src/tests/script-connections.test.ts

@@ -626,6 +626,12 @@ describe("script connections", () => {
       markMigrationApplied(database, "207_runtime_session_tokens.sql");
       // 213 rebuilds script_connections with the post-117 columns this fixture skips.
       markMigrationApplied(database, "213_script_connections_sql.sql");
+      // 215 alters swarm_config, which this migration-112-only fixture does not create.
+      markMigrationApplied(database, "215_swarm_config_export_to_env.sql");
+      // 219 rewrites task_context_snapshots, which this fixture does not create.
+      markMigrationApplied(database, "219_relabel_pi_context_compactions.sql");
+      // 220 reads agents and swarm_config, which this migration-112-only fixture does not create.
+      markMigrationApplied(database, "220_model_profiles.sql");
 
       const id = crypto.randomUUID();
       const now = new Date().toISOString();

package/src/tests/script-executor-conformance.test.ts

@@ -1,4 +1,7 @@
-import { describe, expect, test } from "bun:test";
+import { afterAll, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { classifyExit, NativeScriptExecutor } from "../scripts-runtime/executors/native";
 import { QuickJSScriptExecutor } from "../scripts-runtime/executors/quickjs";
 import type {
@@ -8,6 +11,7 @@ import type {
 } from "../scripts-runtime/executors/types";
 import { DEFAULT_SCRIPT_RESOURCES } from "../scripts-runtime/executors/types";
 import { SKIP_SANDBOX_SPAWN_TESTS } from "./sandbox-spawn-test-helpers";
+import { CHILD_PROCESS_TEST_BUDGET_MS } from "./test-proc";
 
 const payload = {
   system: {
@@ -132,6 +136,253 @@ conformance("fake", () => new FakeScriptExecutor(), false);
 // Worker threads and WASM, no Bun.spawn: runs even when the spawn probe fails.
 conformance("quickjs", () => new QuickJSScriptExecutor(), false);
 
+// Each probe is plain JavaScript, so the test process (Bun) can evaluate it too:
+// both executors must return exactly what Bun's own web globals return.
+const echoServer = Bun.serve({
+  port: 0,
+  async fetch(req) {
+    const bytes = new Uint8Array(await req.arrayBuffer());
+    return Response.json({
+      contentType: req.headers.get("content-type"),
+      bytes: Array.from(bytes),
+    });
+  },
+});
+afterAll(() => echoServer.stop(true));
+
+const PARITY_PROBES: Record<string, string> = {
+  URL: `async () => {
+  const cases = [
+    ["https://user:pa ss@Example.COM:443/a/./b/../c d?q=1 2&x='y'#frag ment"],
+    ["http://example.com:8080"], ["../x?y#z", "https://a.b/c/d/e"], ["//other.host/p", "https://a.b/c"],
+    ["?new", "https://a.b/c/d?q#h"], ["#h2", "https://a.b/c/d?q#h"], ["mailto:someone@example.com"],
+    ["foo://EXAMPLE.com/a/../b"], ["http://0x7f.1/"], ["http://[0:0:0:0:0:0:0:1]:80/"],
+    ["https://münchen.de/straße"], ["http://a.b/c\\\\d"], ["file:///etc/hosts"], ["http:foo", "http://a.b/c/d"],
+    ["not a url"], ["https://a.b:99999/"], ["http://exa mple.com"], ["http://256.1.1.1/"],
+  ];
+  const keys = ["href", "origin", "protocol", "username", "password", "host", "hostname", "port", "pathname", "search", "hash"];
+  const parsed = cases.map(([url, base]) => {
+    try {
+      const u = new URL(url, base);
+      return Object.fromEntries(keys.map((key) => [key, u[key]]).concat([["params", [...u.searchParams]]]));
+    } catch (error) {
+      return { error: error.name };
+    }
+  });
+  const u = new URL("https://a.b/p?x=1#h");
+  u.searchParams.append("y", "two words");
+  const linked = u.href;
+  u.search = "?z=3";
+  u.pathname = "/new path";
+  u.port = "8443";
+  u.hostname = "C.D";
+  u.hash = "";
+  return { parsed, linked, mutated: u.href, json: JSON.stringify({ u }), canParse: [URL.canParse("x"), URL.canParse("x", "https://a/")] };
+}`,
+  "URL relative state": `async () => {
+  const base = "http://a/b?q#f";
+  const cases = [
+    "http:/x", "http:/", "http:", "http:?y", "http:#g", "http:x/../y", "http:\\\\x", "http://x", "http:///x",
+    "http:/\\\\x", "https:/x", "ws:/x", "foo:/x", "file:/x",
+  ];
+  return cases.map((url) => {
+    try { return new URL(url, base).href; } catch (error) { return error.name; }
+  });
+}`,
+  "URL setters": `async () => {
+  const run = (start, key, values) => values.map((value) => {
+    const u = new URL(start);
+    u[key] = value;
+    return u.href;
+  });
+  return {
+    hostname: run("http://a.b:81/p", "hostname", [
+      "[::1]", "[::1]:90", "example.net:90", "c.d/e", "c.d?x", "user@c.d", "", "exa mple", "C.D", "[::1", "0x7f.1",
+    ]),
+    host: run("http://a.b:81/p", "host", [
+      "[::1]", "[::1]:90", "c.d:90", "c.d:", "c.d:80", "c.d:99999", "c.d:9x", "user@c.d", "user:pw@c.d:9", "", "c.d/e:1", ":90",
+      "user:pw@c.d", "c.d:1:2", "c.d:9/x:1", "c.d:080", "c.d:65536", "c.d:x", "[::1]:80",
+    ]),
+    hostNoPort: run("http://a.b/p", "host", ["c.d:80", "c.d:99999"]),
+    nonSpecialHost: run("foo://a:5/p", "host", ["", "b:1", "[::1]", "b@c", "b:", "b:99999"]),
+    nonSpecialEmptyHost: run("foo://a/p", "host", [""]),
+    nonSpecialHostname: run("foo://u@a:5/p", "hostname", ["", "b"]),
+    protocol: run("http://a.b/p", "protocol", [
+      "https", "https:", "https:foo", "https://x", "ht tps", "https!", "1http", "foo", "ws:", "HTTPS", "\\thttps",
+    ]),
+    fileProtocol: run("file:///p", "protocol", ["http"]),
+    opaqueHost: run("mailto:x@y", "host", ["z"]),
+  };
+}`,
+  URLSearchParams: `async () => {
+  const p = new URLSearchParams("?b=2&a=1&a=3&sp=a+b%20c&uni=%C3%A9&bad=%E0%A4%A");
+  p.append("x y", "ä&=+");
+  p.sort();
+  const sorted = p.toString();
+  const all = p.getAll("a");
+  p.set("a", "9");
+  p.delete("b");
+  return {
+    sorted, all, size: p.size, after: p.toString(), entries: [...p],
+    has: [p.has("a"), p.has("a", "1"), p.has("zz")],
+    fromObject: new URLSearchParams({ q: "hello world", n: 5 }).toString(),
+    fromPairs: new URLSearchParams([["k", "v"], ["k", "w"]]).toString(),
+  };
+}`,
+  "URLSearchParams live traversal": `async () => {
+  const appended = new URLSearchParams("a=1&b=2");
+  const keys = appended.keys();
+  appended.append("c", "3");
+  const keysAfterAppend = [...keys];
+
+  const deleted = new URLSearchParams("a=1&b=2&c=3");
+  const visited = [];
+  deleted.forEach((value, key) => {
+    visited.push(key + value);
+    if (key === "a") deleted.delete("c");
+  });
+
+  const grown = new URLSearchParams("x=1");
+  const grownVisits = [];
+  grown.forEach((value, key) => {
+    grownVisits.push(key);
+    if (grownVisits.length < 3) grown.append("y" + grownVisits.length, value);
+  });
+
+  const shifted = new URLSearchParams("a=1&b=2&c=3");
+  const entries = shifted.entries();
+  const first = entries.next().value;
+  shifted.delete("a");
+  const rest = [...entries];
+
+  const reset = new URLSearchParams("a=1&b=2");
+  const values = reset.values();
+  values.next();
+  reset.set("a", "9");
+  reset.sort();
+  const drained = values.next();
+  reset.append("z", "0");
+  const afterDone = values.next();
+
+  const linked = new URL("https://h/?a=1&b=2");
+  const linkedKeys = linked.searchParams.keys();
+  linked.search = "?c=3&d=4&e=5";
+  const linkedRest = [...linkedKeys];
+
+  return { keysAfterAppend, visited, grownVisits, first, rest, drained, afterDone, linkedRest };
+}`,
+  base64: `async () => {
+  const attempt = (run) => { try { return run(); } catch (error) { return error.name; } };
+  return {
+    encode: ["", "f", "fo", "foo", "foob", "fooba", "foobar", "\\u00ff\\u0000\\u0080", 123, null, undefined].map((value) => btoa(value)),
+    decode: ["", "Zg", "Zg==", "Zm8=", "Zm9v", " Zm 9v\\n", "Zm9vYg", "/+8=", "AP+A"].map((value) => atob(value)),
+    decodeBad: ["Z", "Zg=", "Zg===", "Z=g=", "Zm9v!", "Zm9v=", "===="].map((value) => attempt(() => atob(value))),
+    encodeBad: attempt(() => btoa("é👋")),
+    roundTrip: atob(btoa(String.fromCharCode(...Array.from({ length: 256 }, (_, i) => i)))).length,
+  };
+}`,
+  TextEncoder: `async () => {
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode("héllo 👋 \\uD800x");
+  const decoder = new TextDecoder();
+  const wave = encoder.encode("👋é");
+  const streamed = [decoder.decode(wave.subarray(0, 2), { stream: true }), decoder.decode(wave.subarray(2, 5), { stream: true }), decoder.decode(wave.subarray(5))];
+  let fatal = "accepted";
+  try { new TextDecoder("utf-8", { fatal: true }).decode(new Uint8Array([0xc3])); } catch (error) { fatal = error.name; }
+  const target = new Uint8Array(5);
+  return {
+    bytes: Array.from(bytes),
+    roundTrip: decoder.decode(bytes),
+    replaced: decoder.decode(new Uint8Array([0x61, 0xff, 0xe2, 0x82, 0x62, 0xf0, 0x9f, 0x91])),
+    streamed, fatal,
+    bom: decoder.decode(new Uint8Array([0xef, 0xbb, 0xbf, 0x41])),
+    fromBuffer: decoder.decode(new Uint8Array([104, 105]).buffer),
+    encodeInto: [encoder.encodeInto("aé👋", target), Array.from(target)],
+  };
+}`,
+  setInterval: `async () => {
+  let ticks = 0;
+  await new Promise((resolve) => {
+    const id = setInterval((step) => {
+      ticks += step;
+      if (ticks === 3) { clearInterval(id); resolve(); }
+    }, 5, 1);
+  });
+  let crossCleared = 0;
+  const other = setInterval(() => { crossCleared++; }, 5);
+  clearTimeout(other);
+  await new Promise((resolve) => setTimeout(resolve, 40));
+  return { ticks, crossCleared };
+}`,
+  crypto: `async () => {
+  const uuids = [crypto.randomUUID(), crypto.randomUUID()];
+  const words = new Uint32Array(8);
+  const same = crypto.getRandomValues(words) === words;
+  let quota = "accepted";
+  try { crypto.getRandomValues(new Uint8Array(65537)); } catch (error) { quota = error.name; }
+  return {
+    v4: uuids.every((id) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(id)),
+    distinct: uuids[0] !== uuids[1],
+    same,
+    filled: words.some((word) => word !== 0),
+    quota,
+  };
+}`,
+  "fetch bodies": `async ({ base }) => {
+  const send = async (body, headers) => (await fetch(base, { method: "POST", body, headers })).json();
+  return {
+    uint8: await send(new Uint8Array([0, 1, 254, 255])),
+    view: await send(new Uint16Array([1, 2]).subarray(1)),
+    buffer: await send(new Uint8Array([7, 8, 9]).buffer, { "content-type": "application/octet-stream" }),
+    form: await send(new URLSearchParams({ a: "1 2", b: "é" })),
+    formTyped: await send(new URLSearchParams("x=1"), { "Content-Type": "text/plain" }),
+  };
+}`,
+};
+
+// Imports the probe as a module, so Bun's own globals compute the expectation.
+async function runInBun(probe: string, args: unknown): Promise<unknown> {
+  const dir = await mkdtemp(join(tmpdir(), "parity-probe-"));
+  try {
+    const file = join(dir, "probe.js");
+    await Bun.write(file, `export default ${probe};`);
+    const mod = (await import(file)) as { default: (args: unknown) => Promise<unknown> };
+    return await mod.default(args);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+describe("quickjs parity shims match native and Bun", () => {
+  const args = { base: `http://127.0.0.1:${echoServer.port}/echo` };
+  const executors: Array<[string, () => ScriptExecutor, boolean]> = [
+    ["native", () => new NativeScriptExecutor(), true],
+    ["quickjs", () => new QuickJSScriptExecutor(), false],
+  ];
+  for (const [name, probe] of Object.entries(PARITY_PROBES)) {
+    for (const [executorName, makeExecutor, spawns] of executors) {
+      // The native case spawns a bun subprocess with a 10s script budget, so
+      // the test timeout must outlast it (runbooks/testing.md hard rule 5).
+      test.skipIf(spawns && SKIP_SANDBOX_SPAWN_TESTS)(
+        `${name} (${executorName})`,
+        async () => {
+          const expected = await runInBun(probe, args);
+          const output = await makeExecutor().run(
+            input({
+              source: `export default ${probe};`,
+              args,
+              resources: { ...DEFAULT_SCRIPT_RESOURCES, memoryMb: 2048, wallClockMs: 10_000 },
+            }),
+          );
+          expect(output.error).toBeUndefined();
+          expect(output.result).toEqual(expected);
+        },
+        CHILD_PROCESS_TEST_BUDGET_MS,
+      );
+    }
+  }
+});
+
 describe("native-only executor behavior", () => {
   test.skipIf(SKIP_SANDBOX_SPAWN_TESTS)("timeout maps to timeout", async () => {
     const output = await new NativeScriptExecutor().run(

package/src/tests/script-executor-quickjs.test.ts

@@ -69,6 +69,9 @@ const server = Bun.serve({
 afterAll(() => server.stop(true));
 
 const baseUrl = `http://127.0.0.1:${server.port}`;
+// The documented binary body caps (scripts-runtime guide).
+const MAX_BINARY_BODY_BYTES = 16 * 1024 * 1024;
+const MAX_PENDING_BINARY_BODY_BYTES = 64 * 1024 * 1024;
 const executor = new QuickJSScriptExecutor();
 
 function input(source: string, overrides: Partial<ExecutorInput> = {}): ExecutorInput {
@@ -294,6 +297,35 @@ export default async (args: T) => explode(args);
     expect(output.runtimeError?.message).toContain("fetch body must be a string");
   });
 
+  // Parity with native lives in script-executor-conformance.test.ts. These
+  // are the documented limits of the shims.
+  test("shims refuse what they do not implement, with a clear error", async () => {
+    const output = await executor.run(
+      input(`export default async () => {
+  const attempt = (run) => { try { run(); return "ok"; } catch (e) { return e.name + ": " + e.message; } };
+  return {
+    latin1: attempt(() => new TextDecoder("latin1")),
+    floatRandom: attempt(() => crypto.getRandomValues(new Float64Array(2))),
+    subtle: typeof crypto.subtle,
+  };
+};`),
+    );
+    expect(output.result).toEqual({
+      latin1: 'RangeError: quickjs executor: TextDecoder supports utf-8 only, not "latin1"',
+      floatRandom: "TypeError: crypto.getRandomValues: the argument must be an integer TypedArray",
+      subtle: "undefined",
+    });
+  });
+
+  test("binary bodies reach the host through ctx.stdlib.fetch too", async () => {
+    const output = await executor.run(
+      input(
+        `export default async (_args, ctx) => (await ctx.stdlib.fetch("${baseUrl}/echo", { method: "POST", body: new TextEncoder().encode("é!") })).json();`,
+      ),
+    );
+    expect(output.result).toMatchObject({ method: "POST", body: "é!" });
+  });
+
   test("user config values stay redacted until unwrapped", async () => {
     const output = await executor.run(
       input(`export default async (_args, ctx) => {
@@ -436,6 +468,70 @@ export default async (args: T) => explode(args);
     expect(output.result).toContain("Too many pending host calls");
   });
 
+  // The sandbox controls bodyBase64, so these call the bridge directly, past
+  // the prelude's own encoding, and check that no request reaches the server.
+  const bridgeSend = `const send = async (bodyBase64: unknown) =>
+    JSON.parse(await (globalThis as any).__host_call("fetch", JSON.stringify([{ url: "${baseUrl}/sink", method: "POST", bodyBase64 }]))).error?.message ?? "sent";`;
+
+  test("rejects a malformed binary body before any fetch starts", async () => {
+    const before = requests.length;
+    const output = await executor.run(
+      input(`export default async () => {
+  ${bridgeSend}
+  return [await send(123), await send({ length: 4 }), await send("!!!!"), await send("AAA"), await send("AA=A")];
+};`),
+    );
+    expect(output.result).toEqual([
+      "fetch bodyBase64 must be a string",
+      "fetch bodyBase64 must be a string",
+      "fetch bodyBase64 is not valid base64",
+      "fetch bodyBase64 is not valid base64",
+      "fetch bodyBase64 is not valid base64",
+    ]);
+    expect(requests.length).toBe(before);
+  });
+
+  test("rejects an oversized binary body before any fetch starts", async () => {
+    const before = requests.length;
+    const encodedLimit = Math.ceil(MAX_BINARY_BODY_BYTES / 3) * 4;
+    const output = await executor.run(
+      input(`export default async () => {
+  ${bridgeSend}
+  return {
+    encoded: await send("A".repeat(${encodedLimit + 4})),
+    decoded: await send("A".repeat(${encodedLimit})),
+    atLimit: await send("A".repeat(${encodedLimit - 4}) + "AA=="),
+  };
+};`),
+    );
+    const tooLarge = `fetch binary body exceeds the ${MAX_BINARY_BODY_BYTES}-byte limit of the quickjs executor`;
+    expect(output.result).toEqual({ encoded: tooLarge, decoded: tooLarge, atLimit: "sent" });
+    // Only the body at the limit reached the server.
+    expect(requests.length).toBe(before + 1);
+  });
+
+  test("caps the binary bodies one run can have pending", async () => {
+    const before = { ...hang };
+    const encodedLimit = Math.ceil(MAX_BINARY_BODY_BYTES / 3) * 4;
+    const output = await executor.run(
+      input(
+        `export default async () => {
+  // Decodes to exactly MAX_BINARY_BODY_BYTES; four fill the per-run budget.
+  const args = JSON.stringify([{ url: "${baseUrl}/hang", method: "POST", bodyBase64: "A".repeat(${encodedLimit - 4}) + "AA==" }]);
+  const call = async () => JSON.parse(await (globalThis as any).__host_call("fetch", args)).error?.message ?? "sent";
+  const held = [call(), call(), call(), call()];
+  return call();
+};`,
+        { resources: { ...DEFAULT_SCRIPT_RESOURCES, memoryMb: 1024, wallClockMs: 10_000 } },
+      ),
+    );
+    expect(output.result).toBe(
+      `Pending fetch binary bodies in one script run exceed ${MAX_PENDING_BINARY_BODY_BYTES} bytes`,
+    );
+    expect(await waitFor(() => hang.started === before.started + 4)).toBe(true);
+    expect(await waitFor(() => hang.aborted === before.aborted + 4)).toBe(true);
+  }, 30_000);
+
   test("queues runs beyond the pool size", async () => {
     const outputs = await Promise.all(
       Array.from({ length: 12 }, (_, i) =>

package/src/tests/script-runs-http.test.ts

@@ -24,6 +24,7 @@ import {
   clearVolatileSecretsForTesting,
   refreshSecretScrubberCache,
 } from "../utils/secret-scrubber";
+import { executeRawLlm } from "../workflows/executors/raw-llm";
 import { randomToken } from "./synthetic-secret-helpers";
 
 const TEST_DB_PATH = "./test-script-runs-http.sqlite";
@@ -661,3 +662,91 @@ describe("durable launch source with an embedded secret", () => {
     }
   });
 });
+
+describe("POST /api/internal/raw-llm failure", () => {
+  const KEY_VARS = ["NAN_API_KEY", "HELMCODE_API_NAN"] as const;
+
+  // The provider echoes the key it received; `selectCredential` sends it
+  // trimmed, so a padded config value must still be redacted.
+  async function withNanKey(
+    keyVar: (typeof KEY_VARS)[number],
+    pad: string,
+    fn: (dummy: string, calls: () => number) => Promise<void>,
+    dummy = `nan-${randomToken(32)}`,
+  ) {
+    const previous = Object.fromEntries(KEY_VARS.map((name) => [name, process.env[name]]));
+    const previousFetch = globalThis.fetch;
+    for (const name of KEY_VARS) delete process.env[name];
+    process.env[keyVar] = `${pad}${dummy}${pad}`;
+    refreshSecretScrubberCache();
+    let calls = 0;
+    globalThis.fetch = (async () => {
+      calls++;
+      return new Response(
+        JSON.stringify({ error: { message: `Invalid API key: ${dummy}`, type: "auth" } }),
+        { status: 401, headers: { "Content-Type": "application/json" } },
+      );
+    }) as unknown as typeof fetch;
+    try {
+      await fn(dummy, () => calls);
+    } finally {
+      globalThis.fetch = previousFetch;
+      for (const name of KEY_VARS) {
+        if (previous[name] === undefined) delete process.env[name];
+        else process.env[name] = previous[name];
+      }
+      refreshSecretScrubberCache();
+    }
+  }
+
+  for (const keyVar of KEY_VARS) {
+    for (const pad of ["", "  "]) {
+      const label = pad ? "padded" : "unpadded";
+      test(`does not echo a provider error that carries the ${label} ${keyVar} key`, async () => {
+        await withNanKey(keyVar, pad, async (dummy, calls) => {
+          const response = await dispatch("/api/internal/raw-llm", {
+            method: "POST",
+            agentId,
+            body: JSON.stringify({ prompt: "hi", model: "nan/qwen3.8-flash" }),
+          });
+          expect(calls()).toBe(1);
+          expect(response.status).toBe(500);
+          expect(response.text).not.toContain(dummy);
+          const body = (await response.json()) as { error: string };
+          expect(body.error).toContain("LLM call failed");
+          expect(body.error).toContain(`[REDACTED:${keyVar}]`);
+        });
+      });
+    }
+
+    // A random key can contain "529"; that must not read as an overload.
+    test(`a ${keyVar} key containing 529 is not mistaken for a rate limit`, async () => {
+      await withNanKey(
+        keyVar,
+        "",
+        async (dummy, calls) => {
+          const result = await executeRawLlm({ prompt: "hi", model: "nan/qwen3.8-flash" });
+          expect(calls()).toBe(1);
+          expect(result.status).toBe("failed");
+          if (result.status === "failed") expect(result.error).not.toContain(dummy);
+        },
+        `nan-5L76Mxo2D529A9S0GrqOZWIpYdfO1aIM`,
+      );
+    });
+
+    test(`scrubs the fallback-port error for a padded ${keyVar} key`, async () => {
+      await withNanKey(keyVar, "  ", async (dummy, calls) => {
+        const result = await executeRawLlm({
+          prompt: "hi",
+          model: "nan/qwen3.8-flash",
+          fallbackPort: "fallback",
+        });
+        expect(calls()).toBe(1);
+        expect(result.status).toBe("success");
+        expect(result.error).toContain("using fallback port");
+        expect(result.error).not.toContain(dummy);
+        expect(result.error).toContain(`[REDACTED:${keyVar}]`);
+      });
+    });
+  }
+});