@desplega.ai/agent-swarm 1.64.0 → 1.65.0

package/src/tests/self-improvement.test.ts

@@ -4,15 +4,12 @@ import {
   closeDb,
   completeTask,
   createAgent,
-  createMemory,
   createTaskExtended,
   failTask,
   getAgentById,
   initDb,
-  searchMemoriesByVector,
-  updateMemoryEmbedding,
 } from "../be/db";
-import { serializeEmbedding } from "../be/embedding";
+import { SqliteMemoryStore } from "../be/memory/providers/sqlite-store";
 import { getBasePrompt } from "../prompts/base-prompt";
 
 const TEST_DB_PATH = "./test-self-improvement.sqlite";
@@ -21,6 +18,7 @@ describe("Self-Improvement Mechanisms", () => {
   const leadId = "aaaa0000-0000-4000-8000-000000000001";
   const workerId = "bbbb0000-0000-4000-8000-000000000002";
   const otherWorkerId = "cccc0000-0000-4000-8000-000000000003";
+  let store: SqliteMemoryStore;
 
   beforeAll(async () => {
     for (const suffix of ["", "-wal", "-shm"]) {
@@ -33,6 +31,7 @@ describe("Self-Improvement Mechanisms", () => {
 
     closeDb();
     initDb(TEST_DB_PATH);
+    store = new SqliteMemoryStore();
 
     createAgent({ id: leadId, name: "Test Lead", isLead: true, status: "idle" });
     createAgent({ id: workerId, name: "Test Worker", isLead: false, status: "idle" });
@@ -67,7 +66,7 @@ describe("Self-Improvement Mechanisms", () => {
 
       // Simulate what store-progress does: create memory for completed task
       const taskContent = `Task: ${task.task}\n\nOutput:\n${output}`;
-      const memory = createMemory({
+      const memory = store.store({
         agentId: workerId,
         content: taskContent,
         name: `Task: ${task.task.slice(0, 80)}`,
@@ -113,7 +112,7 @@ describe("Self-Improvement Mechanisms", () => {
 
       // Simulate store-progress failed task memory creation
       const taskContent = `Task: ${task.task}\n\nFailure reason:\n${failureReason}\n\nThis task failed. Learn from this to avoid repeating the mistake.`;
-      const memory = createMemory({
+      const memory = store.store({
         agentId: workerId,
         content: taskContent,
         name: `Task: ${task.task.slice(0, 80)}`,
@@ -170,7 +169,7 @@ describe("Self-Improvement Mechanisms", () => {
       expect(shouldShareWithSwarm).toBe(true);
 
       // Verify swarm memory can be created
-      const swarmMemory = createMemory({
+      const swarmMemory = store.store({
         agentId: workerId,
         scope: "swarm",
         name: `Shared: ${task.task.slice(0, 80)}`,
@@ -266,7 +265,7 @@ describe("Self-Improvement Mechanisms", () => {
       const learning = "Always run lint before committing";
       const content = `[Lead Feedback — ${category}]\n\n${learning}`;
 
-      const memory = createMemory({
+      const memory = store.store({
         agentId: workerId,
         scope: "swarm",
         name: `Lead feedback: ${category} — ${learning.slice(0, 60)}`,
@@ -293,7 +292,7 @@ describe("Self-Improvement Mechanisms", () => {
     test("injected learning is visible to target worker in memory search", () => {
       // Create memory with embedding for searchability
       const content = "[Lead Feedback — mistake-pattern]\n\nNever force-push to main branch";
-      const memory = createMemory({
+      const memory = store.store({
         agentId: workerId,
         scope: "agent",
         name: "Lead feedback: mistake-pattern — Never force-push to main branch",
@@ -302,10 +301,10 @@ describe("Self-Improvement Mechanisms", () => {
       });
 
       const embedding = new Float32Array([0.7, 0.3, 0.0]);
-      updateMemoryEmbedding(memory.id, serializeEmbedding(embedding));
+      store.updateEmbedding(memory.id, embedding, "test-model");
 
       // Worker can find it via search
-      const results = searchMemoriesByVector(new Float32Array([0.7, 0.3, 0.0]), workerId, {
+      const results = store.search(new Float32Array([0.7, 0.3, 0.0]), workerId, {
         isLead: false,
         scope: "agent",
       });
@@ -317,7 +316,7 @@ describe("Self-Improvement Mechanisms", () => {
 
     test("injected learning is NOT visible to other workers", () => {
       const content = "[Lead Feedback — preference]\n\nUse bun instead of npm";
-      const memory = createMemory({
+      const memory = store.store({
         agentId: workerId,
         scope: "agent",
         name: "Lead feedback: preference — Use bun instead of npm",
@@ -326,10 +325,10 @@ describe("Self-Improvement Mechanisms", () => {
       });
 
       const embedding = new Float32Array([0.2, 0.8, 0.1]);
-      updateMemoryEmbedding(memory.id, serializeEmbedding(embedding));
+      store.updateEmbedding(memory.id, embedding, "test-model");
 
       // Other worker should NOT see it
-      const results = searchMemoriesByVector(new Float32Array([0.2, 0.8, 0.1]), otherWorkerId, {
+      const results = store.search(new Float32Array([0.2, 0.8, 0.1]), otherWorkerId, {
         isLead: false,
         scope: "agent",
       });
@@ -355,26 +354,26 @@ describe("Self-Improvement Mechanisms", () => {
   describe("memory search agent ID security", () => {
     test("agent can only search their own memories (not others)", () => {
       // Create private memories for worker and other worker
-      const workerMemory = createMemory({
+      const workerMemory = store.store({
         agentId: workerId,
         scope: "agent",
         name: "Worker Private Secret",
         content: "My secret API key pattern",
         source: "manual",
       });
-      updateMemoryEmbedding(workerMemory.id, serializeEmbedding(new Float32Array([0.5, 0.5, 0.0])));
+      store.updateEmbedding(workerMemory.id, new Float32Array([0.5, 0.5, 0.0]), "test-model");
 
-      const otherMemory = createMemory({
+      const otherMemory = store.store({
         agentId: otherWorkerId,
         scope: "agent",
         name: "Other Worker Secret",
         content: "Other agent's private data",
         source: "manual",
       });
-      updateMemoryEmbedding(otherMemory.id, serializeEmbedding(new Float32Array([0.5, 0.5, 0.0])));
+      store.updateEmbedding(otherMemory.id, new Float32Array([0.5, 0.5, 0.0]), "test-model");
 
       // Worker searching with their own ID should see their memory but not other's
-      const workerResults = searchMemoriesByVector(new Float32Array([0.5, 0.5, 0.0]), workerId, {
+      const workerResults = store.search(new Float32Array([0.5, 0.5, 0.0]), workerId, {
         isLead: false,
         scope: "all",
       });

package/src/tests/tool-annotations.test.ts

@@ -178,8 +178,8 @@ describe("Tool Annotations & Classification", () => {
     expect(overlap).toEqual([]);
   });
 
-  test("CORE_TOOLS contains exactly 13 tools", () => {
-    expect(CORE_TOOLS.size).toBe(13);
+  test("CORE_TOOLS contains exactly 14 tools", () => {
+    expect(CORE_TOOLS.size).toBe(14);
   });
 
   test("ALL_TOOLS equals CORE_TOOLS union DEFERRED_TOOLS", () => {

package/src/tools/inject-learning.ts

@@ -1,7 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
-import { createMemory, getAgentById, updateMemoryEmbedding } from "@/be/db";
-import { getEmbedding, serializeEmbedding } from "@/be/embedding";
+import { getAgentById } from "@/be/db";
+import { getEmbeddingProvider, getMemoryStore } from "@/be/memory";
 import { createToolRegistrar } from "@/tools/utils";
 
 const LearningCategoryEnum = z.enum([
@@ -69,7 +69,8 @@ export const registerInjectLearningTool = (server: McpServer) => {
 
       // Create swarm-scoped memory — lead learnings are organizational knowledge visible to all workers
       const content = `[Lead Feedback — ${category}]\n\n${learning}`;
-      const memory = createMemory({
+      const store = getMemoryStore();
+      const memory = store.store({
         agentId: targetAgentId,
         scope: "swarm",
         name: `Lead feedback: ${category} — ${learning.slice(0, 60)}`,
@@ -79,9 +80,10 @@ export const registerInjectLearningTool = (server: McpServer) => {
 
       // Generate and store embedding (async, best-effort)
       try {
-        const embedding = await getEmbedding(content);
+        const provider = getEmbeddingProvider();
+        const embedding = await provider.embed(content);
         if (embedding) {
-          updateMemoryEmbedding(memory.id, serializeEmbedding(embedding));
+          store.updateEmbedding(memory.id, embedding, provider.name);
         }
       } catch {
         // Non-blocking — memory was created, embedding is optional

package/src/tools/memory-delete.ts

@@ -0,0 +1,89 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getAgentById } from "@/be/db";
+import { getMemoryStore } from "@/be/memory";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerMemoryDeleteTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "memory-delete",
+    {
+      title: "Delete a memory",
+      description:
+        "Delete a specific memory by its ID. Agents can delete their own memories; lead agents can also delete swarm-scoped memories.",
+      annotations: { destructiveHint: true },
+
+      inputSchema: z.object({
+        memoryId: z.uuid().describe("The ID of the memory to delete."),
+      }),
+      outputSchema: z.object({
+        yourAgentId: z.string().uuid().optional(),
+        success: z.boolean(),
+        message: z.string(),
+      }),
+    },
+    async ({ memoryId }, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: "Agent ID required to delete memories." }],
+          structuredContent: {
+            yourAgentId: undefined,
+            success: false,
+            message: "Agent ID required. Are you registered in the swarm?",
+          },
+        };
+      }
+
+      const store = getMemoryStore();
+      const memory = store.peek(memoryId);
+
+      if (!memory) {
+        return {
+          content: [{ type: "text", text: `Memory "${memoryId}" not found.` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `Memory "${memoryId}" not found.`,
+          },
+        };
+      }
+
+      // Permission check: own memories or lead can delete swarm-scoped
+      const isOwner = memory.agentId === requestInfo.agentId;
+      const agent = getAgentById(requestInfo.agentId);
+      const isLeadDeletingSwarm = agent?.isLead && memory.scope === "swarm";
+
+      if (!isOwner && !isLeadDeletingSwarm) {
+        return {
+          content: [{ type: "text", text: "You don't have permission to delete this memory." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message:
+              "Permission denied. You can only delete your own memories, or swarm memories if you are the lead.",
+          },
+        };
+      }
+
+      const deleted = store.delete(memoryId);
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: deleted
+              ? `Memory "${memoryId}" deleted.`
+              : `Failed to delete memory "${memoryId}".`,
+          },
+        ],
+        structuredContent: {
+          yourAgentId: requestInfo.agentId,
+          success: deleted,
+          message: deleted
+            ? `Memory "${memoryId}" deleted.`
+            : `Failed to delete memory "${memoryId}".`,
+        },
+      };
+    },
+  );
+};

package/src/tools/memory-get.ts

@@ -1,6 +1,6 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
-import { getMemoryById } from "@/be/db";
+import { getMemoryStore } from "@/be/memory";
 import { createToolRegistrar } from "@/tools/utils";
 import { AgentMemorySchema } from "@/types";
 
@@ -24,7 +24,7 @@ export const registerMemoryGetTool = (server: McpServer) => {
       }),
     },
     async ({ memoryId }, requestInfo, _meta) => {
-      const memory = getMemoryById(memoryId);
+      const memory = getMemoryStore().get(memoryId);
 
       if (!memory) {
         return {

package/src/tools/memory-search.ts

@@ -1,7 +1,9 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
-import { getAgentById, listMemoriesByAgent, searchMemoriesByVector } from "@/be/db";
-import { getEmbedding } from "@/be/embedding";
+import { getAgentById } from "@/be/db";
+import { getEmbeddingProvider, getMemoryStore } from "@/be/memory";
+import { CANDIDATE_SET_MULTIPLIER } from "@/be/memory/constants";
+import { rerank } from "@/be/memory/reranker";
 import { createToolRegistrar } from "@/tools/utils";
 import { AgentMemoryScopeSchema, AgentMemorySourceSchema } from "@/types";
 
@@ -60,17 +62,21 @@ export const registerMemorySearchTool = (server: McpServer) => {
       const isLead = agent?.isLead ?? false;
 
       // Try vector search first
-      const queryEmbedding = await getEmbedding(query);
+      const provider = getEmbeddingProvider();
+      const store = getMemoryStore();
+      const queryEmbedding = await provider.embed(query);
 
       if (queryEmbedding) {
-        const results = searchMemoriesByVector(queryEmbedding, requestInfo.agentId, {
+        const candidateLimit = limit * CANDIDATE_SET_MULTIPLIER;
+        const candidates = store.search(queryEmbedding, requestInfo.agentId, {
           scope: scope as "agent" | "swarm" | "all",
-          limit,
+          limit: candidateLimit,
           source,
           isLead,
         });
+        const ranked = rerank(candidates, { limit });
 
-        const mapped = results.map((r) => ({
+        const mapped = ranked.map((r) => ({
           id: r.id,
           name: r.name,
           summary: r.summary,
@@ -97,7 +103,7 @@ export const registerMemorySearchTool = (server: McpServer) => {
       }
 
       // Fallback: list recent memories (no OPENAI_API_KEY)
-      const recent = listMemoriesByAgent(requestInfo.agentId, {
+      const recent = store.list(requestInfo.agentId, {
         scope: scope as "agent" | "swarm" | "all",
         limit,
         isLead,

package/src/tools/store-progress.ts

@@ -3,7 +3,6 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import {
   completeTask,
-  createMemory,
   createSessionCost,
   createTaskExtended,
   failTask,
@@ -12,10 +11,9 @@ import {
   getLeadAgent,
   getTaskById,
   updateAgentStatusFromCapacity,
-  updateMemoryEmbedding,
   updateTaskProgress,
 } from "@/be/db";
-import { getEmbedding, serializeEmbedding } from "@/be/embedding";
+import { getEmbeddingProvider, getMemoryStore } from "@/be/memory";
 import { resolveTemplate } from "@/prompts/resolver";
 import { createToolRegistrar } from "@/tools/utils";
 import { AgentTaskSchema } from "@/types";
@@ -258,17 +256,20 @@ export const registerStoreProgressTool = (server: McpServer) => {
             // Skip indexing if there's truly no content
             if (taskContent.length < 30) return;
 
-            const memory = createMemory({
-              agentId: requestInfo.agentId,
+            const store = getMemoryStore();
+            const provider = getEmbeddingProvider();
+
+            const memory = store.store({
+              agentId: requestInfo.agentId ?? null,
               content: taskContent,
               name: `Task: ${result.task!.task.slice(0, 80)}`,
               scope: "agent",
               source: "task_completion",
               sourceTaskId: taskId,
             });
-            const embedding = await getEmbedding(taskContent);
+            const embedding = await provider.embed(taskContent);
             if (embedding) {
-              updateMemoryEmbedding(memory.id, serializeEmbedding(embedding));
+              store.updateEmbedding(memory.id, embedding, provider.name);
             }
 
             // Auto-promote high-value completions to swarm memory (P3)
@@ -280,17 +281,17 @@ export const registerStoreProgressTool = (server: McpServer) => {
 
             if (shouldShareWithSwarm) {
               try {
-                const swarmMemory = createMemory({
-                  agentId: requestInfo.agentId,
+                const swarmMemory = store.store({
+                  agentId: requestInfo.agentId ?? null,
                   scope: "swarm",
                   name: `Shared: ${result.task!.task.slice(0, 80)}`,
                   content: `Task completed by agent ${requestInfo.agentId}:\n\n${taskContent}`,
                   source: "task_completion",
                   sourceTaskId: taskId,
                 });
-                const swarmEmbedding = await getEmbedding(taskContent);
+                const swarmEmbedding = await provider.embed(taskContent);
                 if (swarmEmbedding) {
-                  updateMemoryEmbedding(swarmMemory.id, serializeEmbedding(swarmEmbedding));
+                  store.updateEmbedding(swarmMemory.id, swarmEmbedding, provider.name);
                 }
               } catch {
                 // Non-blocking — swarm memory promotion failure is not critical

package/src/tools/tool-config.ts

@@ -30,6 +30,7 @@ export const CORE_TOOLS = new Set([
   // Memory (used at session start)
   "memory-search", // recall relevant context
   "memory-get", // retrieve full memory content
+  "memory-delete", // delete own memories
 
   // Swarm awareness
   "get-swarm", // check who's online

package/src/types.ts

@@ -592,6 +592,9 @@ export const AgentMemorySchema = z.object({
   tags: z.array(z.string()),
   createdAt: z.string(),
   accessedAt: z.string(),
+  expiresAt: z.string().nullable().optional(),
+  accessCount: z.number().int().min(0).default(0).optional(),
+  embeddingModel: z.string().nullable().optional(),
 });
 
 export type AgentMemoryScope = z.infer<typeof AgentMemoryScopeSchema>;

package/tsconfig.json

@@ -0,0 +1,49 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "types": ["bun"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+
+    // Path aliases
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    },
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "exclude": [
+    "ui",
+    "new-ui",
+    "templates-ui",
+    "landing",
+    "node_modules",
+    "scripts",
+    "src/tests",
+    "work",
+    "logs",
+    "plugin",
+    "docs-site"
+  ]
+}