@desplega.ai/agent-swarm 2.5.3 → 2.6.0

package/src/tests/onboarding.test.ts

@@ -362,7 +362,14 @@ describe("onboarding state", () => {
       signals: { providers: Array<Record<string, unknown>> };
     };
     expect(body.signals.providers).toEqual([
-      { provider: "claude", state: "verified", workers: 2, verifiedWorkers: 2 },
+      {
+        provider: "claude",
+        state: "verified",
+        workers: 2,
+        verifiedWorkers: 2,
+        error: null,
+        warning: null,
+      },
     ]);
     expect(body.state.steps.ai).toMatchObject({
       status: "done",
@@ -370,6 +377,57 @@ describe("onboarding state", () => {
     });
   });
 
+  test("GET carries the latest live test error and the pool warning", async () => {
+    const report = (liveTest: {
+      ok: boolean;
+      error: string | null;
+      latency_ms: number;
+      testedAt: number;
+      warning?: string;
+    }) => ({
+      ready: true,
+      missing: [],
+      satisfiedBy: "env" as const,
+      hint: null,
+      liveTest,
+      reportedAt: Date.now(),
+      reportKind: "boot" as const,
+    });
+    const failing = await createAgent({ name: "codex-worker", isLead: false, status: "idle" });
+    await setAgentHarnessProvider(failing.id, "codex");
+    await updateAgentCredStatus(
+      failing.id,
+      report({ ok: false, error: "HTTP 401: bad key", latency_ms: 5, testedAt: Date.now() }),
+    );
+    const warned = await createAgent({ name: "pi-worker", isLead: false, status: "idle" });
+    await setAgentHarnessProvider(warned.id, "pi");
+    await updateAgentCredStatus(
+      warned.id,
+      report({
+        ok: true,
+        error: null,
+        latency_ms: 5,
+        testedAt: Date.now(),
+        warning: "1 of 2 keys failed: key ending abcde (HTTP 401).",
+      }),
+    );
+
+    const body = (await (await request("/api/onboarding")).json()) as {
+      signals: { providers: Array<Record<string, unknown>> };
+    };
+    const byProvider = Object.fromEntries(body.signals.providers.map((p) => [p.provider, p]));
+    expect(byProvider.codex).toMatchObject({
+      state: "configured",
+      error: "HTTP 401: bad key",
+      warning: null,
+    });
+    expect(byProvider.pi).toMatchObject({
+      state: "verified",
+      error: null,
+      warning: "1 of 2 keys failed: key ending abcde (HTTP 401).",
+    });
+  });
+
   test("GET derives integrations from environment configuration", async () => {
     process.env.GITHUB_TOKEN = "example-github-token";
     const body = (await (await request("/api/onboarding")).json()) as {
@@ -853,6 +911,55 @@ describe("onboarding memory probe", () => {
     expect((await getState()).steps.memory.status).toBe("todo");
   });
 
+  test("probes and saves the first member of a reused OpenAI pool", async () => {
+    const originalFetch = globalThis.fetch;
+    let authorization: string | null = null;
+    process.env.OPENAI_API_KEY = "example-first, example-second";
+    globalThis.fetch = (async (input, init) => {
+      const req = new Request(input, init);
+      if (new URL(req.url).hostname !== "api.openai.com") return originalFetch(input, init);
+      authorization = req.headers.get("authorization");
+      return embeddingResponse(512);
+    }) as typeof fetch;
+    try {
+      const response = await request("/api/onboarding/memory", {
+        method: "POST",
+        body: { preset: "openai", reuseKey: "OPENAI_API_KEY" },
+      });
+      expect(await response.json()).toMatchObject({ ok: true, dimensions: 512 });
+      expect(authorization).toBe("Bearer example-first");
+      const configs = await getSwarmConfigs({ scope: "global", key: "EMBEDDING_API_KEY" });
+      expect(configs[0]?.value).toBe("example-first");
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
+  for (const keyVar of ["EMBEDDING_API_KEY", "OPENAI_API_KEY"]) {
+    test(`existing memory probes the first member of ${keyVar}`, async () => {
+      const originalFetch = globalThis.fetch;
+      let authorization: string | null = null;
+      process.env[keyVar] = "example-first, example-second";
+      process.env.EMBEDDING_API_BASE_URL = "https://api.openai.com/v1";
+      globalThis.fetch = (async (input, init) => {
+        const req = new Request(input, init);
+        if (new URL(req.url).hostname !== "api.openai.com") return originalFetch(input, init);
+        authorization = req.headers.get("authorization");
+        return embeddingResponse(512);
+      }) as typeof fetch;
+      try {
+        const response = await request("/api/onboarding/memory", {
+          method: "POST",
+          body: { preset: "existing" },
+        });
+        expect(await response.json()).toMatchObject({ ok: true, dimensions: 512 });
+        expect(authorization).toBe("Bearer example-first");
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    });
+  }
+
   test("does not send a reused OpenAI key to another host", async () => {
     let hits = 0;
     const fake = startEmbeddingServer(() => {

package/src/tests/openai-embedding-credentials.test.ts

@@ -0,0 +1,35 @@
+import { expect, test } from "bun:test";
+import { OpenAIEmbeddingProvider } from "../be/memory/providers/openai-embedding";
+
+for (const source of ["config", "EMBEDDING_API_KEY", "OPENAI_API_KEY"] as const) {
+  test(`embedding selects one key from ${source}`, async () => {
+    const originalFetch = globalThis.fetch;
+    const saved = {
+      EMBEDDING_API_KEY: process.env.EMBEDDING_API_KEY,
+      OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+    };
+    delete process.env.EMBEDDING_API_KEY;
+    delete process.env.OPENAI_API_KEY;
+    const pool = "example-first, example-second";
+    if (source !== "config") process.env[source] = pool;
+    let authorization: string | null = null;
+    globalThis.fetch = (async (input, init) => {
+      authorization = new Request(input, init).headers.get("authorization");
+      return Response.json({ data: [{ embedding: [0.5] }] });
+    }) as typeof fetch;
+    try {
+      const provider = new OpenAIEmbeddingProvider({
+        dimensions: 1,
+        ...(source === "config" ? { apiKey: pool } : {}),
+      });
+      expect(await provider.embed("test input")).toEqual(new Float32Array([0.5]));
+      expect(["Bearer example-first", "Bearer example-second"]).toContain(authorization);
+    } finally {
+      globalThis.fetch = originalFetch;
+      for (const [key, value] of Object.entries(saved)) {
+        if (value === undefined) delete process.env[key];
+        else process.env[key] = value;
+      }
+    }
+  });
+}

package/src/tests/openapi-route-headers.test.ts

@@ -75,6 +75,8 @@ describe("runtime identity header in OpenAPI", () => {
       "GET /api/poll",
       "POST /api/mcp-bridge",
       "POST /api/scripts/run",
+      "POST /api/workflows",
+      "POST /api/workflows/{id}/trigger",
       "POST /close",
       "POST /ping",
       "PUT /api/agents/{id}/credential-status",

package/src/tests/opencode-adapter.test.ts

@@ -10,6 +10,7 @@
 import { afterAll, afterEach, beforeAll, describe, expect, spyOn, test } from "bun:test";
 import type { OpenCodeEvent } from "@opencode/sdk";
 import { normalizeSessionLogs, type SessionLogRecord } from "../../apps/ui/src/logs-parser";
+import { renderContextBoundNote } from "../prompts/context-bound-note";
 import {
   _setOpencodeSdkLoaderForTests,
   _setOpencodeSessionHooksForTests,
@@ -22,6 +23,7 @@ import {
 import { createSkillInvokeTracker, type SkillInvoke } from "../providers/skill-invoke";
 import type { ProviderEvent, ProviderSessionConfig } from "../providers/types";
 import { clearVolatileSecretsForTesting } from "../utils/secret-scrubber";
+import { HELD_NOTE_TEXT, holdTemplateRender } from "./fixtures/held-template-render";
 
 const SESSION_ID = "ses_test";
 
@@ -68,6 +70,7 @@ type FakeHostOptions = {
   tools?: string[];
   /** Model responses handed to the plugin's `http.response` hook at startup. */
   responses?: Response[];
+  syntheticError?: Error;
 };
 
 /**
@@ -85,6 +88,7 @@ function makeFakeHost(events: OpenCodeEvent[], opts: FakeHostOptions = {}) {
     createOptions: undefined as unknown as Record<string, unknown>,
     created: [] as unknown[],
     prompts: [] as Array<Record<string, unknown>>,
+    synthetics: [] as Array<Record<string, unknown>>,
     interrupts: [] as unknown[],
     closeCalls: 0,
     mcpListCalls: 0,
@@ -116,6 +120,11 @@ function makeFakeHost(events: OpenCodeEvent[], opts: FakeHostOptions = {}) {
         host.interrupts.push(input);
         return {};
       },
+      synthetic: async (input: Record<string, unknown>) => {
+        host.synthetics.push(input);
+        if (opts.syntheticError) throw opts.syntheticError;
+        return {};
+      },
     },
     events: {
       async *subscribe() {
@@ -815,6 +824,131 @@ describe("OpencodeSession — abort and steering", () => {
   });
 });
 
+describe("OpencodeSession — context-bound note", () => {
+  const boundConfig = (threshold: string) =>
+    testConfig({ env: { CONTEXT_BOUND_NOTE_TOKENS: threshold } });
+  const step = (sessionID: string, input: number, read = 0, write = 0) =>
+    ev("session.step.ended", { sessionID, tokens: tokens(input, 10, read, write) });
+
+  test("steers the note once at the threshold, not again on a larger step", async () => {
+    const { session, host } = await startSession([], boundConfig("1000"));
+    // 600 input + 300 cache read + 100 cache write = 1,000 (output does not count).
+    session.handleOpencodeEvent(step(SESSION_ID, 500, 300, 100));
+    session.handleOpencodeEvent(step(SESSION_ID, 600, 300, 100));
+    session.handleOpencodeEvent(step(SESSION_ID, 5_000));
+    await waitFor(() => host.synthetics.length > 0);
+    await Bun.sleep(20);
+    expect(host.synthetics).toEqual([
+      {
+        sessionID: SESSION_ID,
+        text: await renderContextBoundNote(1_000, "openrouter/google/gemini-3-flash-preview"),
+        delivery: "steer",
+        resume: false,
+      },
+    ]);
+    expect(host.synthetics[0]?.text).toContain("1,000");
+    session.handleOpencodeEvent(succeeded);
+    expect((await session.waitForCompletion()).isError).toBe(false);
+  });
+
+  test("the note shows the window share for a known model and omits it for an unknown one", async () => {
+    const noteFor = async (model: string) => {
+      const { session, host } = await startSession(
+        [],
+        testConfig({ model, env: { CONTEXT_BOUND_NOTE_TOKENS: "1000" } }),
+      );
+      session.handleOpencodeEvent(step(SESSION_ID, 524_288));
+      await waitFor(() => host.synthetics.length > 0);
+      session.handleOpencodeEvent(succeeded);
+      await session.waitForCompletion();
+      return host.synthetics[0]?.text;
+    };
+    const rest =
+      "Keep this task bounded: finish the current step, store-progress, and complete or defer instead of starting new exploration.";
+    expect(await noteFor("openrouter/google/gemini-3-flash-preview")).toBe(
+      `Context is 524,288 tokens (50% of the 1,048,576-token window). ${rest}`,
+    );
+    expect(await noteFor("openrouter/made-up/model")).toBe(`Context is 524,288 tokens. ${rest}`);
+  });
+
+  test("off when CONTEXT_BOUND_NOTE_TOKENS is unset", async () => {
+    const { session, host } = await startSession([]);
+    session.handleOpencodeEvent(step(SESSION_ID, 900_000));
+    await Bun.sleep(20);
+    expect(host.synthetics).toEqual([]);
+    session.handleOpencodeEvent(succeeded);
+    await session.waitForCompletion();
+  });
+
+  test("no-op below the threshold and for a child session's steps", async () => {
+    const { session, host } = await startSession([], boundConfig("1000"));
+    session.handleOpencodeEvent(step(SESSION_ID, 999));
+    session.handleOpencodeEvent(step("ses_child", 50_000));
+    await Bun.sleep(20);
+    expect(host.synthetics).toEqual([]);
+    session.handleOpencodeEvent(succeeded);
+    await session.waitForCompletion();
+  });
+
+  test("off at 0", async () => {
+    const { session, host } = await startSession([], boundConfig("0"));
+    session.handleOpencodeEvent(step(SESSION_ID, 250_000));
+    await Bun.sleep(20);
+    expect(host.synthetics).toEqual([]);
+    session.handleOpencodeEvent(succeeded);
+    await session.waitForCompletion();
+  });
+
+  test("fails open on corrupt step tokens", async () => {
+    const { session, host } = await startSession([], boundConfig("1000"));
+    session.handleOpencodeEvent(
+      ev("session.step.ended", {
+        sessionID: SESSION_ID,
+        tokens: { input: "lots", output: 1, reasoning: 0, cache: { read: null, write: {} } },
+      }),
+    );
+    await Bun.sleep(20);
+    expect(host.synthetics).toEqual([]);
+    session.handleOpencodeEvent(succeeded);
+    expect((await session.waitForCompletion()).isError).toBe(false);
+  });
+
+  test("a rejected steer still lets the session complete", async () => {
+    const { session, host } = await startSession([], boundConfig("1000"), {
+      syntheticError: new Error("synthetic refused"),
+    });
+    session.handleOpencodeEvent(step(SESSION_ID, 5_000));
+    await waitFor(() => host.synthetics.length > 0);
+    session.handleOpencodeEvent(succeeded);
+    expect((await session.waitForCompletion()).isError).toBe(false);
+  });
+
+  test("a note rendered after the session completed is dropped", async () => {
+    const lateSynthetics = async (releaseInSession: boolean) => {
+      const held = holdTemplateRender();
+      try {
+        const { session, host } = await startSession([], boundConfig("1000"));
+        session.handleOpencodeEvent(step(SESSION_ID, 5_000));
+        await held.requested;
+        if (releaseInSession) {
+          held.release();
+          await waitFor(() => host.synthetics.length > 0);
+        }
+        session.handleOpencodeEvent(succeeded);
+        expect((await session.waitForCompletion()).isError).toBe(false);
+        held.release();
+        await Bun.sleep(50);
+        return host.synthetics.map((s) => s.text);
+      } finally {
+        held.stop();
+      }
+    };
+    expect(await lateSynthetics(false)).toEqual([]);
+    // Control: ready while the session runs.
+    expect(await lateSynthetics(true)).toEqual([HELD_NOTE_TEXT]);
+  });
+});
+
 describe("OpenRouter attribution config", () => {
   test("overrides harness attribution while preserving custom headers and options", () => {
     const config = {

package/src/tests/openrouter-attribution-call-sites.test.ts

@@ -164,12 +164,12 @@ describe("workflow raw-llm and validate nodes", () => {
   });
 });
 
-describe("OpenRouter credential check (GET /models)", () => {
+describe("OpenRouter credential check (GET /key)", () => {
   for (const c of CASES) {
     test(`${c.name}`, async () => {
       setEnv(c.env);
       await validateProviderCredentials("grok", { OPENROUTER_API_KEY: "example-or-key" });
-      expect(requests[0]?.url.endsWith("/models")).toBe(true);
+      expect(requests[0]?.url.endsWith("/key")).toBe(true);
       expectAttribution(requests[0]?.headers, c.attributed);
     });
   }

package/src/tests/org-website.test.ts

@@ -5,6 +5,8 @@ import {
   COMPANY_ACQUISITION_SOURCES,
   COMPANY_TEAM_SIZES,
   COMPANY_USE_CASES,
+  reportedUseCase,
+  reportedUserFunction,
 } from "../utils/company-profile";
 import {
   isFilledOrgLogoUrl,
@@ -157,6 +159,40 @@ describe("company profile config guards", () => {
   }
 });
 
+describe("profile values the telemetry catalog does not list yet", () => {
+  const input = {
+    orgId: "org_0123456789abcdef",
+    installationId: "install_0123456789abcdef",
+    isCloud: false,
+    isE2b: false,
+    swarmVersion: "1.0.0",
+    actor: { userId: "user-1" },
+  };
+
+  test("the config guards accept them", () => {
+    for (const value of ["content", "research", "seo", "admin"]) {
+      expect(validateConfigValue("SWARM_ORG_USE_CASE", value)).toBeNull();
+    }
+  });
+
+  test("stay out of the telemetry context, as if unset", () => {
+    for (const useCase of ["content", "research", "seo", "admin"]) {
+      expect(reportedUseCase(useCase)).toBeUndefined();
+      expect(buildContext({ ...input, useCase })).not.toHaveProperty("use_case");
+    }
+    for (const userFunction of ["marketing", "sales", "research"]) {
+      expect(reportedUserFunction(userFunction)).toBeUndefined();
+      expect(buildContext({ ...input, userFunction })).not.toHaveProperty("user_function");
+    }
+  });
+
+  test("the catalog values still report", () => {
+    const context = buildContext({ ...input, useCase: "docs", userFunction: "founder" });
+    expect(context.use_case).toBe("docs");
+    expect(context.user_function).toBe("founder");
+  });
+});
+
 describe("org_website in the telemetry context", () => {
   const input = {
     orgId: "org_0123456789abcdef",

package/src/tests/pi-mono-adapter.test.ts

@@ -12,6 +12,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { OPENAI_COMPATIBLE_PROVIDERS } from "@desplega/model-catalog";
 import * as piCodingAgent from "@earendil-works/pi-coding-agent";
+import { renderContextBoundNote } from "../prompts/context-bound-note";
 import { configureHttpResolver, resetHttpResolver } from "../prompts/resolver";
 import {
   checkPiMonoCredentials,
@@ -24,6 +25,7 @@ import {
   writeSessionModelsJson,
 } from "../providers/pi-mono-adapter";
 import type { ProviderSessionConfig } from "../providers/types";
+import { HELD_NOTE_TEXT, holdTemplateRender } from "./fixtures/held-template-render";
 
 describe("PiMonoAdapter", () => {
   test("name is 'pi'", () => {
@@ -1187,6 +1189,8 @@ function makeMockAgentSession(opts: {
   steerCalls?: string[];
   followUpCalls?: string[];
   steeringError?: string;
+  /** Awaited after each call's events, as a real turn keeps running its tools. */
+  afterEvents?: () => Promise<unknown>;
 }): AgentSession {
   const listeners: Array<(event: AgentSessionEvent) => void> = [];
   const scripts = opts.turns ?? [opts.events ?? []];
@@ -1210,6 +1214,7 @@ function makeMockAgentSession(opts: {
       for (const event of scripts[call] ?? []) {
         for (const l of listeners) l(event);
       }
+      await opts.afterEvents?.();
       if (opts.throwError) throw new Error(opts.throwError);
     },
     getContextUsage: () => null,
@@ -1754,3 +1759,103 @@ describe("classifyAwsSdkError — all 4 categories (quick summary)", () => {
     }
   });
 });
+
+describe("PiMonoSession context-bound note", () => {
+  /** An assistant `message_end` with this request usage; a tool call unless `final`. */
+  function assistantTurn(usage: unknown, final = false): AgentSessionEvent {
+    return {
+      type: "message_end",
+      message: {
+        role: "assistant",
+        content: final
+          ? [{ type: "text", text: "Done" }]
+          : [{ type: "toolCall", id: "call-1", name: "bash", arguments: {} }],
+        stopReason: final ? "stop" : "toolUse",
+        usage,
+      },
+    } as unknown as AgentSessionEvent;
+  }
+
+  const usage = (input: number) => ({ input, cacheRead: 300, cacheWrite: 200, output: 50 });
+
+  async function steersFor(
+    threshold: string,
+    events: AgentSessionEvent[],
+    afterEvents: () => Promise<unknown> = () => Bun.sleep(50),
+    model?: string,
+  ): Promise<string[]> {
+    const steerCalls: string[] = [];
+    const session = new PiMonoSession(
+      makeMockAgentSession({ events, steerCalls, afterEvents }),
+      {
+        ...makeSessionConfig(join(tmpLogDir, `bound-note-${crypto.randomUUID()}.log`)),
+        env: { CONTEXT_BOUND_NOTE_TOKENS: threshold },
+        ...(model ? { model } : {}),
+      },
+      false,
+    );
+    await session.waitForCompletion();
+    return steerCalls;
+  }
+
+  test("steers the note once when a tool-call request reaches the threshold", async () => {
+    const steers = await steersFor("1000", [
+      assistantTurn(usage(400)),
+      assistantTurn(usage(500)),
+      assistantTurn(usage(900)),
+      assistantTurn(usage(1500), true),
+    ]);
+    // 500 + 300 + 200 reaches 1000; the larger later request does not steer again.
+    expect(steers).toEqual([await renderContextBoundNote(1000)]);
+  });
+
+  test("the note shows the window share for a known model and omits it for an unknown one", async () => {
+    const events = () => [assistantTurn(usage(209_500)), assistantTurn(usage(400), true)];
+    const rest =
+      "Keep this task bounded: finish the current step, store-progress, and complete or defer instead of starting new exploration.";
+    expect(await steersFor("200000", events(), undefined, "anthropic/claude-sonnet-4-6")).toEqual([
+      `Context is 210,000 tokens (21% of the 1,000,000-token window). ${rest}`,
+    ]);
+    expect(await steersFor("200000", events(), undefined, "made-up/model")).toEqual([
+      `Context is 210,000 tokens. ${rest}`,
+    ]);
+  });
+
+  test("no-op below the threshold and when disabled at 0", async () => {
+    const events = [assistantTurn(usage(400)), assistantTurn(usage(400), true)];
+    expect(await steersFor("1000", events)).toEqual([]);
+    expect(await steersFor("0", events)).toEqual([]);
+  });
+
+  test("fails open on missing or corrupt usage", async () => {
+    const events = [
+      assistantTurn(undefined),
+      assistantTurn({ input: "lots", cacheRead: {}, cacheWrite: null }),
+      assistantTurn(undefined, true),
+    ];
+    expect(await steersFor("1", events)).toEqual([]);
+  });
+
+  test("never steers after the final reply, which would start another turn", async () => {
+    expect(await steersFor("1", [assistantTurn(usage(5000), true)])).toEqual([]);
+  });
+
+  test("a note rendered after its tool turn ended is dropped", async () => {
+    const turnEnd = { type: "turn_end" } as unknown as AgentSessionEvent;
+    const lateSteers = async (events: AgentSessionEvent[]) => {
+      const held = holdTemplateRender();
+      try {
+        return await steersFor("1", events, async () => {
+          held.release();
+          await Bun.sleep(50);
+        });
+      } finally {
+        held.stop();
+      }
+    };
+    // Pi already read steering for that turn; the next reply could be the final one.
+    expect(await lateSteers([assistantTurn(usage(5000)), turnEnd])).toEqual([]);
+    // Control: ready while the tool turn is still running.
+    expect(await lateSteers([assistantTurn(usage(5000))])).toEqual([HELD_NOTE_TEXT]);
+  });
+});

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

@@ -22,6 +22,7 @@ const SYSTEM_TEMPLATES = [
   "system.agent.communication",
   "system.agent.communication.remote",
   "system.agent.compaction.goal_reminder",
+  "system.agent.context.bound_note",
   "system.agent.cursor.first_message",
   "system.agent.lead",
   "system.agent.memory",
@@ -117,11 +118,11 @@ describe("Session templates: registration", () => {
     expect(sessionSystemEventTypes("session")).toEqual([...SESSION_TEMPLATES].sort());
   });
 
-  test("registers 31 system and session templates in total", () => {
+  test("registers 32 system and session templates in total", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
-    // 26 system blocks + 5 session composites.
-    expect(sessionSystem.length).toBe(31);
+    // 27 system blocks + 5 session composites.
+    expect(sessionSystem.length).toBe(32);
   });
 
   test("drops the v1 blocks that prompt v2 deleted", () => {