@desplega.ai/agent-swarm 2.7.4 → 2.7.5

package/src/tests/chat-sdk-inbound.test.ts

@@ -12,13 +12,16 @@ import {
   createUser,
   getDbClient,
   getKv,
+  getLogsByTaskId,
   getTaskAttachments,
   getTaskById,
   initDb,
   startTask,
   upsertKv,
 } from "../be/db";
+import { installExtension } from "../be/extensions/db";
 import { linkIdentity } from "../be/users";
+import { enableExtension, stopExtensionRuntime } from "../extensions/lifecycle";
 import { resetFileStorageProviderForTests } from "../fs/registry";
 import { drainBackground } from "../integrations/chat-sdk/background";
 import { CHAT_CHANNEL_SETTINGS_NAMESPACE } from "../integrations/chat-sdk/reactions";
@@ -42,6 +45,8 @@ import {
   telegramUpdate,
 } from "./chat-sdk-harness";
 
+import { loadBundleFixture } from "./fixtures/extensions/load";
+
 const TEST_DB_PATH = "./test-chat-sdk-inbound.sqlite";
 const ENV_KEYS = [
   "AGENT_FS_LOCAL_DIR",
@@ -271,6 +276,31 @@ describe("Chat SDK inbound pipeline", () => {
     expect(sendCount()).toBe(sendsBefore);
   });
 
+  test("an extension-blocked steer never falls back to a follow-up task", async () => {
+    await postTelegramUpdate(telegramUpdate(group(-2025), "@swarm_test_bot plan the report"));
+    await flushChatBuffers();
+    const [task] = await chatTasks(-2025);
+    expect(task).toBeDefined();
+    await startTask(task!.id);
+    const bundle = await loadBundleFixture("steering-policy");
+    const { extension } = await installExtension({ ...bundle, config: { action: "block" } });
+    await enableExtension(extension.id);
+    try {
+      const blocked = telegramUpdate(group(-2025), "Do not deliver this correction");
+      await postTelegramUpdate(blocked);
+      await flushChatBuffers();
+      expect(await chatTasks(-2025)).toHaveLength(1);
+      expect(await steeringRows(task!.id)).toEqual([]);
+      expect(reactionsOn(-2025, blocked)).toEqual(["👎"]);
+      expect(
+        (await getLogsByTaskId(task!.id)).filter((log) => log.eventType === "task_steering"),
+      ).toEqual([]);
+    } finally {
+      await stopExtensionRuntime();
+      await getDbClient().run("DELETE FROM extensions WHERE id = ?", [extension.id]);
+    }
+  });
+
   test("a channel that opts into text acks also gets the steering reply", async () => {
     await upsertKv({
       namespace: CHAT_CHANNEL_SETTINGS_NAMESPACE,

package/src/tests/chatgpt-subscription-model-groups.test.ts

@@ -0,0 +1,62 @@
+/**
+ * The pi model picker's ChatGPT subscription group: present only while a
+ * `codex_oauth` pool slot exists, listing the codex harness models under
+ * `openai-codex/<id>`.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { SwarmConfig } from "../../apps/ui/src/api/types";
+import {
+  CHATGPT_SUBSCRIPTION_LABEL,
+  effortLevelsFor,
+  findKnownModel,
+  modelGroupsForHarness,
+} from "../../apps/ui/src/lib/agent-runtime-models";
+
+function configRow(key: string, value: string): SwarmConfig {
+  return { key, value } as SwarmConfig;
+}
+
+const withSlot = [configRow("codex_oauth_0", "********")];
+
+describe("ChatGPT subscription group", () => {
+  test("hidden on pi without a codex_oauth slot", () => {
+    const groups = modelGroupsForHarness("pi", [configRow("codex_oauth_0", "")], undefined);
+    expect(groups.find((g) => g.provider === CHATGPT_SUBSCRIPTION_LABEL)).toBeUndefined();
+  });
+
+  test("shown and enabled on pi with a slot, holding the codex list as openai-codex ids", () => {
+    const group = modelGroupsForHarness("pi", withSlot, undefined).find(
+      (g) => g.provider === CHATGPT_SUBSCRIPTION_LABEL,
+    );
+    const codexIds = modelGroupsForHarness("codex", undefined, undefined)[0].models.map(
+      (m) => `openai-codex/${m.id}`,
+    );
+    expect(group?.enabled).toBe(true);
+    expect(group?.models.map((m) => m.id)).toEqual(codexIds);
+    expect(group?.models.every((m) => m.cost === undefined)).toBe(true);
+  });
+
+  test("not offered on opencode or codex", () => {
+    for (const harness of ["opencode", "codex"] as const) {
+      const groups = modelGroupsForHarness(harness, withSlot, undefined);
+      expect(groups.find((g) => g.provider === CHATGPT_SUBSCRIPTION_LABEL)).toBeUndefined();
+    }
+  });
+
+  test("a stored subscription id displays as its catalog model and keeps its effort levels", () => {
+    const known = findKnownModel("openai-codex/gpt-5.6-sol");
+    expect(known?.provider).toBe(CHATGPT_SUBSCRIPTION_LABEL);
+    expect(known?.label).not.toBe("openai-codex/gpt-5.6-sol");
+    expect(effortLevelsFor("pi", "openai-codex/gpt-5.6-sol")).toEqual(
+      effortLevelsFor("pi", "openai/gpt-5.6-sol"),
+    );
+    expect(effortLevelsFor("pi", "openai-codex/gpt-5.6-sol").length).toBeGreaterThan(0);
+  });
+
+  test("a mixed-case prefix keeps its effort levels", () => {
+    expect(effortLevelsFor("pi", "OpenAI-Codex/gpt-5.6-sol")).toEqual(
+      effortLevelsFor("pi", "openai/gpt-5.6-sol"),
+    );
+  });
+});

package/src/tests/chatgpt-subscription-pi.test.ts

@@ -0,0 +1,170 @@
+/**
+ * pi on the ChatGPT subscription pool (`openai-codex/<id>` models): the
+ * credential handed to pi never carries the pool's refresh token, the gate
+ * reports ready on pool slots, and the model resolves to pi-ai's ChatGPT
+ * backend provider.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { CodexOAuthRefreshError } from "../providers/codex-oauth/storage";
+import {
+  chatgptSubscriptionAuthFailure,
+  loadChatgptSubscriptionCredential,
+} from "../providers/codex-oauth/subscription";
+import {
+  checkPiMonoCredentials,
+  createPiRuntimeAuth,
+  resolveModel,
+} from "../providers/pi-mono-adapter";
+import { supportedReasoningLevels } from "../providers/reasoning-effort";
+import { isCodexAuthFailureReason } from "../utils/codex-auth-failure";
+
+const CREDS = {
+  access: "subscription-access-token-for-tests",
+  refresh: "pool-refresh-token-must-not-leak",
+  expires: Date.now() + 24 * 60 * 60 * 1000,
+  accountId: "acct-subscription",
+};
+const CONFIG = {
+  apiUrl: "http://localhost:3013",
+  apiKey: "test-key",
+  codexSlot: 2,
+  model: "openai-codex/gpt-5.6-sol",
+};
+const noFiles = { existsSync: () => false };
+
+describe("loadChatgptSubscriptionCredential", () => {
+  test("revalidates the runner's slot and blanks the refresh token", async () => {
+    let slotSeen: number | undefined;
+    const creds = await loadChatgptSubscriptionCredential(CONFIG, {
+      getValid: async (_url, _key, slot) => {
+        slotSeen = slot;
+        return CREDS;
+      },
+    });
+    expect(slotSeen).toBe(2);
+    expect(creds).toEqual({ ...CREDS, refresh: "" });
+  });
+
+  test("no pool slot is an auth error, not a silent fallback", async () => {
+    await expect(
+      loadChatgptSubscriptionCredential({ ...CONFIG, codexSlot: undefined }),
+    ).rejects.toThrow("[auth-error]");
+  });
+
+  test("a rejected refresh carries the codex pool failure reason", async () => {
+    await expect(
+      loadChatgptSubscriptionCredential(CONFIG, {
+        getValid: async () => {
+          throw new CodexOAuthRefreshError(2, "refresh_rejected", "abcde", 401, "revoked");
+        },
+      }),
+    ).rejects.toThrow("Codex pool slot 2 [...abcde] revalidation failed: refresh rejected");
+  });
+
+  test("a quarantined slot fails fast", async () => {
+    await expect(
+      loadChatgptSubscriptionCredential(CONFIG, { getValid: async () => null }),
+    ).rejects.toThrow("no credentials found in config store");
+  });
+});
+
+describe("checkPiMonoCredentials with a subscription model", () => {
+  const model = { MODEL_OVERRIDE: "openai-codex/gpt-5.6-sol" };
+
+  test("ready when the pool has slots", async () => {
+    const status = await checkPiMonoCredentials(
+      { ...model, CODEX_OAUTH_POOL_SLOTS: "2" },
+      { homeDir: "/home/test", fs: noFiles },
+    );
+    expect(status).toEqual({ ready: true, missing: [], satisfiedBy: "env" });
+  });
+
+  test("not ready without slots, even with other keys or a pi auth.json", async () => {
+    const status = await checkPiMonoCredentials(
+      { ...model, OPENAI_API_KEY: "sk-test" },
+      { homeDir: "/home/test", fs: { existsSync: () => true } },
+    );
+    expect(status.ready).toBe(false);
+    expect(status.missing).toEqual(["CODEX_OAUTH"]);
+  });
+
+  test("pool slots alone satisfy the permissive (no MODEL_OVERRIDE) check", async () => {
+    const status = await checkPiMonoCredentials(
+      { CODEX_OAUTH_POOL_SLOTS: "1" },
+      { homeDir: "/home/test", fs: noFiles },
+    );
+    expect(status.ready).toBe(true);
+  });
+});
+
+describe("pi model resolution and auth", () => {
+  test("a shipped id resolves to pi-ai's openai-codex model", () => {
+    const model = resolveModel("openai-codex/gpt-5.6-sol", {});
+    expect({ provider: model?.provider, id: model?.id }).toEqual({
+      provider: "openai-codex",
+      id: "gpt-5.6-sol",
+    });
+  });
+
+  test("a catalog id pi-ai does not ship reuses the provider's transport", () => {
+    const model = resolveModel("openai-codex/gpt-7-test", {});
+    expect({ provider: model?.provider, id: model?.id, api: model?.api }).toEqual({
+      provider: "openai-codex",
+      id: "gpt-7-test",
+      api: "openai-codex-responses",
+    });
+  });
+
+  test("the session runtime authenticates openai-codex from memory with no refresh token", async () => {
+    const runtime = await createPiRuntimeAuth({}, undefined, { ...CREDS, refresh: "" });
+    const auth = await runtime.getAuth("openai-codex");
+    expect(auth?.auth.apiKey).toBe(CREDS.access);
+    const listed = await runtime.listCredentials();
+    expect(listed).toContainEqual({ providerId: "openai-codex", type: "oauth" });
+  });
+});
+
+describe("chatgptSubscriptionAuthFailure", () => {
+  const revoked =
+    "Your authentication token has been invalidated. Please try signing in again. (token_invalidated)";
+
+  test("a rejected subscription login mid-run is a counted auth failure for its slot", () => {
+    const reason = chatgptSubscriptionAuthFailure(revoked, CONFIG);
+    expect(reason).toStartWith("[auth-error] Codex pool slot 2 authentication failed");
+    expect(reason).toContain(revoked);
+    expect(isCodexAuthFailureReason(reason)).toBe(true);
+    expect(
+      isCodexAuthFailureReason(chatgptSubscriptionAuthFailure("401 Unauthorized", CONFIG)),
+    ).toBe(true);
+  });
+
+  test("the backend's 401 for an unparseable access token counts too", () => {
+    // Live body for a slot holding a malformed access token (pi surfaces it without the status).
+    const reason = chatgptSubscriptionAuthFailure(
+      "Could not parse your authentication token. Please try signing in again.",
+      CONFIG,
+    );
+    expect(isCodexAuthFailureReason(reason)).toBe(true);
+  });
+
+  test("other errors, models and slotless sessions are left alone", () => {
+    expect(chatgptSubscriptionAuthFailure("Codex stream ended without a stop reason", CONFIG)).toBe(
+      undefined,
+    );
+    expect(
+      chatgptSubscriptionAuthFailure(revoked, { ...CONFIG, model: "openai/gpt-5.6-sol" }),
+    ).toBe(undefined);
+    expect(chatgptSubscriptionAuthFailure(revoked, { ...CONFIG, codexSlot: undefined })).toBe(
+      undefined,
+    );
+  });
+});
+
+describe("subscription effort levels on the worker", () => {
+  test("a mixed-case prefix keeps the openai levels", () => {
+    const levels = supportedReasoningLevels("pi", "OpenAI-Codex/gpt-5.6-sol");
+    expect(levels.length).toBeGreaterThan(0);
+    expect(levels).toEqual(supportedReasoningLevels("pi", "openai/gpt-5.6-sol"));
+  });
+});

package/src/tests/chatgpt-subscription-session-bench.test.ts

@@ -0,0 +1,198 @@
+/**
+ * The auth-failure bench for a ChatGPT subscription pool slot (pi on
+ * `openai-codex/<id>`). A refresh rejected while the session starts fails
+ * `createSession`, before the completion-time report, so the runner reports it
+ * there. A login rejected mid-run reaches the completion-time report as a
+ * counted `[auth-error]`. Session starts go through `spawnProviderProcess`,
+ * the boundary the new-task and resumed-task paths share, against the real
+ * key-status routes.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtemp, rm, unlink } from "node:fs/promises";
+import { createServer, type Server } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { closeDb, initDb } from "../be/db";
+import { reportKeyCompletionOutcome, spawnProviderProcess } from "../commands/runner";
+import { handleApiKeys } from "../http/api-keys";
+import { deriveCodexKeySuffix } from "../providers/codex-oauth/auth-json";
+import { CodexOAuthRefreshError } from "../providers/codex-oauth/storage";
+import {
+  chatgptSubscriptionAuthFailure,
+  loadChatgptSubscriptionCredential,
+} from "../providers/codex-oauth/subscription";
+import type { CodexOAuthCredentials } from "../providers/codex-oauth/types";
+import type { ProviderSessionConfig } from "../providers/types";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB = `./test-chatgpt-subscription-session-bench-${Date.now()}.sqlite`;
+const TASK_ID = "00000000-0000-4000-8000-000000000001";
+const AGENT_ID = "00000000-0000-4000-8000-0000000000aa";
+const MODEL = "openai-codex/gpt-5.6-sol";
+
+let server: Server;
+let baseUrl = "";
+let logDir = "";
+/** The pool the config store serves: `codex_oauth_<slot>` entries. */
+let pool: Array<{ slot: number; creds: CodexOAuthCredentials }> = [];
+
+beforeAll(async () => {
+  initDb(TEST_DB);
+  logDir = await mkdtemp(join(tmpdir(), "chatgpt-sub-bench-"));
+  server = createServer(async (req, res) => {
+    const url = new URL(req.url || "/", "http://localhost");
+    if (req.method === "GET" && url.pathname === "/api/config/resolved") {
+      const configs = pool.map(({ slot, creds }) => ({
+        key: `codex_oauth_${slot}`,
+        value: JSON.stringify(creds),
+      }));
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ configs }));
+      return;
+    }
+    const handled = await handleApiKeys(
+      req,
+      res,
+      url.pathname.split("/").filter(Boolean),
+      url.searchParams,
+    );
+    if (!handled) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end("{}");
+    }
+  });
+  baseUrl = `http://127.0.0.1:${await listenOnFreePort(server)}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) await unlink(`${TEST_DB}${suffix}`).catch(() => {});
+  await rm(logDir, { recursive: true, force: true });
+});
+
+async function slotStatus(keySuffix: string) {
+  const res = await fetch(`${baseUrl}/api/keys/status?keyType=CODEX_OAUTH`);
+  const body = (await res.json()) as { keys: Array<Record<string, unknown>> };
+  return body.keys.find((k) => k.keySuffix === keySuffix);
+}
+
+/** Serve a one-slot pool; returns the slot's key suffix. */
+function serveSlot(slot: number, accountId: string): string {
+  const creds: CodexOAuthCredentials = {
+    access: `at_synthetic_${accountId}`,
+    refresh: `rt_synthetic_${accountId}`,
+    expires: Date.now() - 1000,
+    accountId,
+  };
+  pool = [{ slot, creds }];
+  return deriveCodexKeySuffix(creds.access, accountId);
+}
+
+/** A pi adapter whose session start revalidates the slot with `getValid`. */
+function piAdapter(getValid: () => Promise<never>) {
+  const slots: Array<number | undefined> = [];
+  const adapter = {
+    name: "pi",
+    traits: {},
+    canResume: async () => false,
+    formatCommand: (name: string) => name,
+    createSession: async (config: ProviderSessionConfig) => {
+      slots.push(config.codexSlot);
+      await loadChatgptSubscriptionCredential(config, { getValid });
+      throw new Error("unreachable");
+    },
+  } as unknown as Parameters<typeof spawnProviderProcess>[0];
+  return { adapter, slots };
+}
+
+/**
+ * Options as the poll loop passes them: a new task carries the claim's
+ * resolved model, a resumed task only its own pin and never a native resume
+ * id.
+ */
+function startOpts(kind: "new" | "resumed") {
+  const base = {
+    prompt: kind === "new" ? "do the task" : "resume the task",
+    logFile: join(logDir, `${kind}.jsonl`),
+    role: "worker",
+    apiUrl: baseUrl,
+    apiKey: "test-key",
+    agentId: AGENT_ID,
+    runnerSessionId: crypto.randomUUID(),
+    iteration: 1,
+    taskId: TASK_ID,
+    model: MODEL,
+    harnessProvider: "pi" as const,
+    cwd: logDir,
+  };
+  return kind === "new"
+    ? { ...base, resolvedModel: MODEL, modelSource: "task", triggerSurface: "api" }
+    : { ...base, resumeSessionId: undefined };
+}
+
+function startSession(
+  adapter: Parameters<typeof spawnProviderProcess>[0],
+  kind: "new" | "resumed",
+) {
+  return spawnProviderProcess(adapter, startOpts(kind), logDir, true);
+}
+
+describe("ChatGPT subscription slot bench", () => {
+  for (const [kind, slot] of [
+    ["new", 1],
+    ["resumed", 2],
+  ] as const) {
+    test(`a refresh rejected at ${kind}-task session start benches the slot on the second start`, async () => {
+      const keySuffix = serveSlot(slot, `acct-${kind}`);
+      const { adapter, slots } = piAdapter(async () => {
+        throw new CodexOAuthRefreshError(slot, "refresh_rejected", keySuffix, 401, "invalid_grant");
+      });
+
+      for (let i = 0; i < 2; i++) {
+        await expect(startSession(adapter, kind)).rejects.toThrow("refresh rejected (401");
+      }
+
+      expect(slots).toEqual([slot, slot]);
+      expect(await slotStatus(keySuffix)).toMatchObject({
+        status: "rate_limited",
+        consecutiveAuthFailures: 2,
+      });
+    });
+  }
+
+  test("a lock timeout at session start is transient and never counts", async () => {
+    const keySuffix = serveSlot(4, "acct-lock");
+    const { adapter } = piAdapter(async () => {
+      throw new CodexOAuthRefreshError(4, "lock_timeout", keySuffix);
+    });
+
+    for (let i = 0; i < 2; i++) {
+      await expect(startSession(adapter, "new")).rejects.toThrow("refresh lock");
+    }
+
+    expect((await slotStatus(keySuffix))?.consecutiveAuthFailures ?? 0).toBe(0);
+  });
+
+  test("a login rejected mid-run benches the slot through the completion report", async () => {
+    const reason = chatgptSubscriptionAuthFailure(
+      "Your authentication token has been invalidated. Please try signing in again.",
+      { codexSlot: 3, model: "openai-codex/gpt-5.6-sol" },
+    );
+    for (let i = 0; i < 2; i++) {
+      await reportKeyCompletionOutcome({
+        apiUrl: baseUrl,
+        apiKey: "test-key",
+        credential: { keyType: "CODEX_OAUTH", keySuffix: "subC3", keyIndex: 3 },
+        taskId: TASK_ID,
+        exitCode: 1,
+        failureReason: reason,
+      });
+    }
+
+    expect(await slotStatus("subC3")).toMatchObject({
+      status: "rate_limited",
+      consecutiveAuthFailures: 2,
+    });
+  });
+});

package/src/tests/codex-oauth-credential-info.test.ts

@@ -143,4 +143,44 @@ describe("resolveCodexOAuthCredentialInfo — issue #1102 bug 1", () => {
     expect(info!.selection.index).toBe(0);
     expect(info!.selection.total).toBe(1);
   });
+
+  it("poolOnly (pi subscription) picks a slot without writing ~/.codex/auth.json", async () => {
+    const creds = {
+      access:
+        "header.eyJodHRwczovL2FwaS5vcGVuYWkuY29tL2F1dGgiOnsiY2hhdGdwdF9hY2NvdW50X2lkIjoiYWNjLXBvb2wifX0=.sig",
+      refresh: "rt_pool",
+      expires: Date.now() + 3_600_000,
+      accountId: "acc-pool",
+    };
+    globalThis.fetch = (async (url: string | URL | Request) => {
+      const href = typeof url === "string" ? url : url instanceof URL ? url.href : url.url;
+      if (href.includes("/api/config/resolved")) {
+        return new Response(
+          JSON.stringify({ configs: [{ key: "codex_oauth_1", value: JSON.stringify(creds) }] }),
+          { status: 200, headers: { "Content-Type": "application/json" } },
+        );
+      }
+      if (href.includes("/api/keys/available")) {
+        return new Response(JSON.stringify({ availableIndices: [1] }), { status: 200 });
+      }
+      return new Response("not found", { status: 404 });
+    }) as typeof fetch;
+
+    const info = await resolveCodexOAuthCredentialInfo(MOCK_API_URL, MOCK_API_KEY, {
+      poolOnly: true,
+    });
+
+    expect(info?.isPoolBacked).toBe(true);
+    expect(info?.selection.index).toBe(1);
+    expect(await Bun.file(join(tmpHome, ".codex", "auth.json")).exists()).toBe(false);
+  });
+
+  it("poolOnly ignores a standalone auth.json: no slot means no subscription", async () => {
+    mockEmptyConfigStore();
+    await writeStandaloneAuthJson();
+
+    expect(
+      await resolveCodexOAuthCredentialInfo(MOCK_API_URL, MOCK_API_KEY, { poolOnly: true }),
+    ).toBeNull();
+  });
 });