@desplega.ai/agent-swarm 2.5.3 → 2.6.0

package/src/tests/context-bound-note.test.ts

@@ -0,0 +1,269 @@
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
+import * as fsPromises from "node:fs/promises";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  claimContextBoundNote,
+  contextBoundNoteThreshold,
+  contextStatePath,
+  createContextBoundNote,
+  recordContextState,
+} from "../hooks/context-bound-note";
+import { renderContextBoundNote } from "../prompts/context-bound-note";
+import { normalizeClaudeMessage } from "../providers/claude-session-events";
+
+let dir: string;
+let n = 0;
+
+beforeAll(async () => {
+  dir = await mkdtemp(join(tmpdir(), "context-bound-note-"));
+});
+
+afterAll(async () => {
+  await rm(dir, { recursive: true, force: true });
+});
+
+/** A fresh task file path with `contextTokens` recorded next to it. */
+function taskFileWith(contextTokens?: number): string {
+  const taskFile = join(dir, `task-${++n}.json`);
+  if (contextTokens !== undefined) recordContextState(taskFile, contextTokens);
+  return taskFile;
+}
+
+describe("contextBoundNoteThreshold", () => {
+  test("off when unset, blank, invalid or 0", () => {
+    expect(contextBoundNoteThreshold({})).toBe(0);
+    expect(contextBoundNoteThreshold({ CONTEXT_BOUND_NOTE_TOKENS: "" })).toBe(0);
+    expect(contextBoundNoteThreshold({ CONTEXT_BOUND_NOTE_TOKENS: " " })).toBe(0);
+    expect(contextBoundNoteThreshold({ CONTEXT_BOUND_NOTE_TOKENS: "-5" })).toBe(0);
+    expect(contextBoundNoteThreshold({ CONTEXT_BOUND_NOTE_TOKENS: "lots" })).toBe(0);
+    expect(contextBoundNoteThreshold({ CONTEXT_BOUND_NOTE_TOKENS: "1e5" })).toBe(0);
+    expect(contextBoundNoteThreshold({ CONTEXT_BOUND_NOTE_TOKENS: "99999999999999999999" })).toBe(
+      0,
+    );
+    expect(contextBoundNoteThreshold({ CONTEXT_BOUND_NOTE_TOKENS: "0" })).toBe(0);
+  });
+
+  test("a positive integer turns the note on at that threshold", () => {
+    expect(contextBoundNoteThreshold({ CONTEXT_BOUND_NOTE_TOKENS: "150000" })).toBe(150_000);
+    expect(contextBoundNoteThreshold({ CONTEXT_BOUND_NOTE_TOKENS: " 200000 " })).toBe(200_000);
+  });
+});
+
+describe("claimContextBoundNote", () => {
+  test("fires once at the threshold, not again on later calls", async () => {
+    const taskFile = taskFileWith(200_000);
+    expect(await claimContextBoundNote(taskFile, 200_000)).toEqual({ contextTokens: 200_000 });
+    expect(await claimContextBoundNote(taskFile, 200_000)).toBeNull();
+    recordContextState(taskFile, 400_000);
+    expect(await claimContextBoundNote(taskFile, 200_000)).toBeNull();
+  });
+
+  test("concurrent hooks fire the note once", async () => {
+    const taskFile = taskFileWith(300_000);
+    const results = await Promise.all(
+      Array.from({ length: 8 }, () => claimContextBoundNote(taskFile, 200_000)),
+    );
+    expect(results.filter((r) => r !== null)).toEqual([{ contextTokens: 300_000 }]);
+  });
+
+  test("no-op below the threshold, then fires once it is crossed", async () => {
+    const taskFile = taskFileWith(199_999);
+    expect(await claimContextBoundNote(taskFile, 200_000)).toBeNull();
+    recordContextState(taskFile, 210_000);
+    expect(await claimContextBoundNote(taskFile, 200_000)).toEqual({ contextTokens: 210_000 });
+  });
+
+  test("returns the model the session recorded", async () => {
+    const taskFile = join(dir, `task-${++n}.json`);
+    recordContextState(taskFile, 250_000, "claude-opus-5-5");
+    expect(await claimContextBoundNote(taskFile, 200_000)).toEqual({
+      contextTokens: 250_000,
+      model: "claude-opus-5-5",
+    });
+  });
+
+  test("disabled at 0", async () => {
+    expect(await claimContextBoundNote(taskFileWith(900_000), 0)).toBeNull();
+  });
+
+  test("fails open on missing task file, missing state or corrupt state", async () => {
+    expect(await claimContextBoundNote(undefined, 200_000)).toBeNull();
+    expect(await claimContextBoundNote(taskFileWith(), 200_000)).toBeNull();
+
+    const corrupt = taskFileWith();
+    await Bun.write(contextStatePath(corrupt), "{not json");
+    expect(await claimContextBoundNote(corrupt, 200_000)).toBeNull();
+
+    const wrongShape = taskFileWith();
+    await Bun.write(contextStatePath(wrongShape), JSON.stringify({ contextTokens: "300000" }));
+    expect(await claimContextBoundNote(wrongShape, 200_000)).toBeNull();
+  });
+
+  test("fails open when the marker cannot be written", async () => {
+    const taskFile = taskFileWith(300_000);
+    const writeFile = spyOn(fsPromises, "writeFile").mockRejectedValue(
+      Object.assign(new Error("EIO: i/o error"), { code: "EIO" }),
+    );
+    try {
+      expect(await claimContextBoundNote(taskFile, 200_000)).toBeNull();
+      expect(writeFile).toHaveBeenCalledTimes(1);
+    } finally {
+      writeFile.mockRestore();
+    }
+  });
+});
+
+describe("createContextBoundNote", () => {
+  function observer(
+    threshold: number,
+    inject: (note: string) => unknown = () => {},
+    canDeliver: () => boolean = () => true,
+    model?: () => string | undefined,
+  ) {
+    const notes: string[] = [];
+    const observe = createContextBoundNote({
+      threshold,
+      canDeliver,
+      model,
+      inject: (note) => {
+        notes.push(note);
+        return inject(note);
+      },
+    });
+    return { observe, notes };
+  }
+
+  test("fires once at the threshold, not again on later requests", async () => {
+    const { observe, notes } = observer(200_000);
+    await observe(200_000);
+    await observe(400_000);
+    expect(notes).toEqual([await renderContextBoundNote(200_000)]);
+  });
+
+  test("no-op below the threshold, then fires once it is crossed", async () => {
+    const { observe, notes } = observer(200_000);
+    await observe(199_999);
+    expect(notes).toEqual([]);
+    await observe(210_000);
+    expect(notes).toEqual([await renderContextBoundNote(210_000)]);
+  });
+
+  test("disabled at 0", async () => {
+    const { observe, notes } = observer(0);
+    await observe(900_000);
+    expect(notes).toEqual([]);
+  });
+
+  test("fails open on missing or corrupt sizes", async () => {
+    const { observe, notes } = observer(200_000);
+    await observe(undefined);
+    await observe(Number.NaN);
+    await observe(Number.POSITIVE_INFINITY);
+    await observe("300000" as unknown as number);
+    expect(notes).toEqual([]);
+  });
+
+  test("never rejects when injection fails, and does not retry", async () => {
+    const { observe, notes } = observer(200_000, () => Promise.reject(new Error("closed")));
+    await expect(observe(300_000)).resolves.toBeUndefined();
+    await observe(300_000);
+    expect(notes).toHaveLength(1);
+  });
+
+  test("holds a note rendered after its window closed, then delivers it on the next call", async () => {
+    let open = false;
+    const { observe, notes } = observer(200_000, undefined, () => open);
+    await observe(300_000);
+    expect(notes).toEqual([]);
+    open = true;
+    await observe(500_000);
+    // The held note, not a re-render at the later size.
+    expect(notes).toEqual([await renderContextBoundNote(300_000)]);
+    await observe(600_000);
+    expect(notes).toHaveLength(1);
+  });
+
+  test("never delivers when the window stays closed", async () => {
+    const { observe, notes } = observer(200_000, undefined, () => false);
+    await observe(300_000);
+    await observe(400_000);
+    expect(notes).toEqual([]);
+  });
+
+  test("renders with the session's model at render time", async () => {
+    let model = "made-up-model";
+    const { observe, notes } = observer(200_000, undefined, undefined, () => model);
+    model = "claude-opus-5-5";
+    await observe(210_000);
+    expect(notes).toEqual([
+      "Context is 210,000 tokens (21% of the 1,000,000-token window). Keep this task bounded: finish the current step, store-progress, and complete or defer instead of starting new exploration.",
+    ]);
+  });
+
+  test("checks the window after rendering, not before", async () => {
+    let open = true;
+    const { observe, notes } = observer(200_000, undefined, () => open);
+    const pending = observe(300_000);
+    open = false;
+    await pending;
+    expect(notes).toEqual([]);
+  });
+});
+
+describe("renderContextBoundNote", () => {
+  const rest =
+    "Keep this task bounded: finish the current step, store-progress, and complete or defer instead of starting new exploration.";
+
+  test("renders the code default with a formatted token count and no model", async () => {
+    expect(await renderContextBoundNote(213_456)).toBe(`Context is 213,456 tokens. ${rest}`);
+  });
+
+  test("adds the window share for a known model", async () => {
+    expect(await renderContextBoundNote(210_000, "claude-opus-5-5")).toBe(
+      `Context is 210,000 tokens (21% of the 1,000,000-token window). ${rest}`,
+    );
+    expect(await renderContextBoundNote(200_000, "gpt-5")).toBe(
+      `Context is 200,000 tokens (50% of the 400,000-token window). ${rest}`,
+    );
+  });
+
+  test("omits the share for an unknown model instead of using the 200k fallback", async () => {
+    expect(await renderContextBoundNote(210_000, "made-up-model")).toBe(
+      `Context is 210,000 tokens. ${rest}`,
+    );
+  });
+});
+
+describe("normalizeClaudeMessage requestContextTokens", () => {
+  const state = {
+    taskId: "task-fixture",
+    agentId: "agent-fixture",
+    model: "claude-opus-5-5",
+    contextWindowSize: 1_000_000,
+    transport: "cli" as const,
+  };
+  const usage = {
+    input_tokens: 10,
+    cache_read_input_tokens: 180_000,
+    cache_creation_input_tokens: 25_000,
+    output_tokens: 4_000,
+  };
+
+  test("is input + cache read + cache write of a main-thread request", () => {
+    const normalized = normalizeClaudeMessage(
+      { type: "assistant", message: { content: [], usage } },
+      state,
+    );
+    expect(normalized.requestContextTokens).toBe(205_010);
+  });
+
+  test("is unset for subagent messages", () => {
+    const normalized = normalizeClaudeMessage(
+      { type: "assistant", parent_tool_use_id: "toolu_1", message: { content: [], usage } },
+      state,
+    );
+    expect(normalized.requestContextTokens).toBeUndefined();
+  });
+});

package/src/tests/credential-check.test.ts

@@ -1,8 +1,9 @@
-import { describe, expect, mock, test } from "bun:test";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 import { OPENAI_COMPATIBLE_PROVIDERS } from "@desplega/model-catalog";
 import {
   buildCredStatusReport,
   CREDENTIAL_PROVIDER_CHECKERS,
+  checkEachKey,
   checkOpenAICompatibleProvider,
   checkProviderCredentials,
   isBedrockMode,
@@ -27,6 +28,241 @@ function fsWith(present: Set<string>): { existsSync(p: string): boolean } {
 
 const noFiles = fsWith(new Set());
 
+describe("pool live test", () => {
+  const realFetch = globalThis.fetch;
+  afterEach(() => {
+    globalThis.fetch = realFetch;
+  });
+
+  test("all members pass in parallel with the maximum latency", async () => {
+    let release!: () => void;
+    const gate = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const check = mock(async (key: string) => {
+      await gate;
+      return { ok: true, latency_ms: key === "fake-abcde" ? 30 : 10 };
+    });
+    const pending = checkEachKey("OPENAI_API_KEY", " fake-abcde, fake-fghij ", check);
+    expect(check).toHaveBeenCalledTimes(2);
+    release();
+    expect(await pending).toEqual({
+      ok: true,
+      latency_ms: 30,
+      keys: [
+        { keyType: "OPENAI_API_KEY", index: 0, suffix: "abcde", ok: true, latency_ms: 30 },
+        { keyType: "OPENAI_API_KEY", index: 1, suffix: "fghij", ok: true, latency_ms: 10 },
+      ],
+    });
+  });
+
+  test("one failed member preserves pool order and reports a warning", async () => {
+    const result = await checkEachKey(
+      "ANTHROPIC_API_KEY",
+      "fake-first,fake-abcde,fake-third",
+      async (key) =>
+        key === "fake-abcde"
+          ? { ok: false, error: "Unauthorized", httpStatus: 401, latency_ms: 20 }
+          : { ok: true, latency_ms: 10 },
+    );
+    expect(result).toMatchObject({
+      ok: true,
+      latency_ms: 20,
+      warning: "1 of 3 keys failed: key ending abcde (HTTP 401).",
+    });
+    expect(result.keys).toEqual([
+      { keyType: "ANTHROPIC_API_KEY", index: 0, suffix: "first", ok: true, latency_ms: 10 },
+      {
+        keyType: "ANTHROPIC_API_KEY",
+        index: 1,
+        suffix: "abcde",
+        ok: false,
+        error: "Unauthorized",
+        httpStatus: 401,
+        latency_ms: 20,
+      },
+      { keyType: "ANTHROPIC_API_KEY", index: 2, suffix: "third", ok: true, latency_ms: 10 },
+    ]);
+    expect(result.error).toBeUndefined();
+  });
+
+  test("several failed members use HTTP status or the member error", async () => {
+    const result = await checkEachKey(
+      "OPENAI_API_KEY",
+      "fake-abcde,fake-fghij,fake-third",
+      async (key) => {
+        if (key === "fake-abcde") {
+          return { ok: false, error: "Unauthorized", httpStatus: 401, latency_ms: 10 };
+        }
+        if (key === "fake-fghij") return { ok: false, error: "timeout", latency_ms: 30 };
+        return { ok: true, latency_ms: 20 };
+      },
+    );
+    expect(result.ok).toBe(true);
+    expect(result.warning).toBe(
+      "2 of 3 keys failed: key ending abcde (HTTP 401), key ending fghij (timeout).",
+    );
+    expect(result.latency_ms).toBe(30);
+  });
+
+  test("all failed members produce an error", async () => {
+    const result = await checkEachKey("OPENAI_API_KEY", "fake-abcde,fake-fghij", async () => ({
+      ok: false,
+      error: "Unauthorized",
+      httpStatus: 401,
+      latency_ms: 10,
+    }));
+    expect(result).toMatchObject({
+      ok: false,
+      error: "All 2 keys failed: key ending abcde (HTTP 401), key ending fghij (HTTP 401).",
+      latency_ms: 10,
+    });
+    expect(result.keys).toHaveLength(2);
+    expect(result.warning).toBeUndefined();
+    expect(result.httpStatus).toBeUndefined();
+  });
+
+  test("one failed key preserves the member error and HTTP status", async () => {
+    const result = await checkEachKey("OPENAI_API_KEY", "fake-abcde", async () => ({
+      ok: false,
+      error: "HTTP 401: rejected",
+      httpStatus: 401,
+      latency_ms: 10,
+    }));
+    expect(result).toMatchObject({
+      ok: false,
+      error: "HTTP 401: rejected",
+      httpStatus: 401,
+      latency_ms: 10,
+    });
+    expect(result.keys).toHaveLength(1);
+  });
+
+  test("a thrown check becomes a scrubbed member failure", async () => {
+    const result = await checkEachKey("OPENAI_API_KEY", "fake-abcde,fake-fghij", async (key) => {
+      if (key === "fake-abcde") throw new Error("timeout");
+      return { ok: true, latency_ms: 0 };
+    });
+    expect(result.ok).toBe(true);
+    expect(result.warning).toBe("1 of 2 keys failed: key ending abcde (timeout).");
+    expect(result.keys?.[0]).toMatchObject({ ok: false, error: "timeout" });
+    expect(result.keys?.[0]?.latency_ms).toBeGreaterThanOrEqual(0);
+  });
+
+  test("a CODEX_OAUTH JSON blob remains one member", async () => {
+    const blob = '{"access":"fake-access","refresh":"fake-refresh","expires":123}';
+    const check = mock(async () => ({ ok: true, latency_ms: 0 }));
+    const result = await checkEachKey("CODEX_OAUTH", ` ${blob} `, check);
+    expect(check).toHaveBeenCalledTimes(1);
+    expect(check).toHaveBeenCalledWith(blob);
+    expect(result.keys).toHaveLength(1);
+    expect(result.keys?.[0]?.suffix).toBe(blob.slice(-5));
+  });
+
+  test("an empty split checks the trimmed input once", async () => {
+    const check = mock(async () => ({ ok: false, error: "Missing key", latency_ms: 0 }));
+    const result = await checkEachKey("OPENAI_API_KEY", " , , ", check);
+    expect(check).toHaveBeenCalledTimes(1);
+    expect(check).toHaveBeenCalledWith(", ,");
+    expect(result.error).toBe("Missing key");
+  });
+
+  test("all configured members skip the live test", async () => {
+    const result = await checkEachKey("ANTHROPIC_API_KEY", "fake-abcde,fake-fghij", async () => ({
+      ok: true,
+      skipped: true,
+      latency_ms: 10,
+    }));
+    expect(result).toEqual({ ok: true, skipped: true, latency_ms: 10 });
+  });
+
+  test("Claude API-key pools send a separate request for each member", async () => {
+    const fetchMock = mock(async (_url: string | URL | Request, init?: RequestInit) => {
+      const key = new Headers(init?.headers).get("x-api-key");
+      return new Response("{}", { status: key === "fake-good1" ? 200 : 401 });
+    });
+    globalThis.fetch = fetchMock as typeof fetch;
+    const result = await validateProviderCredentials("claude", {
+      ANTHROPIC_API_KEY: "fake-good1,fake-bad01",
+    });
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(
+      fetchMock.mock.calls.map(([, init]) => new Headers(init?.headers).get("x-api-key")),
+    ).toEqual(["fake-good1", "fake-bad01"]);
+    expect(result.ok).toBe(true);
+    expect(result.warning).toBe("1 of 2 keys failed: key ending bad01 (HTTP 401).");
+    expect(result.keys?.[1]?.httpStatus).toBe(401);
+  });
+
+  test("Claude subscription pools check the OAuth profile for each member", async () => {
+    const fetchMock = mock(async (_url: string | URL | Request, _init?: RequestInit) => {
+      return new Response("{}", { status: 200 });
+    });
+    globalThis.fetch = fetchMock as typeof fetch;
+    const result = await validateProviderCredentials("claude", {
+      CLAUDE_CODE_OAUTH_TOKEN: "fake-token-a,fake-token-b",
+    });
+    expect(result.ok).toBe(true);
+    expect(result.keys).toHaveLength(2);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    for (const [url, init] of fetchMock.mock.calls) {
+      expect(String(url)).toBe("https://api.anthropic.com/api/oauth/profile");
+      expect(init?.method).toBe("GET");
+    }
+    expect(
+      fetchMock.mock.calls.map(([, init]) => new Headers(init?.headers).get("Authorization")),
+    ).toEqual(["Bearer fake-token-a", "Bearer fake-token-b"]);
+  });
+
+  test("buildCredStatusReport copies the warning and per-key results", async () => {
+    globalThis.fetch = (async (_url: string | URL | Request, init?: RequestInit) => {
+      const key = new Headers(init?.headers).get("x-api-key");
+      return new Response("{}", { status: key === "fake-good1" ? 200 : 401 });
+    }) as typeof fetch;
+    const report = await buildCredStatusReport(
+      "claude",
+      { ANTHROPIC_API_KEY: "fake-good1,fake-bad01" },
+      {},
+      "boot",
+    );
+    expect(report.liveTest?.warning).toBe("1 of 2 keys failed: key ending bad01 (HTTP 401).");
+    expect(report.liveTest?.keys).toEqual([
+      {
+        keyType: "ANTHROPIC_API_KEY",
+        index: 0,
+        suffix: "good1",
+        ok: true,
+        latency_ms: expect.any(Number),
+      },
+      {
+        keyType: "ANTHROPIC_API_KEY",
+        index: 1,
+        suffix: "bad01",
+        ok: false,
+        error: "HTTP 401: {}",
+        httpStatus: 401,
+        latency_ms: expect.any(Number),
+      },
+    ]);
+    expect(AgentCredStatusSchema.parse(report).liveTest).toEqual(report.liveTest);
+    const success = await buildCredStatusReport(
+      "claude",
+      { ANTHROPIC_API_KEY: "fake-good1" },
+      {},
+      "boot",
+    );
+    expect(success.liveTest).not.toHaveProperty("warning");
+    const presenceOnly = await buildCredStatusReport(
+      "acp",
+      { ACP_COMMAND: "fake-command" },
+      {},
+      "boot",
+    );
+    expect(presenceOnly.liveTest).not.toHaveProperty("warning");
+    expect(presenceOnly.liveTest).not.toHaveProperty("keys");
+  });
+});
+
 // ─── claude ──────────────────────────────────────────────────────────────────
 
 describe("checkClaudeCredentials", () => {
@@ -1174,7 +1410,10 @@ describe("buildCredStatusReport", () => {
           expect(failure.liveTest?.ok).toBe(false);
           expect(failure.liveTest?.error).toContain("HTTP 401");
           expect(fetchMock).toHaveBeenCalledTimes(2);
-          expect(String(fetchMock.mock.calls[0]?.[0])).toMatch(/\/models$/);
+          // OpenRouter's /models is public, so its key is checked on /key.
+          expect(String(fetchMock.mock.calls[0]?.[0])).toMatch(
+            key === "OPENROUTER_API_KEY" ? /\/key$/ : /\/models$/,
+          );
         } finally {
           globalThis.fetch = realFetch;
         }
@@ -1437,3 +1676,52 @@ describe("runBedrockSdkProbeAndEnumerate — intersection logic", () => {
     mock.restore();
   });
 });
+
+describe("OpenRouter and DeepSeek live checks", () => {
+  const realFetch = globalThis.fetch;
+  afterEach(() => {
+    globalThis.fetch = realFetch;
+  });
+
+  /** Answers by path; records every URL. */
+  function stubByPath(statusFor: (url: string) => number) {
+    const urls: string[] = [];
+    globalThis.fetch = (async (input: string | URL | Request) => {
+      const url = input instanceof Request ? input.url : String(input);
+      urls.push(url);
+      return new Response("{}", { status: statusFor(url) });
+    }) as typeof fetch;
+    return urls;
+  }
+
+  test("OpenRouter checks the key on /key, not the public /models", async () => {
+    const urls = stubByPath((url) => (url.endsWith("/key") ? 401 : 200));
+    const result = await validateProviderCredentials("pi", { OPENROUTER_API_KEY: "or-bad" });
+    expect(result).toMatchObject({ ok: false, httpStatus: 401 });
+    expect(urls).toEqual(["https://openrouter.ai/api/v1/key"]);
+  });
+
+  test("a base URL without /key falls back to /models", async () => {
+    const urls = stubByPath((url) => (url.endsWith("/key") ? 404 : 200));
+    const result = await validateProviderCredentials("pi", { OPENROUTER_API_KEY: "or-key" });
+    expect(result.ok).toBe(true);
+    expect(urls).toEqual([
+      "https://openrouter.ai/api/v1/key",
+      "https://openrouter.ai/api/v1/models",
+    ]);
+  });
+
+  test("dsh checks DEEPSEEK_API_KEY on DeepSeek /models, else OpenRouter", async () => {
+    const urls = stubByPath(() => 401);
+    const deepseek = await validateProviderCredentials("dsh", {
+      DEEPSEEK_API_KEY: "ds-bad",
+      OPENROUTER_API_KEY: "or-key",
+    });
+    expect(deepseek).toMatchObject({ ok: false, httpStatus: 401 });
+    expect(urls).toEqual(["https://api.deepseek.com/models"]);
+
+    const openrouter = await validateProviderCredentials("dsh", { OPENROUTER_API_KEY: "or-key" });
+    expect(openrouter).toMatchObject({ ok: false, httpStatus: 401 });
+    expect(urls.at(-1)).toBe("https://openrouter.ai/api/v1/key");
+  });
+});