@desplega.ai/agent-swarm 1.119.6 → 1.121.0

package/src/tests/oauth-refresh-failure.test.ts

@@ -0,0 +1,263 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, createAgent, getDb, initDb } from "../be/db";
+import {
+  getAuthorizationById,
+  getOAuthApp,
+  storeOAuthTokens,
+  upsertAuthorization,
+  upsertOAuthApp,
+} from "../be/db-queries/oauth";
+import { upsertCredentialBinding } from "../be/script-connections";
+import { buildScriptCredentialBindingsWithFailures } from "../be/script-credential-broker";
+import {
+  ensureAuthorizationTokenOrThrow,
+  forceRefreshAuthorizationOrThrow,
+  OAuthRefreshError,
+} from "../oauth/ensure-token";
+import { patchFetchWithCredentialBroker } from "../scripts-runtime/credential-broker";
+import { clearVolatileSecretsForTesting } from "../utils/secret-scrubber";
+
+const TEST_DB_PATH = "./test-oauth-refresh-failure.sqlite";
+const LEAD_ID = "aaaa9500-0000-4000-8000-000000000001";
+const originalFetch = globalThis.fetch;
+
+function appConfig(provider: string, tokenUrl = `https://oauth.${provider}.test/token`) {
+  return {
+    clientId: `${provider}-client-id`,
+    clientSecret: `${provider}-client-secret`,
+    authorizeUrl: `https://oauth.${provider}.test/authorize`,
+    tokenUrl,
+    redirectUri: "http://localhost:3013/callback",
+    scopes: "read,write",
+  };
+}
+
+/**
+ * Mock the token endpoint. Refresh requests whose body carries a refresh token
+ * listed in `failFor` get a 400 (invalid_grant); everything else gets a fresh
+ * token whose access value is derived from the incoming refresh token so
+ * per-authorization isolation is observable.
+ */
+function mockTokenEndpoint(failFor: string[] = []): void {
+  globalThis.fetch = (async (_input: string | URL | Request, init?: RequestInit) => {
+    const body = typeof init?.body === "string" ? init.body : "";
+    const failing = failFor.some((token) => body.includes(`refresh_token=${token}`));
+    if (failing) {
+      return new Response(JSON.stringify({ error: "invalid_grant" }), {
+        status: 400,
+        headers: { "content-type": "application/json" },
+      });
+    }
+    return new Response(
+      JSON.stringify({
+        access_token: "healed-access-token",
+        token_type: "bearer",
+        expires_in: 3600,
+        refresh_token: "rotated-refresh-token",
+        scope: "read,write",
+      }),
+      { status: 200, headers: { "content-type": "application/json" } },
+    );
+  }) as typeof fetch;
+}
+
+beforeAll(async () => {
+  await unlink(TEST_DB_PATH).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-wal`).catch(() => {});
+  await unlink(`${TEST_DB_PATH}-shm`).catch(() => {});
+  initDb(TEST_DB_PATH);
+  createAgent({ id: LEAD_ID, name: "OAuth Refresh Lead", isLead: true, status: "idle" });
+});
+
+beforeEach(() => {
+  globalThis.fetch = originalFetch;
+  clearVolatileSecretsForTesting();
+  getDb().run("DELETE FROM oauth_refresh_locks");
+  getDb().run("DELETE FROM script_credential_bindings");
+  getDb().run("DELETE FROM oauth_authorizations");
+  getDb().run("DELETE FROM oauth_apps");
+});
+
+afterAll(async () => {
+  globalThis.fetch = originalFetch;
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await unlink(TEST_DB_PATH + suffix).catch(() => {});
+  }
+});
+
+function seedDefault(provider: string, refreshToken: string | null, expiresInMs: number): string {
+  storeOAuthTokens(provider, {
+    accessToken: `${provider}-access`,
+    refreshToken,
+    expiresAt: new Date(Date.now() + expiresInMs).toISOString(),
+    scope: "read,write",
+  });
+  const id = getDb()
+    .query(
+      `SELECT z.id AS id FROM oauth_authorizations z
+       JOIN oauth_apps a ON a.id = z.appId
+       WHERE a.provider = ? AND a.mcpServerId IS NULL AND z.label = 'default'`,
+    )
+    .get(provider) as { id: string } | null;
+  if (!id) throw new Error("default authorization not seeded");
+  return id.id;
+}
+
+describe("OAuth refresh failure semantics", () => {
+  test("a rejected refresh persists refresh-failed + lastErrorMessage and throws typed error", async () => {
+    upsertOAuthApp("acme", appConfig("acme"));
+    const authId = seedDefault("acme", "acme-refresh", 60 * 1000);
+    mockTokenEndpoint(["acme-refresh"]);
+
+    await expect(forceRefreshAuthorizationOrThrow(authId)).rejects.toBeInstanceOf(
+      OAuthRefreshError,
+    );
+
+    const after = getAuthorizationById(authId);
+    expect(after?.status).toBe("refresh-failed");
+    expect(after?.lastErrorMessage).toBeTruthy();
+    expect(after?.lastErrorMessage).toContain("400");
+  });
+
+  test("a recovered provider flips a refresh-failed authorization back to active", async () => {
+    upsertOAuthApp("acme", appConfig("acme"));
+    const authId = seedDefault("acme", "acme-refresh", 60 * 1000);
+
+    mockTokenEndpoint(["acme-refresh"]);
+    await expect(forceRefreshAuthorizationOrThrow(authId)).rejects.toBeInstanceOf(
+      OAuthRefreshError,
+    );
+    expect(getAuthorizationById(authId)?.status).toBe("refresh-failed");
+
+    // Provider recovers.
+    mockTokenEndpoint();
+    await forceRefreshAuthorizationOrThrow(authId);
+    const healed = getAuthorizationById(authId);
+    expect(healed?.status).toBe("active");
+    expect(healed?.lastErrorMessage).toBeNull();
+    expect(healed?.accessToken).toBe("healed-access-token");
+  });
+
+  test("the broker surfaces a failed OAuth binding while other bindings still resolve", async () => {
+    upsertOAuthApp("acme", { ...appConfig("acme"), displayName: "Acme Corp" });
+    const authId = seedDefault("acme", "acme-refresh", 60 * 1000);
+    upsertCredentialBinding({
+      configKey: "ACME_OAUTH",
+      allowedHosts: ["api.acme.test"],
+      headerTemplate: "Authorization: Bearer [REDACTED:ACME_OAUTH]",
+      authKind: "oauth",
+      oauthAuthorizationId: authId,
+    });
+    upsertCredentialBinding({
+      configKey: "HEALTHY_CONFIG",
+      allowedHosts: ["api.acme.test"],
+      headerTemplate: "Authorization: Bearer [REDACTED:HEALTHY_CONFIG]",
+    });
+    process.env.HEALTHY_CONFIG = "healthy-config-value";
+    mockTokenEndpoint(["acme-refresh"]);
+
+    try {
+      const { egressSecrets, failedBindings } = await buildScriptCredentialBindingsWithFailures({});
+
+      expect(egressSecrets.some((b) => b.configKey === "ACME_OAUTH")).toBe(false);
+      expect(egressSecrets).toContainEqual(
+        expect.objectContaining({ configKey: "HEALTHY_CONFIG", value: "healthy-config-value" }),
+      );
+      expect(failedBindings).toContainEqual(
+        expect.objectContaining({
+          placeholder: "[REDACTED:ACME_OAUTH]",
+          allowedHosts: ["api.acme.test"],
+          reason: "refresh_rejected",
+          authorizationLabel: "Acme Corp",
+        }),
+      );
+      // The authorization is now persisted as broken.
+      expect(getAuthorizationById(authId)?.status).toBe("refresh-failed");
+    } finally {
+      delete process.env.HEALTHY_CONFIG;
+    }
+  });
+
+  test("the sandbox fetch throws a typed error for a failed binding's host", async () => {
+    try {
+      // Observer stub so non-blocked requests pass through without real network I/O.
+      let observedCalls = 0;
+      globalThis.fetch = (async () => {
+        observedCalls++;
+        return Response.json({ ok: true });
+      }) as typeof fetch;
+
+      patchFetchWithCredentialBroker(
+        [],
+        [
+          {
+            placeholder: "[REDACTED:ACME_OAUTH]",
+            allowedHosts: ["api.acme.test"],
+            reason: "refresh_rejected",
+            authorizationLabel: "Acme Corp",
+          },
+        ],
+      );
+
+      // Targets the failed binding's host WITH its placeholder → typed throw.
+      expect(() =>
+        fetch("https://api.acme.test/v1/things", {
+          headers: { Authorization: "Bearer [REDACTED:ACME_OAUTH]" },
+        }),
+      ).toThrow(/OAuth authorization 'Acme Corp' is in refresh-failed state: refresh_rejected/);
+
+      // A request to the same host WITHOUT the placeholder is not blocked.
+      await fetch("https://api.acme.test/v1/public", { headers: { "x-foo": "bar" } });
+      // A different host is not blocked even with the placeholder present.
+      await fetch("https://example.com/leak", {
+        headers: { Authorization: "Bearer [REDACTED:ACME_OAUTH]" },
+      });
+      expect(observedCalls).toBe(2);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  test("two authorizations under one app refresh independently (per-authorization isolation)", async () => {
+    upsertOAuthApp("acme", appConfig("acme"));
+    const app = getOAuthApp("acme");
+    if (!app) throw new Error("app not created");
+
+    const broken = upsertAuthorization({
+      appId: app.id,
+      label: "default",
+      accessToken: "broken-access",
+      refreshToken: "broken-refresh",
+      expiresAt: new Date(Date.now() + 60 * 1000).toISOString(),
+      status: "active",
+    });
+    const healthy = upsertAuthorization({
+      appId: app.id,
+      label: "secondary",
+      accessToken: "healthy-access",
+      refreshToken: "healthy-refresh",
+      expiresAt: new Date(Date.now() + 60 * 1000).toISOString(),
+      status: "active",
+    });
+
+    mockTokenEndpoint(["broken-refresh"]);
+
+    const [brokenResult, healthyResult] = await Promise.allSettled([
+      ensureAuthorizationTokenOrThrow(broken.id),
+      ensureAuthorizationTokenOrThrow(healthy.id),
+    ]);
+
+    expect(brokenResult.status).toBe("rejected");
+    if (brokenResult.status === "rejected") {
+      expect(brokenResult.reason).toBeInstanceOf(OAuthRefreshError);
+    }
+    expect(healthyResult.status).toBe("fulfilled");
+
+    expect(getAuthorizationById(broken.id)?.status).toBe("refresh-failed");
+    const healed = getAuthorizationById(healthy.id);
+    expect(healed?.status).toBe("active");
+    expect(healed?.accessToken).toBe("healed-access-token");
+  });
+});

package/src/tests/oauth-refresh-sweep.test.ts

@@ -1,9 +1,20 @@
 import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, getDb, initDb } from "../be/db";
-import { getOAuthTokens, storeOAuthTokens, upsertOAuthApp } from "../be/db-queries/oauth";
+import {
+  getAuthorizationById,
+  getDefaultAuthorizationIdForProvider,
+  getOAuthTokens,
+  storeOAuthTokens,
+  upsertOAuthApp,
+} from "../be/db-queries/oauth";
 import { sweepOAuthTokenRefresh } from "../be/oauth-refresh-sweep";
 
+function authorizationStatus(provider: string): string | undefined {
+  const id = getDefaultAuthorizationIdForProvider(provider);
+  return id ? getAuthorizationById(id)?.status : undefined;
+}
+
 const TEST_DB_PATH = "./test-oauth-refresh-sweep.sqlite";
 
 const originalFetch = globalThis.fetch;
@@ -34,7 +45,11 @@ function seedTokens(
 function backdateTokenRow(provider: string, ageMs: number): void {
   const backdated = new Date(Date.now() - ageMs).toISOString();
   getDb()
-    .query("UPDATE oauth_tokens SET updatedAt = ? WHERE provider = ?")
+    .query(
+      `UPDATE oauth_authorizations SET updatedAt = ?
+       WHERE appId = (SELECT id FROM oauth_apps WHERE provider = ? AND mcpServerId IS NULL LIMIT 1)
+         AND label = 'default'`,
+    )
     .run(backdated, provider);
 }
 
@@ -73,7 +88,7 @@ beforeAll(() => {
 beforeEach(() => {
   globalThis.fetch = originalFetch;
   getDb().run("DELETE FROM oauth_refresh_locks");
-  getDb().run("DELETE FROM oauth_tokens");
+  getDb().run("DELETE FROM oauth_authorizations");
   getDb().run("DELETE FROM oauth_apps");
 });
 
@@ -112,6 +127,28 @@ describe("sweepOAuthTokenRefresh", () => {
     expect(getOAuthTokens("vendor_a")?.accessToken).toBe("vendor_a-old-access-token");
   });
 
+  test("skips a non-expiring (NULL expiry) row instead of proactively refreshing it", async () => {
+    upsertOAuthApp("vendor_a", appConfig("vendor_a"));
+    // GitHub-preset shape: a live token WITH a refresh token but NO expiry.
+    // NULL expiry means "does not expire" — the sweep must not treat it as
+    // expiring, must not refresh it proactively, and must never mark it
+    // refresh-failed.
+    storeOAuthTokens("vendor_a", {
+      accessToken: "vendor_a-old-access-token",
+      refreshToken: "vendor_a-refresh-token",
+      expiresAt: null,
+      scope: "read,write",
+    });
+
+    const captured = mockTokenEndpoint();
+    const result = await sweepOAuthTokenRefresh();
+
+    expect(result).toEqual({ checked: 1, refreshed: 0, skipped: 1, failed: [] });
+    expect(captured).toHaveLength(0);
+    expect(authorizationStatus("vendor_a")).toBe("active");
+    expect(getOAuthTokens("vendor_a")?.accessToken).toBe("vendor_a-old-access-token");
+  });
+
   test("skips fresh rows that are neither expiring nor stale", async () => {
     upsertOAuthApp("vendor_a", appConfig("vendor_a"));
     seedTokens("vendor_a", { expiresInMs: 24 * 60 * 60 * 1000 }); // expires in 24h, just updated
@@ -156,5 +193,48 @@ describe("sweepOAuthTokenRefresh", () => {
     ]);
     expect(getOAuthTokens("a_broken")?.accessToken).toBe("a_broken-old-access-token");
     expect(getOAuthTokens("b_healthy")?.accessToken).toBe("new-access-token");
+    // A failing refresh persists refresh-failed on the authorization; the
+    // healthy one stays active.
+    expect(authorizationStatus("a_broken")).toBe("refresh-failed");
+    expect(authorizationStatus("b_healthy")).toBe("active");
+  });
+
+  test("a refresh-failed authorization stays in the sweep and heals on the next pass", async () => {
+    upsertOAuthApp("vendor_a", appConfig("vendor_a"));
+    // Not expiring on its own — the only reason it should be swept is the
+    // persisted refresh-failed status.
+    seedTokens("vendor_a", { expiresInMs: 24 * 60 * 60 * 1000 });
+
+    // Pass 1: provider is down → status flips to refresh-failed.
+    mockTokenEndpoint(["https://oauth.vendor_a.test/token"]);
+    // Force a first failure via a near-expiry token so the sweep attempts it.
+    getDb()
+      .query(
+        `UPDATE oauth_authorizations SET expiresAt = ?
+         WHERE appId = (SELECT id FROM oauth_apps WHERE provider = 'vendor_a' AND mcpServerId IS NULL LIMIT 1)
+           AND label = 'default'`,
+      )
+      .run(new Date(Date.now() + 60 * 1000).toISOString());
+    const first = await sweepOAuthTokenRefresh();
+    expect(first.failed).toHaveLength(1);
+    expect(authorizationStatus("vendor_a")).toBe("refresh-failed");
+
+    // Bump expiry far into the future so the ONLY reason to sweep is the
+    // refresh-failed status, proving failed rows are retried each pass.
+    getDb()
+      .query(
+        `UPDATE oauth_authorizations SET expiresAt = ?
+         WHERE appId = (SELECT id FROM oauth_apps WHERE provider = 'vendor_a' AND mcpServerId IS NULL LIMIT 1)
+           AND label = 'default'`,
+      )
+      .run(new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString());
+
+    // Pass 2: provider recovers → refresh succeeds → status back to active.
+    mockTokenEndpoint();
+    const second = await sweepOAuthTokenRefresh();
+    expect(second.refreshed).toBe(1);
+    expect(second.failed).toHaveLength(0);
+    expect(authorizationStatus("vendor_a")).toBe("active");
+    expect(getOAuthTokens("vendor_a")?.accessToken).toBe("new-access-token");
   });
 });

package/src/tests/oauth-wrapper.test.ts

@@ -1,12 +1,10 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, initDb } from "../be/db";
-import { upsertOAuthApp } from "../be/db-queries/oauth";
+import { consumeOAuthPending, upsertOAuthApp } from "../be/db-queries/oauth";
 import {
-  _clearPendingStates,
-  _getPendingState,
   buildAuthorizationUrl,
-  exchangeCode,
+  exchangeAuthorizationCode,
   type OAuthProviderConfig,
 } from "../oauth/wrapper";
 
@@ -18,14 +16,14 @@ const testConfig: OAuthProviderConfig = {
   clientSecret: "test-client-secret",
   authorizeUrl: "https://example.com/oauth/authorize",
   tokenUrl: "https://example.com/oauth/token",
-  redirectUri: "http://localhost:3013/callback",
+  redirectUri: "http://localhost:3013/api/oauth/callback",
   scopes: ["read", "write"],
   extraParams: { actor: "app" },
 };
 
 beforeAll(() => {
   initDb(TEST_DB_PATH);
-  // Create an oauth_app row so token storage works (FK constraint)
+  // Create an oauth_app row so pending persistence works (FK constraint on appId).
   upsertOAuthApp("test-provider", {
     clientId: testConfig.clientId,
     clientSecret: testConfig.clientSecret,
@@ -36,10 +34,6 @@ beforeAll(() => {
   });
 });
 
-beforeEach(() => {
-  _clearPendingStates();
-});
-
 afterAll(async () => {
   closeDb();
   await unlink(TEST_DB_PATH).catch(() => {});
@@ -58,7 +52,7 @@ describe("buildAuthorizationUrl", () => {
     const url = new URL(result.url);
     expect(url.origin + url.pathname).toBe("https://example.com/oauth/authorize");
     expect(url.searchParams.get("client_id")).toBe("test-client-id");
-    expect(url.searchParams.get("redirect_uri")).toBe("http://localhost:3013/callback");
+    expect(url.searchParams.get("redirect_uri")).toBe("http://localhost:3013/api/oauth/callback");
     expect(url.searchParams.get("response_type")).toBe("code");
     expect(url.searchParams.get("scope")).toBe("read,write");
     expect(url.searchParams.get("state")).toBe(result.state);
@@ -72,14 +66,21 @@ describe("buildAuthorizationUrl", () => {
     expect(url.searchParams.get("actor")).toBe("app");
   });
 
-  test("stores pending state with code verifier", async () => {
+  test("persists a DB pending row (default label, generic flow) with the code verifier", async () => {
     const result = await buildAuthorizationUrl(testConfig);
-    const pending = _getPendingState(result.state);
+    const pending = consumeOAuthPending(result.state);
 
     expect(pending).toBeTruthy();
     expect(pending!.codeVerifier).toBe(result.codeVerifier);
-    expect(pending!.config.provider).toBe("test-provider");
-    expect(pending!.createdAt).toBeGreaterThan(0);
+    expect(pending!.label).toBe("default");
+    expect(pending!.flow).toBe("generic");
+    expect(pending!.redirectUri).toBe(testConfig.redirectUri);
+  });
+
+  test("honors an explicit label option", async () => {
+    const result = await buildAuthorizationUrl(testConfig, { label: "support" });
+    const pending = consumeOAuthPending(result.state);
+    expect(pending!.label).toBe("support");
   });
 
   test("generates unique state for each call", async () => {
@@ -90,60 +91,81 @@ describe("buildAuthorizationUrl", () => {
     expect(result1.codeVerifier).not.toBe(result2.codeVerifier);
   });
 
-  test("works without extra params", async () => {
-    const configNoExtras: OAuthProviderConfig = {
-      ...testConfig,
-      extraParams: undefined,
-    };
+  test("throws when the provider has no configured app", async () => {
+    await expect(
+      buildAuthorizationUrl({ ...testConfig, provider: "no-such-provider" }),
+    ).rejects.toThrow("is not configured");
+  });
 
+  test("works without extra params", async () => {
+    const configNoExtras: OAuthProviderConfig = { ...testConfig, extraParams: undefined };
     const result = await buildAuthorizationUrl(configNoExtras);
     const url = new URL(result.url);
     expect(url.searchParams.get("actor")).toBeNull();
   });
 });
 
-describe("exchangeCode", () => {
-  test("rejects invalid state", async () => {
-    await expect(exchangeCode(testConfig, "some-code", "invalid-state")).rejects.toThrow(
-      "Invalid or expired OAuth state",
+describe("exchangeAuthorizationCode", () => {
+  test("exchanges a code for tokens (pure — no persistence)", async () => {
+    const fetchSpy = spyOn(globalThis, "fetch").mockResolvedValueOnce(
+      Response.json({
+        access_token: "atk",
+        token_type: "Bearer",
+        expires_in: 3600,
+        refresh_token: "rtk",
+        scope: "read write",
+      }),
     );
-  });
-
-  test("rejects already-consumed state", async () => {
-    const result = await buildAuthorizationUrl(testConfig);
-
-    // Mock fetch to fail immediately (avoids real network call to example.com)
-    const fetchSpy = spyOn(globalThis, "fetch").mockRejectedValueOnce(new Error("Network error"));
     try {
-      await exchangeCode(testConfig, "some-code", result.state);
-    } catch {
-      // Expected: fetch fails, but state is consumed
+      const tokens = await exchangeAuthorizationCode(testConfig, {
+        code: "the-code",
+        codeVerifier: "the-verifier",
+        redirectUri: testConfig.redirectUri,
+      });
+      expect(tokens.accessToken).toBe("atk");
+      expect(tokens.refreshToken).toBe("rtk");
+      expect(tokens.expiresIn).toBe(3600);
+      expect(tokens.scope).toBe("read write");
+      const [, init] = fetchSpy.mock.calls[0] as [string, RequestInit];
+      expect(String(init.body)).toContain("grant_type=authorization_code");
+      expect(String(init.body)).toContain("code=the-code");
     } finally {
       fetchSpy.mockRestore();
     }
+  });
 
-    // Second attempt with the same state should fail with "Invalid or expired"
-    await expect(exchangeCode(testConfig, "some-code", result.state)).rejects.toThrow(
-      "Invalid or expired OAuth state",
+  test("throws on a non-OK token response", async () => {
+    const fetchSpy = spyOn(globalThis, "fetch").mockResolvedValueOnce(
+      new Response("nope", { status: 400 }),
     );
+    try {
+      await expect(
+        exchangeAuthorizationCode(testConfig, {
+          code: "x",
+          codeVerifier: "y",
+          redirectUri: testConfig.redirectUri,
+        }),
+      ).rejects.toThrow("Token exchange failed");
+    } finally {
+      fetchSpy.mockRestore();
+    }
   });
-});
-
-describe("state TTL cleanup", () => {
-  test("expired states are cleaned up on next buildAuthorizationUrl call", async () => {
-    // Manually insert an "expired" entry by backdating createdAt
-    const result = await buildAuthorizationUrl(testConfig);
-    const pending = _getPendingState(result.state);
-    expect(pending).toBeTruthy();
-
-    // Backdate to 11 minutes ago (past the 10-minute TTL)
-    pending!.createdAt = Date.now() - 11 * 60 * 1000;
 
-    // Building a new URL triggers cleanup
-    await buildAuthorizationUrl(testConfig);
-
-    // The expired state should be gone
-    const expired = _getPendingState(result.state);
-    expect(expired).toBeUndefined();
+  test("sends Accept: application/json so form-encoding providers (GitHub) return JSON", async () => {
+    const fetchSpy = spyOn(globalThis, "fetch").mockResolvedValueOnce(
+      Response.json({ access_token: "atk", token_type: "Bearer" }),
+    );
+    try {
+      await exchangeAuthorizationCode(testConfig, {
+        code: "the-code",
+        codeVerifier: "the-verifier",
+        redirectUri: testConfig.redirectUri,
+      });
+      const [, init] = fetchSpy.mock.calls[0] as [string, RequestInit];
+      const headers = init.headers as Record<string, string>;
+      expect(headers.Accept).toBe("application/json");
+    } finally {
+      fetchSpy.mockRestore();
+    }
   });
 });

package/src/tests/prompt-template-session.test.ts

@@ -60,12 +60,13 @@ describe("Session templates — registration", () => {
     await ensureTemplatesRegistered();
   });
 
-  test("all 16 system templates are registered", () => {
+  test("all 17 system templates are registered", () => {
     const systemTemplates = [
       "system.agent.role",
       "system.agent.register",
       "system.agent.lead",
       "system.agent.slack",
+      "system.agent.messaging",
       "system.agent.worker",
       "system.agent.worker.slack",
       "system.agent.filesystem",
@@ -98,13 +99,13 @@ describe("Session templates — registration", () => {
     }
   });
 
-  test("total of 24 session/system templates registered", () => {
+  test("total of 25 session/system templates registered", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
-    // 24 = the original 19 + `system.session.worker.pi` + `system.agent.seed_scripts`
+    // 25 = the original 19 + `system.session.worker.pi` + `system.agent.seed_scripts`
     // + `system.agent.script_rubric` + `system.agent.scripts_only_mode`
-    // + `system.agent.scripts_only_mode.slack`.
-    expect(sessionSystem.length).toBe(24);
+    // + `system.agent.scripts_only_mode.slack` + `system.agent.messaging`.
+    expect(sessionSystem.length).toBe(25);
   });
 });