@desplega.ai/agent-swarm 1.92.2 → 1.93.0

package/src/tests/codex-pool.test.ts

@@ -24,11 +24,7 @@ import {
   credentialsToAuthJson,
 } from "../providers/codex-oauth/auth-json.js";
 import { materializeCodexAuthJson } from "../providers/codex-oauth/auth-json-fs.js";
-import {
-  loadAllCodexOAuthSlots,
-  persistCodexOAuth,
-  storeCodexOAuth,
-} from "../providers/codex-oauth/storage.js";
+import { loadAllCodexOAuthSlots, persistCodexOAuth } from "../providers/codex-oauth/storage.js";
 import type { CodexOAuthCredentials } from "../providers/codex-oauth/types.js";
 
 // ─── Fixtures ────────────────────────────────────────────────────────────────
@@ -117,7 +113,7 @@ afterEach(() => {
 describe("Scenario 1 — 3-slot round-trip with availability filter", () => {
   it("selects from available slots [1,2] and materialises the correct creds into auth.json", async () => {
     // Mock API: three slots in config store.
-    globalThis.fetch = async (url: string | URL | Request) => {
+    globalThis.fetch = async (_url: string | URL | Request) => {
       return makeConfigResponse();
       // (available-indices endpoint not called by loadAllCodexOAuthSlots)
     };

package/src/tests/http-api-integration.test.ts

@@ -25,7 +25,6 @@ async function api(
   method: string,
   path: string,
   opts: { body?: unknown; agentId?: string; headers?: Record<string, string> } = {},
-  // biome-ignore lint/suspicious/noExplicitAny: test helper needs flexible body type
 ): Promise<{ status: number; body: any; ok: boolean }> {
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
@@ -41,7 +40,6 @@ async function api(
   });
 
   const text = await res.text();
-  // biome-ignore lint/suspicious/noExplicitAny: body can be parsed JSON or raw text
   let body: any;
   try {
     body = JSON.parse(text);
@@ -427,9 +425,9 @@ describe("Tasks", () => {
     expect(status).toBe(404);
   });
 
-  test("PUT /api/tasks/:id/claude-session — update session ID", async () => {
+  test("PUT /api/tasks/:id/session — update session ID", async () => {
     const sessionId = randomUUID();
-    const { status, body } = await put(`/api/tasks/${ids.task2}/claude-session`, {
+    const { status, body } = await put(`/api/tasks/${ids.task2}/session`, {
       agentId: ids.workerAgent,
       body: { claudeSessionId: sessionId },
     });
@@ -437,8 +435,8 @@ describe("Tasks", () => {
     expect(body.claudeSessionId).toBe(sessionId);
   });
 
-  test("PUT /api/tasks/:id/claude-session — missing fields returns 400", async () => {
-    const { status } = await put(`/api/tasks/${ids.task2}/claude-session`, {
+  test("PUT /api/tasks/:id/session — missing fields returns 400", async () => {
+    const { status } = await put(`/api/tasks/${ids.task2}/session`, {
       body: {},
     });
     expect(status).toBe(400);

package/src/tests/memory-edges.test.ts

@@ -48,7 +48,6 @@ async function api(
   method: string,
   path: string,
   opts: { body?: unknown; agentId?: string } = {},
-  // biome-ignore lint/suspicious/noExplicitAny: test helper
 ): Promise<{ status: number; body: any }> {
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
@@ -61,7 +60,6 @@ async function api(
     body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
   });
   const text = await res.text();
-  // biome-ignore lint/suspicious/noExplicitAny: body may be JSON or text
   let body: any;
   try {
     body = JSON.parse(text);

package/src/tests/memory-rate-endpoint.test.ts

@@ -41,7 +41,6 @@ async function api(
   method: string,
   path: string,
   opts: { body?: unknown; agentId?: string } = {},
-  // biome-ignore lint/suspicious/noExplicitAny: test helper
 ): Promise<{ status: number; body: any }> {
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
@@ -54,7 +53,6 @@ async function api(
     body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
   });
   const text = await res.text();
-  // biome-ignore lint/suspicious/noExplicitAny: body may be JSON or text
   let body: any;
   try {
     body = JSON.parse(text);

package/src/tests/memory-rater-e2e.test.ts

@@ -64,7 +64,6 @@ async function api(
   method: string,
   path: string,
   opts: { body?: unknown; agentId?: string; sourceTaskId?: string } = {},
-  // biome-ignore lint/suspicious/noExplicitAny: test helper
 ): Promise<{ status: number; body: any }> {
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
@@ -78,7 +77,6 @@ async function api(
     body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
   });
   const text = await res.text();
-  // biome-ignore lint/suspicious/noExplicitAny: body may be JSON or text
   let body: any;
   try {
     body = JSON.parse(text);

package/src/tests/memory-store.test.ts

@@ -1,6 +1,6 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
-import { closeDb, createAgent, getDb, initDb } from "../be/db";
+import { closeDb, createAgent, getDb, initDb, isSqliteVecAvailable } from "../be/db";
 import { serializeEmbedding } from "../be/embedding";
 import { SqliteMemoryStore } from "../be/memory/providers/sqlite-store";
 
@@ -19,6 +19,16 @@ describe("SqliteMemoryStore", () => {
     return embedding;
   }
 
+  function skipVecAssertionsWhenUnavailable(): boolean {
+    if (isSqliteVecAvailable()) return false;
+
+    const health = store.getHealth();
+    expect(health.sqliteVec.extensionLoaded).toBe(false);
+    expect(health.retrievalMode).toBe("fallback");
+    expect(health.reasons).toContain("sqlite_vec_extension_unavailable");
+    return true;
+  }
+
   beforeAll(async () => {
     for (const suffix of ["", "-wal", "-shm"]) {
       try {
@@ -221,6 +231,8 @@ describe("SqliteMemoryStore", () => {
     });
 
     test("uses sqlite-vec for 512d embeddings with scope-filter parity", () => {
+      if (skipVecAssertionsWhenUnavailable()) return;
+
       for (let i = 0; i < 6; i++) {
         const otherAgent = store.store({
           agentId: agentB,
@@ -256,6 +268,8 @@ describe("SqliteMemoryStore", () => {
 
   describe("memory_vec population", () => {
     test("populates existing embeddings on startup and reports health counts", () => {
+      if (skipVecAssertionsWhenUnavailable()) return;
+
       const raw = store.store({
         agentId: agentA,
         scope: "agent",
@@ -282,6 +296,8 @@ describe("SqliteMemoryStore", () => {
     });
 
     test("rebuilds an old non-cosine memory_vec table from agent_memory", () => {
+      if (skipVecAssertionsWhenUnavailable()) return;
+
       const raw = store.store({
         agentId: agentA,
         scope: "agent",
@@ -473,6 +489,8 @@ describe("SqliteMemoryStore", () => {
     });
 
     test("also removes corresponding vec rows", () => {
+      if (skipVecAssertionsWhenUnavailable()) return;
+
       const db = getDb();
       const emb = vector({ 0: 0.9, 100: 0.1 });
 

package/src/tests/memory.test.ts

@@ -479,6 +479,57 @@ describe("Memory System", () => {
       const page2 = store.list(listAgent, { scope: "agent", limit: 3, offset: 3 });
       expect(page2.length).toBe(2);
     });
+
+    test("counts memories with the same filters used by list", () => {
+      const countAgent = "eeee0000-0000-4000-8000-000000000105";
+      createAgent({ id: countAgent, name: "Count Agent", isLead: false, status: "idle" });
+
+      store.store({
+        agentId: countAgent,
+        scope: "agent",
+        name: "Count match 1",
+        content: "Content",
+        source: "file_index",
+        sourcePath: "/workspace/src/MemoryPage.tsx",
+      });
+      store.store({
+        agentId: countAgent,
+        scope: "swarm",
+        name: "Count match 2",
+        content: "Content",
+        source: "file_index",
+        sourcePath: "/workspace/SRC/memory-page.tsx",
+      });
+      store.store({
+        agentId: countAgent,
+        scope: "agent",
+        name: "Wrong source",
+        content: "Content",
+        source: "manual",
+        sourcePath: "/workspace/src/MemoryPage.tsx",
+      });
+      store.store({
+        agentId: agentA,
+        scope: "agent",
+        name: "Wrong owner",
+        content: "Content",
+        source: "file_index",
+        sourcePath: "/workspace/src/MemoryPage.tsx",
+      });
+
+      const filters = {
+        scope: "all" as const,
+        isLead: true,
+        ownerAgentId: countAgent,
+        source: "file_index" as const,
+        sourcePath: "src/memory",
+      };
+
+      expect(store.count("", filters)).toBe(2);
+      expect(store.list("", { ...filters, limit: 1, offset: 0 })).toHaveLength(1);
+      expect(store.list("", { ...filters, limit: 1, offset: 1 })).toHaveLength(1);
+      expect(store.list("", { ...filters, limit: 1, offset: 2 })).toHaveLength(0);
+    });
   });
 
   describe("store.delete (deleteMemory)", () => {

package/src/tests/model-control.test.ts

@@ -102,7 +102,7 @@ describe("Model Control - Schedule Creation", () => {
   });
 
   test("should store all valid model values on schedules", () => {
-    for (const model of ["haiku", "sonnet", "opus"] as const) {
+    for (const model of ["haiku", "sonnet", "opus", "fable"] as const) {
       const schedule = createScheduledTask({
         name: `model-schedule-all-${model}-${Date.now()}`,
         intervalMs: 60000,

package/src/tests/reload-config.test.ts

@@ -14,6 +14,37 @@ import {
 
 const TEST_DB_PATH = "./test-reload-config.sqlite";
 const TEST_PORT = 13023;
+const INTEGRATION_DISABLE_KEYS = [
+  "AGENTMAIL_DISABLE",
+  "GITHUB_DISABLE",
+  "JIRA_DISABLE",
+  "LINEAR_DISABLE",
+  "SLACK_DISABLE",
+] as const;
+const originalIntegrationDisableValues = new Map<
+  (typeof INTEGRATION_DISABLE_KEYS)[number],
+  string | undefined
+>();
+
+beforeAll(() => {
+  for (const key of INTEGRATION_DISABLE_KEYS) {
+    originalIntegrationDisableValues.set(key, process.env[key]);
+    process.env[key] = "true";
+  }
+  _resetAutoReloadForTests();
+});
+
+afterAll(() => {
+  for (const key of INTEGRATION_DISABLE_KEYS) {
+    const originalValue = originalIntegrationDisableValues.get(key);
+    if (originalValue === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = originalValue;
+    }
+  }
+  originalIntegrationDisableValues.clear();
+});
 
 function insertLegacyReservedRow(key: string, value = "legacy"): string {
   const id = crypto.randomUUID();
@@ -207,23 +238,8 @@ describe("reload-config", () => {
 });
 
 describe("auto-reload debouncer", () => {
-  // The reload calls into stopSlackApp/startSlackApp + GH/Linear/Jira/AgentMail
-  // init. They are no-ops without credentials, so we explicitly disable Slack
-  // (it has its own DISABLE switch) and rely on the others being unconfigured.
-  let originalSlackDisable: string | undefined;
-
-  beforeAll(() => {
-    originalSlackDisable = process.env.SLACK_DISABLE;
-    process.env.SLACK_DISABLE = "true";
-  });
-
-  afterAll(() => {
-    if (originalSlackDisable === undefined) {
-      delete process.env.SLACK_DISABLE;
-    } else {
-      process.env.SLACK_DISABLE = originalSlackDisable;
-    }
-  });
+  // The reload path reinitializes every integration. Keep these tests focused
+  // on debounce semantics rather than local .env / CI credential side effects.
 
   beforeEach(async () => {
     // Drain any reload state that leaked from earlier test files in the full