@desplega.ai/agent-swarm 1.92.0 → 1.92.2

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

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
-import { closeDb, createAgent, initDb } from "../be/db";
+import { closeDb, createAgent, getDb, initDb } from "../be/db";
+import { serializeEmbedding } from "../be/embedding";
 import { SqliteMemoryStore } from "../be/memory/providers/sqlite-store";
 
 const TEST_DB_PATH = "./test-memory-store.sqlite";
@@ -10,6 +11,14 @@ describe("SqliteMemoryStore", () => {
   const agentB = "bbbb0000-0000-4000-8000-000000000002";
   let store: SqliteMemoryStore;
 
+  function vector(values: Record<number, number>): Float32Array {
+    const embedding = new Float32Array(512);
+    for (const [index, value] of Object.entries(values)) {
+      embedding[Number(index)] = value;
+    }
+    return embedding;
+  }
+
   beforeAll(async () => {
     for (const suffix of ["", "-wal", "-shm"]) {
       try {
@@ -210,6 +219,95 @@ describe("SqliteMemoryStore", () => {
       const agents = new Set(results.map((r) => r.agentId));
       expect(agents.size).toBeGreaterThanOrEqual(1);
     });
+
+    test("uses sqlite-vec for 512d embeddings with scope-filter parity", () => {
+      for (let i = 0; i < 6; i++) {
+        const otherAgent = store.store({
+          agentId: agentB,
+          scope: "agent",
+          name: `vec-other-agent-exact-${i}`,
+          content: "exact but invisible to agentA",
+          source: "manual",
+        });
+        store.updateEmbedding(otherAgent.id, vector({ 0: 1 }), "test-model");
+      }
+
+      const visible = store.store({
+        agentId: agentA,
+        scope: "agent",
+        name: "vec-agent-visible",
+        content: "visible to agentA",
+        source: "manual",
+      });
+      store.updateEmbedding(visible.id, vector({ 0: 0.8, 1: 0.2 }), "test-model");
+
+      const query = vector({ 0: 1 });
+      const results = store.search(query, agentA, { scope: "agent", limit: 5 });
+
+      expect(results[0]!.id).toBe(visible.id);
+      expect(results.every((r) => r.agentId === agentA && r.scope === "agent")).toBe(true);
+
+      const health = store.getHealth();
+      expect(health.sqliteVec.schema).toContain("distance_metric=cosine");
+      expect(health.counts.memoryVec).toBeGreaterThanOrEqual(2);
+      expect(health.retrievalMode).toBe("vec");
+    });
+  });
+
+  describe("memory_vec population", () => {
+    test("populates existing embeddings on startup and reports health counts", () => {
+      const raw = store.store({
+        agentId: agentA,
+        scope: "agent",
+        name: "raw-existing-embedding",
+        content: "raw existing embedding",
+        source: "manual",
+      });
+      getDb()
+        .prepare("UPDATE agent_memory SET embedding = ?, embeddingModel = ? WHERE id = ?")
+        .run(serializeEmbedding(vector({ 2: 1 })), "test-model", raw.id);
+      getDb().prepare("DELETE FROM memory_vec WHERE memory_id = ?").run(raw.id);
+
+      const freshStore = new SqliteMemoryStore();
+      const health = freshStore.getHealth();
+
+      expect(health.counts.missingFromVec).toBe(0);
+      expect(health.sqliteVec.lastPopulate?.attempted).toBeGreaterThanOrEqual(1);
+      expect(health.sqliteVec.lastPopulate?.failed).toBe(0);
+
+      const resultIds = freshStore
+        .search(vector({ 2: 1 }), agentA, { scope: "agent", limit: 20 })
+        .map((r) => r.id);
+      expect(resultIds).toContain(raw.id);
+    });
+
+    test("rebuilds an old non-cosine memory_vec table from agent_memory", () => {
+      const raw = store.store({
+        agentId: agentA,
+        scope: "agent",
+        name: "stale-schema-embedding",
+        content: "stale schema embedding",
+        source: "manual",
+      });
+      getDb()
+        .prepare("UPDATE agent_memory SET embedding = ?, embeddingModel = ? WHERE id = ?")
+        .run(serializeEmbedding(vector({ 3: 1 })), "test-model", raw.id);
+
+      getDb().run("DROP TABLE memory_vec");
+      getDb().run(`
+        CREATE VIRTUAL TABLE memory_vec USING vec0(
+          memory_id TEXT PRIMARY KEY,
+          embedding float[512]
+        )
+      `);
+
+      const freshStore = new SqliteMemoryStore();
+      const health = freshStore.getHealth();
+
+      expect(health.sqliteVec.schema).toContain("distance_metric=cosine");
+      expect(health.counts.missingFromVec).toBe(0);
+      expect(health.retrievalMode).toBe("vec");
+    });
   });
 
   describe("delete()", () => {
@@ -326,4 +424,126 @@ describe("SqliteMemoryStore", () => {
       expect(filtered.length).toBeGreaterThan(0);
     });
   });
+
+  describe("purgeExpired()", () => {
+    const purgeAgent = "cccc0000-0000-4000-8000-000000000003";
+
+    beforeAll(() => {
+      try {
+        createAgent({ id: purgeAgent, name: "Purge Agent", isLead: false, status: "idle" });
+      } catch {
+        // agent may already exist from a prior run
+      }
+    });
+
+    test("deletes rows past their expiresAt and returns count", () => {
+      const db = getDb();
+
+      // Store a session_summary (3-day TTL) then backdateits expiresAt to the past
+      const mem = store.store({
+        agentId: purgeAgent,
+        scope: "agent",
+        name: "expired session",
+        content: "old session data",
+        source: "session_summary",
+      });
+      db.prepare("UPDATE agent_memory SET expiresAt = datetime('now', '-1 day') WHERE id = ?").run(
+        mem.id,
+      );
+
+      // Store a manual memory (never expires) — should survive
+      const keeper = store.store({
+        agentId: purgeAgent,
+        scope: "agent",
+        name: "keeper",
+        content: "manual content",
+        source: "manual",
+      });
+
+      const purged = store.purgeExpired();
+      expect(purged).toBeGreaterThanOrEqual(1);
+
+      expect(store.get(mem.id)).toBeNull();
+      expect(store.get(keeper.id)).not.toBeNull();
+    });
+
+    test("returns 0 when nothing is expired", () => {
+      const purged = store.purgeExpired();
+      expect(purged).toBe(0);
+    });
+
+    test("also removes corresponding vec rows", () => {
+      const db = getDb();
+      const emb = vector({ 0: 0.9, 100: 0.1 });
+
+      const mem = store.store({
+        agentId: purgeAgent,
+        scope: "agent",
+        name: "vec-purge-test",
+        content: "will be purged",
+        source: "task_completion",
+      });
+      store.updateEmbedding(mem.id, emb, "test-model");
+
+      const vecBefore = db
+        .prepare<{ count: number }, [string]>(
+          "SELECT COUNT(*) as count FROM memory_vec WHERE memory_id = ?",
+        )
+        .get(mem.id);
+
+      // Only check vec cleanup if the row was actually inserted
+      if (vecBefore && vecBefore.count > 0) {
+        db.prepare(
+          "UPDATE agent_memory SET expiresAt = datetime('now', '-1 day') WHERE id = ?",
+        ).run(mem.id);
+
+        store.purgeExpired();
+
+        const vecAfter = db
+          .prepare<{ count: number }, [string]>(
+            "SELECT COUNT(*) as count FROM memory_vec WHERE memory_id = ?",
+          )
+          .get(mem.id);
+        expect(vecAfter?.count ?? 0).toBe(0);
+      }
+    });
+  });
+
+  describe("knn-k cap", () => {
+    test("search does not throw when vec table exceeds 4096 rows", () => {
+      const db = getDb();
+      const emb = vector({ 0: 1.0 });
+      const embBuffer = serializeEmbedding(emb);
+
+      // Check if vec is available — if not, skip (test is meaningful only with vec)
+      const health = store.getHealth();
+      if (health.retrievalMode !== "vec") return;
+
+      // Insert enough rows to exceed 4096 in the vec table
+      const currentCount =
+        db.prepare<{ c: number }, []>("SELECT COUNT(*) as c FROM memory_vec").get()?.c ?? 0;
+      const needed = Math.max(0, 4097 - currentCount);
+
+      for (let i = 0; i < needed; i++) {
+        const id = `knn-test-${i}-${Date.now()}`;
+        db.prepare(
+          "INSERT INTO agent_memory (id, agentId, scope, name, content, source, embedding, chunkIndex, totalChunks, tags, alpha, beta, createdAt, accessedAt) VALUES (?, ?, 'agent', ?, 'knn test', 'manual', ?, 0, 1, '[]', 1, 1, datetime('now'), datetime('now'))",
+        ).run(id, agentA, `knn-${i}`, embBuffer);
+        const vecBuf = new Float32Array(emb);
+        db.prepare("INSERT INTO memory_vec (memory_id, embedding) VALUES (?, ?)").run(
+          id,
+          Buffer.from(vecBuf.buffer),
+        );
+      }
+
+      const vecCount =
+        db.prepare<{ c: number }, []>("SELECT COUNT(*) as c FROM memory_vec").get()?.c ?? 0;
+      expect(vecCount).toBeGreaterThanOrEqual(4097);
+
+      // This should NOT throw — it should clamp k to 4096
+      const results = store.search(emb, agentA, { scope: "agent", limit: 10 });
+      expect(results).toBeDefined();
+      expect(Array.isArray(results)).toBe(true);
+    });
+  });
 });

package/src/tests/memory.test.ts

@@ -342,8 +342,9 @@ describe("Memory System", () => {
         status: "idle",
       });
 
-      // Create memories with known embeddings
-      // Memory 1: agent scope for searchAgentId, embedding [1,0,0]
+      // Create memories with known embeddings (all share a baseline component
+      // so pairwise cosine similarity stays above the MIN_SIMILARITY floor).
+      // Memory 1: agent scope for searchAgentId
       const m1 = store.store({
         agentId: searchAgentId,
         scope: "agent",
@@ -351,9 +352,9 @@ describe("Memory System", () => {
         content: "Agent-scoped content",
         source: "manual",
       });
-      store.updateEmbedding(m1.id, new Float32Array([1, 0, 0]), "test-model");
+      store.updateEmbedding(m1.id, new Float32Array([1, 0.3, 0.3]), "test-model");
 
-      // Memory 2: swarm scope, embedding [0,1,0]
+      // Memory 2: swarm scope
       const m2 = store.store({
         agentId: searchAgentId,
         scope: "swarm",
@@ -361,9 +362,9 @@ describe("Memory System", () => {
         content: "Swarm-scoped content",
         source: "file_index",
       });
-      store.updateEmbedding(m2.id, new Float32Array([0, 1, 0]), "test-model");
+      store.updateEmbedding(m2.id, new Float32Array([0.3, 1, 0.3]), "test-model");
 
-      // Memory 3: agent scope for OTHER agent, embedding [0,0,1]
+      // Memory 3: agent scope for OTHER agent
       const m3 = store.store({
         agentId: searchAgentId2,
         scope: "agent",
@@ -371,11 +372,11 @@ describe("Memory System", () => {
         content: "Other agent's private memory",
         source: "manual",
       });
-      store.updateEmbedding(m3.id, new Float32Array([0, 0, 1]), "test-model");
+      store.updateEmbedding(m3.id, new Float32Array([0.3, 0.3, 1]), "test-model");
     });
 
     test("worker sees own agent-scoped + swarm memories", () => {
-      const query = new Float32Array([1, 0, 0]); // closest to Memory 1
+      const query = new Float32Array([1, 0.3, 0.3]); // closest to Memory 1
       const results = store.search(query, searchAgentId, { isLead: false });
       const names = results.map((r) => r.name);
 
@@ -385,7 +386,7 @@ describe("Memory System", () => {
     });
 
     test("worker does not see other agent's agent-scoped memories", () => {
-      const query = new Float32Array([0, 0, 1]); // closest to Memory 3
+      const query = new Float32Array([0.3, 0.3, 1]); // closest to Memory 3
       const results = store.search(query, searchAgentId, { isLead: false });
       const names = results.map((r) => r.name);
 
@@ -393,7 +394,7 @@ describe("Memory System", () => {
     });
 
     test("lead sees ALL memories across agents", () => {
-      const query = new Float32Array([0, 0, 1]); // closest to Memory 3
+      const query = new Float32Array([0.3, 0.3, 1]); // closest to Memory 3
       const results = store.search(query, searchAgentId, { isLead: true });
       const names = results.map((r) => r.name);
 
@@ -403,12 +404,12 @@ describe("Memory System", () => {
     });
 
     test("results sorted by similarity (highest first)", () => {
-      const query = new Float32Array([1, 0, 0]); // identical to Memory 1's embedding
+      const query = new Float32Array([1, 0.3, 0.3]); // closest to Memory 1's embedding
       const results = store.search(query, searchAgentId, { isLead: true });
 
       expect(results.length).toBeGreaterThan(0);
       expect(results[0].name).toBe("Agent Memory 1");
-      expect(results[0].similarity).toBeCloseTo(1.0, 3);
+      expect(results[0].similarity).toBeGreaterThan(0.9);
 
       // Each subsequent result should have lower or equal similarity
       for (let i = 1; i < results.length; i++) {

package/src/tests/pages-http.test.ts

@@ -61,14 +61,13 @@ describe("Pages HTTP API", () => {
     }
   });
 
-  test("POST /api/pages creates a page and returns {id, version}", async () => {
+  test("POST /api/pages creates an authed page by default and returns {id, version}", async () => {
     const res = await fetch(`${baseUrl}/api/pages`, {
       method: "POST",
       headers,
       body: JSON.stringify({
         title: "Hello",
         contentType: "text/html",
-        authMode: "public",
         body: "<h1>hi</h1>",
       }),
     });
@@ -87,6 +86,25 @@ describe("Pages HTTP API", () => {
     expect(page.agentId).toBe(agentId);
     expect(page.slug).toBe("hello"); // auto-slug from title
     expect(page.contentType).toBe("text/html");
+    expect(page.authMode).toBe("authed");
+  });
+
+  test("POST /api/pages can explicitly opt in to public auth", async () => {
+    const res = await fetch(`${baseUrl}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        title: "Public",
+        contentType: "text/html",
+        authMode: "public",
+        body: "<h1>public</h1>",
+      }),
+    });
+
+    expect(res.status).toBe(201);
+    const json = (await res.json()) as { id: string };
+    const got = await fetch(`${baseUrl}/api/pages/${json.id}`, { headers });
+    const page = (await got.json()) as Page;
     expect(page.authMode).toBe("public");
   });
 

package/src/tests/pages-storage.test.ts

@@ -5,6 +5,7 @@ import {
   closeDb,
   createPage,
   deletePage,
+  getDb,
   getPage,
   getPageBySlug,
   getPageVersion,
@@ -81,6 +82,31 @@ describe("pages storage CRUD", () => {
     expect(getPageVersions(created.id)).toHaveLength(0);
   });
 
+  test("createPage defaults authMode to authed when omitted", () => {
+    const agentId = makeAgentId();
+    const created = createPage({
+      agentId,
+      slug: "default-auth",
+      title: "Default Auth",
+      contentType: "text/html",
+      body: "<h1>default</h1>",
+    });
+
+    expect(created.authMode).toBe("authed");
+  });
+
+  test("pages table defaults authMode to authed when omitted", () => {
+    const agentId = makeAgentId();
+    const row = getDb()
+      .prepare<{ authMode: string }, [string, string, string, string, string]>(
+        `INSERT INTO pages (agentId, slug, title, contentType, body)
+         VALUES (?, ?, ?, ?, ?) RETURNING authMode`,
+      )
+      .get(agentId, "sql-default-auth", "SQL Default Auth", "text/html", "<h1>default</h1>");
+
+    expect(row?.authMode).toBe("authed");
+  });
+
   test("snapshotPage captures PRE-update content; post-update lives on parent", () => {
     const agentId = makeAgentId();
     const page = createPage({

package/src/tests/scripts-mcp-e2e.test.ts

@@ -232,6 +232,59 @@ describe("script_ MCP HTTP proxy tools", () => {
     expect(del.structuredContent.data?.deleted).toBe(true);
   });
 
+  test("persists a successful inline run with kind 'inline' and no journal", async () => {
+    const tools = buildToolServer();
+    const source = `export default async (args: { value: number }) => ({ doubled: args.value * 2 });`;
+
+    const run = (await tools.run.handler(
+      { source, args: { value: 21 }, intent: "inline persist e2e" },
+      meta(workerId),
+    )) as StructuredResult<{ result: { doubled: number } }>;
+    expect(run.structuredContent.success).toBe(true);
+    expect(run.structuredContent.data?.result).toEqual({ doubled: 42 });
+
+    const listed = (await tools.listScriptRuns.handler(
+      { limit: 10, offset: 0 },
+      meta(workerId),
+    )) as StructuredResult<{
+      runs: Array<{ id: string; kind: string; status: string }>;
+      total: number;
+    }>;
+    expect(listed.structuredContent.data?.total).toBe(1);
+    const inlineRun = listed.structuredContent.data?.runs[0];
+    expect(inlineRun?.kind).toBe("inline");
+    expect(inlineRun?.status).toBe("completed");
+
+    const detail = (await tools.getScriptRun.handler(
+      { id: inlineRun?.id },
+      meta(workerId),
+    )) as StructuredResult<{ run: { kind: string }; journal: unknown[] }>;
+    expect(detail.structuredContent.data?.run.kind).toBe("inline");
+    expect(detail.structuredContent.data?.journal).toEqual([]);
+  });
+
+  test("persists a failed inline run with kind 'inline' and an error", async () => {
+    const tools = buildToolServer();
+    const source = `export default async () => { throw new Error("boom"); };`;
+
+    const run = (await tools.run.handler(
+      { source, intent: "inline failure e2e" },
+      meta(workerId),
+    )) as StructuredResult<unknown>;
+    expect(run.structuredContent.success).toBe(true);
+
+    const listed = (await tools.listScriptRuns.handler(
+      { limit: 10, offset: 0 },
+      meta(workerId),
+    )) as StructuredResult<{
+      runs: Array<{ kind: string; status: string; error?: string }>;
+    }>;
+    const failed = listed.structuredContent.data?.runs[0];
+    expect(failed?.kind).toBe("inline");
+    expect(failed?.status).toBe("failed");
+    expect(failed?.error).toBeTruthy();
+  });
+
   test("stdio-style missing agent identity short-circuits clearly", async () => {
     const tools = buildToolServer();
     const result = (await tools.search.handler({ query: "anything" }, meta())) as StructuredResult<{