@desplega.ai/agent-swarm 2.7.0 → 2.7.1

package/src/tests/memory-embedding-input-cap.test.ts

@@ -1,4 +1,13 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
 import {
   MAX_EMBEDDING_INPUT_CHARS,
   OpenAIEmbeddingProvider,
@@ -112,3 +121,115 @@ describe("embedding input cap", () => {
     expect(requests).toEqual([["one", "three"]]);
   });
 });
+
+// A TEI server started with the default --max-client-batch-size 32. TEI answers
+// a bigger request with a 422 and this body. TEI also answers 422 for other
+// validation errors, such as a `dimensions` value the model cannot serve.
+const TEI_MAX_BATCH = 32;
+let teiServer: ReturnType<typeof Bun.serve>;
+let teiBaseUrl: string;
+let teiOtherError: string | null = null;
+let teiPayloadTooLarge = false;
+const teiRequests: string[][] = [];
+
+function teiProvider(): OpenAIEmbeddingProvider {
+  return new OpenAIEmbeddingProvider({
+    apiKey: "local-tei",
+    model: "nomic-ai/nomic-embed-text-v1.5",
+    dimensions: 4,
+  });
+}
+
+describe("batch-size rejections", () => {
+  let savedBaseUrl: string | undefined;
+
+  beforeAll(() => {
+    teiServer = Bun.serve({
+      hostname: "127.0.0.1",
+      port: 0,
+      async fetch(req) {
+        const body = (await req.json()) as { input: string | string[] };
+        const inputs = Array.isArray(body.input) ? body.input : [body.input];
+        teiRequests.push(inputs);
+        if (teiPayloadTooLarge && inputs.length > 1) {
+          return new Response("payload too large", { status: 413 });
+        }
+        if (teiOtherError) {
+          return Response.json({ error: teiOtherError, error_type: "Validation" }, { status: 422 });
+        }
+        if (inputs.length > TEI_MAX_BATCH) {
+          return Response.json(
+            {
+              error: `batch size ${inputs.length} > maximum allowed batch size ${TEI_MAX_BATCH}`,
+              error_type: "Validation",
+            },
+            { status: 422 },
+          );
+        }
+        return Response.json({
+          object: "list",
+          data: inputs.map((input, index) => ({
+            object: "embedding",
+            index,
+            embedding: [input.length, 0, 0, 1],
+          })),
+          model: "nomic-ai/nomic-embed-text-v1.5",
+          usage: { prompt_tokens: 1, total_tokens: 1 },
+        });
+      },
+    });
+    teiBaseUrl = `http://127.0.0.1:${teiServer.port}/v1`;
+  });
+
+  afterAll(() => {
+    teiServer.stop(true);
+  });
+
+  beforeEach(() => {
+    teiRequests.length = 0;
+    teiOtherError = null;
+    teiPayloadTooLarge = false;
+    savedBaseUrl = process.env.EMBEDDING_API_BASE_URL;
+    process.env.EMBEDDING_API_BASE_URL = teiBaseUrl;
+  });
+
+  afterEach(() => {
+    process.env.EMBEDDING_API_BASE_URL = savedBaseUrl;
+  });
+
+  test("a 422 for the batch size embeds every input one by one", async () => {
+    const texts = Array.from({ length: 70 }, (_, i) => `chunk ${i}`);
+    const vectors = await teiProvider().embedBatch(texts);
+
+    expect(vectors.map(embeddedLength)).toEqual(texts.map((text) => text.length));
+    expect(teiRequests[0]).toHaveLength(70);
+    expect(teiRequests.slice(1)).toHaveLength(70);
+    expect(teiRequests.slice(1).every((r) => r.length === 1)).toBe(true);
+  });
+
+  test("a 413 also embeds every input one by one", async () => {
+    teiPayloadTooLarge = true;
+
+    const vectors = await teiProvider().embedBatch(["one", "three"]);
+    expect(vectors.map(embeddedLength)).toEqual([3, 5]);
+    expect(teiRequests).toEqual([["one", "three"], ["one"], ["three"]]);
+  });
+
+  test("a 422 with another message is one logged failure and no per-input calls", async () => {
+    teiOtherError = "`dimensions` set to 4 but the model only supports 768, 512, 256, 128, 64";
+    const errors = spyOn(console, "error").mockImplementation(() => {});
+    try {
+      const texts = Array.from({ length: 70 }, (_, i) => `chunk ${i}`);
+      const vectors = await teiProvider().embedBatch(texts);
+
+      expect(vectors.every((vector) => vector === null)).toBe(true);
+      expect(teiRequests).toHaveLength(1);
+      const failures = errors.mock.calls.filter((call) =>
+        String(call[0]).includes("Batch embedding failed"),
+      );
+      expect(failures).toHaveLength(1);
+    } finally {
+      errors.mockRestore();
+    }
+  });
+});

package/src/tests/memory-embedding-recovery.test.ts

@@ -0,0 +1,137 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { randomUUID } from "node:crypto";
+import { closeDb, createAgent, getDbClient, initDb } from "../be/db";
+import { getEmbeddingProvider, getMemoryStore, resetEmbeddingProvider } from "../be/memory";
+import { EMBEDDING_DIMENSIONS } from "../be/memory/constants";
+import {
+  pendingRecoveryBackfill,
+  resetEmbeddingRecoveryForTests,
+} from "../be/memory/embedding-recovery";
+
+// A fake OpenAI-compatible endpoint that is down (503), rejects inputs (400)
+// or works, like a local TEI that restarts.
+let mode: "down" | "reject" | "up" = "up";
+let server: ReturnType<typeof Bun.serve>;
+const agentId = randomUUID();
+const saved = {
+  baseUrl: process.env.EMBEDDING_API_BASE_URL,
+  key: process.env.EMBEDDING_API_KEY,
+};
+
+beforeAll(async () => {
+  server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    async fetch(req) {
+      const body = (await req.json()) as { input: string | string[] };
+      const inputs = Array.isArray(body.input) ? body.input : [body.input];
+      if (mode === "down") return new Response("model loading", { status: 503 });
+      if (mode === "reject") {
+        return Response.json({ error: { message: "bad input" } }, { status: 400 });
+      }
+      return Response.json({
+        object: "list",
+        data: inputs.map((_, index) => ({
+          object: "embedding",
+          index,
+          embedding: new Array(EMBEDDING_DIMENSIONS).fill(0.1),
+        })),
+        model: "nomic-ai/nomic-embed-text-v1.5",
+        usage: { prompt_tokens: 1, total_tokens: 1 },
+      });
+    },
+  });
+  process.env.EMBEDDING_API_BASE_URL = `http://127.0.0.1:${server.port}/v1`;
+  process.env.EMBEDDING_API_KEY = "local-tei";
+  resetEmbeddingProvider();
+  initDb(":memory:");
+  await createAgent({ id: agentId, name: "recovery", isLead: false, status: "idle" });
+});
+
+afterAll(() => {
+  server.stop(true);
+  closeDb();
+  for (const [env, value] of [
+    ["EMBEDDING_API_BASE_URL", saved.baseUrl],
+    ["EMBEDDING_API_KEY", saved.key],
+  ] as const) {
+    if (value === undefined) delete process.env[env];
+    else process.env[env] = value;
+  }
+  resetEmbeddingProvider();
+});
+
+beforeEach(() => {
+  resetEmbeddingRecoveryForTests();
+  mode = "up";
+});
+
+async function memoryWithoutVector(): Promise<string> {
+  const memory = await getMemoryStore().store({
+    agentId,
+    scope: "agent",
+    name: `written while down ${randomUUID()}`,
+    content: "violet umbrella 37",
+    source: "manual",
+  });
+  return memory.id;
+}
+
+/** A stored script with no vector, like one seeded while the endpoint was down. */
+async function scriptWithoutVector(): Promise<string> {
+  const id = randomUUID();
+  await getDbClient().run(
+    `INSERT INTO scripts (id, name, scope, source, description, intent, signatureJson, contentHash)
+     VALUES (?, ?, 'global', 'export default async () => 1', 'umbrella counter', 'count', '{}', ?)`,
+    [id, `recovery-${id}`, id],
+  );
+  return id;
+}
+
+async function scriptVectorBytes(id: string): Promise<number | null> {
+  const row = await getDbClient().get<{ bytes: number | null }>(
+    "SELECT length(embedding) AS bytes FROM script_embeddings WHERE scriptId = ?",
+    [id],
+  );
+  return row?.bytes ?? null;
+}
+
+async function vectorBytes(id: string): Promise<number | null> {
+  const row = await getDbClient().get<{ bytes: number | null }>(
+    "SELECT length(embedding) AS bytes FROM agent_memory WHERE id = ?",
+    [id],
+  );
+  return row?.bytes ?? null;
+}
+
+describe("backfill after the embeddings endpoint recovers", () => {
+  test("a memory or script written while the endpoint was down gets its vector on the next working call", async () => {
+    mode = "down";
+    expect(await getEmbeddingProvider().embed("first try", { kind: "document" })).toBeNull();
+    const id = await memoryWithoutVector();
+    const scriptId = await scriptWithoutVector();
+    expect(await vectorBytes(id)).toBeNull();
+    expect(await scriptVectorBytes(scriptId)).toBeNull();
+
+    mode = "up";
+    expect(await getEmbeddingProvider().embed("a search", { kind: "query" })).not.toBeNull();
+    const backfill = pendingRecoveryBackfill();
+    expect(backfill).not.toBeNull();
+    await backfill;
+    expect(await vectorBytes(id)).toBe(EMBEDDING_DIMENSIONS * 4);
+    expect(await scriptVectorBytes(scriptId)).toBe(EMBEDDING_DIMENSIONS * 4);
+  }, 30_000);
+
+  test("a rejected input does not start a backfill", async () => {
+    mode = "reject";
+    expect(await getEmbeddingProvider().embed("bad input")).toBeNull();
+    mode = "up";
+    expect(await getEmbeddingProvider().embed("a search", { kind: "query" })).not.toBeNull();
+    expect(pendingRecoveryBackfill()).toBeNull();
+  });
+
+  test("working calls without an earlier failure start no backfill", async () => {
+    expect(await getEmbeddingProvider().embed("a search", { kind: "query" })).not.toBeNull();
+    expect(pendingRecoveryBackfill()).toBeNull();
+  });
+});

package/src/tests/onboard-compose.test.ts

@@ -1,8 +1,15 @@
 import { describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { generateCompose as generateTemplateCompose } from "../../apps/templates-ui/src/lib/compose-generator.ts";
+import { readAgentFsImageTag } from "../../scripts/agent-fs-version-utils.ts";
+import { applyPins, PINS } from "../../scripts/bump-agent-fs.ts";
+import { AGENT_FS_VERSION } from "../commands/onboard/agent-fs-version.ts";
 import { generateCompose } from "../commands/onboard/compose-generator.ts";
 import { getPresetById, PRESETS } from "../commands/onboard/presets.ts";
 import { INITIAL_STATE, type OnboardState } from "../commands/onboard/types.ts";
+import { BASELINE_CASES, baselineState } from "./fixtures/onboard/baseline-states.ts";
 
 function makeState(overrides: Partial<OnboardState>): OnboardState {
   return { ...INITIAL_STATE, ...overrides };
@@ -379,3 +386,138 @@ describe("generateCompose", () => {
     expect(yaml).toContain("condition: service_healthy");
   });
 });
+
+describe("generateCompose with the agent-fs bundle flag", () => {
+  const serviceHeaders = (yaml: string) =>
+    yaml.split("\nvolumes:\n")[0]?.match(/^ {2}[a-z][\w-]+:$/gm) ?? [];
+  const serviceBlock = (yaml: string, name: string) =>
+    yaml.split(`\n  ${name}:\n`)[1]?.split(/\n {2}[a-z][\w-]+:\n|\nvolumes:\n/)[0] ?? "";
+
+  test("INITIAL_STATE keeps the bundle off", () => {
+    expect(INITIAL_STATE.bundleAgentFs).toBe(false);
+    expect(INITIAL_STATE.teiImage).toBeNull();
+  });
+
+  for (const { name, state } of BASELINE_CASES) {
+    test(`flag off: ${name} compose equals the pre-bundle output`, async () => {
+      const expected = await Bun.file(
+        new URL(`./fixtures/onboard/${name}.compose.yml.txt`, import.meta.url),
+      ).text();
+      const yaml = generateCompose(state);
+      expect(yaml).toBe(expected);
+      for (const s of ["agent-fs", "tei", "COMB_ENABLED", "EMBEDDING_", "AGENT_FS_"]) {
+        expect(yaml).not.toContain(s);
+      }
+    });
+  }
+
+  for (const { name, state } of BASELINE_CASES) {
+    test(`flag on: ${name} adds agent-fs and tei without changing the rest`, () => {
+      const off = generateCompose(state);
+      const yaml = generateCompose({ ...state, bundleAgentFs: true });
+      const agents = serviceHeaders(off).filter((h) => h !== "  swarm-api:");
+
+      expect(serviceHeaders(yaml)).toEqual([...serviceHeaders(off), "  agent-fs:", "  tei:"]);
+      expect(yaml).toMatch(/\n {2}agent_fs_data:\n {2}tei_data:\n$/);
+      expect(yaml.match(/^ {4}pull_policy: /gm)).toHaveLength(agents.length + 3);
+      expect(yaml.match(new RegExp(`pull_policy: ${state.pullPolicy}`, "g"))).toHaveLength(
+        agents.length + 3,
+      );
+
+      // Every line of the flag-off output survives, in order.
+      const onLines = yaml.split("\n");
+      let cursor = 0;
+      for (const line of off.split("\n")) {
+        const found = onLines.indexOf(line, cursor);
+        expect(found).toBeGreaterThanOrEqual(cursor);
+        cursor = found + 1;
+      }
+
+      // API: proxy, Comb, dashboard links, TEI memory with quoted prefixes.
+      const api = serviceBlock(yaml, "swarm-api");
+      for (const line of [
+        "      - AGENT_FS_API_URL=http://agent-fs:7433",
+        "      - AGENT_FS_PROXY=true",
+        "      - COMB_ENABLED=true",
+        "      - AGENT_FS_LINK_TARGET=dashboard",
+        "      - EMBEDDING_API_BASE_URL=http://tei:80/v1",
+        "      - EMBEDDING_MODEL=nomic-ai/nomic-embed-text-v1.5",
+        "      - EMBEDDING_API_KEY=local-tei",
+        '      - "EMBEDDING_QUERY_PREFIX=search_query: "',
+        '      - "EMBEDDING_DOCUMENT_PREFIX=search_document: "',
+      ]) {
+        expect(api.split("\n")).toContain(line);
+      }
+      expect(api).toContain(
+        "    depends_on:\n      agent-fs:\n        condition: service_healthy\n      tei:\n        condition: service_started\n",
+      );
+
+      // Every agent reaches agent-fs and builds dashboard links.
+      expect(yaml.match(/^ {6}- AGENT_FS_API_URL=http:\/\/agent-fs:7433$/gm)).toHaveLength(
+        agents.length + 1,
+      );
+      for (const header of agents) {
+        const agent = serviceBlock(yaml, header.trim().slice(0, -1));
+        expect(agent).toContain("      - AGENT_FS_API_URL=http://agent-fs:7433\n");
+        expect(agent).toContain("      - APP_URL=https://app.agent-swarm.dev\n");
+        expect(agent).toContain("      - AGENT_FS_LINK_TARGET=dashboard\n");
+      }
+
+      // agent-fs: local disk, no MinIO, no host port.
+      const afs = serviceBlock(yaml, "agent-fs");
+      expect(afs).toContain("AGENT_FS_STORAGE_PROVIDER=local");
+      expect(afs).toContain("AGENT_FS_LOCAL_ROOT=/data/storage");
+      expect(afs).toContain("      - agent_fs_data:/data");
+      expect(afs).toContain(
+        `AGENT_FS_PUBLIC_URL=\${PUBLIC_MCP_BASE_URL:-http://localhost:${state.apiPort || 3013}}/agentfs`,
+      );
+      expect(afs).toContain("node -e");
+      expect(afs).not.toContain("ports:");
+
+      // tei: no host port, the OOM and batch flags, a 2 GB cap.
+      const tei = serviceBlock(yaml, "tei");
+      expect(tei).toContain(
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: Docker Compose env var syntax
+        'image: "${TEI_IMAGE:-ghcr.io/huggingface/text-embeddings-inference:cpu-1.9.4}"',
+      );
+      expect(tei).toContain('"--max-batch-tokens", "2048"');
+      expect(tei).toContain('"--max-client-batch-size", "256"');
+      expect(tei).toContain("mem_limit: 2g");
+      expect(tei).not.toContain("ports:");
+
+      expect(yaml).not.toContain("minio");
+      expect(yaml).not.toContain("platform:");
+      expect(yaml).not.toContain("EMBEDDING_DIMENSIONS");
+    });
+  }
+
+  test("flag on: the agent-fs pin equals the Helm chart tag", async () => {
+    const values = new URL("../../charts/agent-swarm/values.yaml", import.meta.url);
+    const tag = readAgentFsImageTag(await Bun.file(values).text(), "values.yaml");
+    expect(AGENT_FS_VERSION).toBe(tag);
+    const yaml = generateCompose({ ...baselineState("solo"), bundleAgentFs: true });
+    expect(yaml).toContain(`    image: "ghcr.io/desplega-ai/agent-fs:${tag}"\n`);
+  });
+
+  test("bump-agent-fs rewrites the onboard pin and keeps the closing quote", async () => {
+    const root = await mkdtemp(join(tmpdir(), "bump-agent-fs-"));
+    try {
+      const repo = new URL("../../", import.meta.url);
+      const onboardPath = "src/commands/onboard/agent-fs-version.ts";
+      // Copy the onboard file even if PINS drops it, so the failure is the stale version.
+      for (const path of new Set([onboardPath, ...PINS.map((pin) => pin.path)])) {
+        await Bun.write(join(root, path), Bun.file(new URL(path, repo)));
+      }
+      const onboard = join(root, onboardPath);
+      expect(await Bun.file(onboard).text()).toContain(
+        `export const AGENT_FS_VERSION = "${AGENT_FS_VERSION}";`,
+      );
+      await applyPins("9.9.9", root);
+      const bumped = await Bun.file(onboard).text();
+      expect(bumped).toContain('export const AGENT_FS_VERSION = "9.9.9";');
+      expect(bumped).not.toContain(`"${AGENT_FS_VERSION}"`);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});

package/src/tests/onboard-env.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { generateEnv } from "../commands/onboard/env-generator.ts";
 import { INITIAL_STATE, type OnboardState } from "../commands/onboard/types.ts";
+import { BASELINE_CASES, baselineState } from "./fixtures/onboard/baseline-states.ts";
 
 function makeState(overrides: Partial<OnboardState>): OnboardState {
   return { ...INITIAL_STATE, ...overrides };
@@ -232,3 +233,26 @@ describe("generateEnv", () => {
     expect(env).toContain("SENTRY_ORG=sentry-org");
   });
 });
+
+describe("generateEnv with the agent-fs bundle flag", () => {
+  for (const { name, state } of BASELINE_CASES) {
+    test(`flag off: ${name} .env equals the pre-bundle output`, async () => {
+      expect(state.bundleAgentFs).toBe(false);
+      const expected = await Bun.file(
+        new URL(`./fixtures/onboard/${name}.env.txt`, import.meta.url),
+      ).text();
+      expect(generateEnv(state)).toBe(expected);
+    });
+  }
+
+  test("flag on: adds only a comment block; every bundle value lives in the compose", () => {
+    const off = generateEnv(baselineState("solo"));
+    const on = generateEnv({ ...baselineState("solo"), bundleAgentFs: true });
+    const added = on.split("\n").filter((line) => !off.split("\n").includes(line));
+    expect(added.filter((line) => line && !line.startsWith("#"))).toEqual([]);
+    expect(on).toContain("--no-agent-fs");
+    for (const s of ["COMB_ENABLED", "EMBEDDING_", "AGENT_FS_", "EMBEDDING_DIMENSIONS"]) {
+      expect(on).not.toContain(s);
+    }
+  });
+});

package/src/tests/onboard-non-interactive.test.ts

@@ -94,6 +94,34 @@ describe("non-interactive onboarding CLI", () => {
     CHILD_PROCESS_TEST_BUDGET_MS,
   );
 
+  test(
+    "--yes bundles agent-fs by default and --no-agent-fs turns it off (dry run writes nothing)",
+    async () => {
+      const outputDir = await mkdtemp(join(tmpdir(), "onboard-agent-fs-"));
+      const env = { ...process.env, CLAUDE_CODE_OAUTH_TOKEN: "example-test-oauth" };
+      try {
+        const bundled = await runChild(
+          ["bun", CLI_PATH, "onboard", "--yes", "--preset=solo", "--dry-run"],
+          { cwd: outputDir, env },
+        );
+        expect(bundled.exitCode).toBe(0);
+        expect(bundled.stdout).toContain("Bundling agent-fs and TEI");
+
+        const skipped = await runChild(
+          ["bun", CLI_PATH, "onboard", "--yes", "--preset=solo", "--dry-run", "--no-agent-fs"],
+          { cwd: outputDir, env },
+        );
+        expect(skipped.exitCode).toBe(0);
+        expect(skipped.stdout).toContain("Write docker-compose.yml");
+        expect(skipped.stdout).not.toContain("Bundling agent-fs");
+        expect(await readdir(outputDir)).toEqual([]);
+      } finally {
+        await rm(outputDir, { recursive: true, force: true });
+      }
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
   test(
     "documents explicit unattended presets and conservative concurrency",
     async () => {
@@ -104,6 +132,7 @@ describe("non-interactive onboarding CLI", () => {
       expect(result.stdout).toContain("onboard --yes --preset=full");
       expect(result.stdout).toContain("default: lead 2, worker 1");
       expect(result.stdout).not.toContain("default: full");
+      expect(result.stdout).toContain("--no-agent-fs");
     },
     CHILD_PROCESS_TEST_BUDGET_MS,
   );

package/src/tests/onboard-tei-image.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+import { generateEnv } from "../commands/onboard/env-generator.ts";
+import { TEI_ARM64_IMAGE, teiImageForArch } from "../commands/onboard/tei-image.ts";
+import { baselineState } from "./fixtures/onboard/baseline-states.ts";
+
+describe("teiImageForArch", () => {
+  test("arm64 and aarch64 get the arm64 TEI tag", () => {
+    expect(TEI_ARM64_IMAGE).toBe("ghcr.io/huggingface/text-embeddings-inference:cpu-arm64-1.9.4");
+    expect(teiImageForArch("arm64")).toBe(TEI_ARM64_IMAGE);
+    expect(teiImageForArch("aarch64")).toBe(TEI_ARM64_IMAGE);
+  });
+
+  test("x64 and other arches keep the compose default", () => {
+    expect(teiImageForArch("x64")).toBeNull();
+    expect(teiImageForArch("ia32")).toBeNull();
+    expect(teiImageForArch("")).toBeNull();
+  });
+});
+
+describe("TEI_IMAGE in .env", () => {
+  test("is written only with the arm64 tag", () => {
+    const on = { ...baselineState("solo"), bundleAgentFs: true };
+    const arm = generateEnv({ ...on, teiImage: teiImageForArch("arm64") });
+    expect(arm).toContain(`\nTEI_IMAGE=${TEI_ARM64_IMAGE}\n`);
+    expect(arm.match(/^TEI_IMAGE=/gm)).toHaveLength(1);
+
+    const x64 = generateEnv({ ...on, teiImage: teiImageForArch("x64") });
+    expect(x64).not.toContain("TEI_IMAGE");
+    expect(x64).toContain("--no-agent-fs");
+  });
+
+  test("is never written with the bundle off", () => {
+    const env = generateEnv({ ...baselineState("solo"), teiImage: TEI_ARM64_IMAGE });
+    expect(env).not.toContain("TEI_IMAGE");
+  });
+});