@desplega.ai/agent-swarm 1.64.0 → 1.65.0

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.64.0",
+    "version": "1.65.0",
     "description": "Multi-agent orchestration API for Claude Code, Codex, and Gemini CLI. Enables task distribution, agent communication, and service discovery.\n\nMCP tools are documented separately in [MCP.md](./MCP.md)."
   },
   "servers": [
@@ -2387,6 +2387,47 @@
         }
       }
     },
+    "/api/memory/re-embed": {
+      "post": {
+        "summary": "Re-embed all memories using the current embedding provider",
+        "tags": [
+          "Memory"
+        ],
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "agentId": {
+                    "type": "string",
+                    "format": "uuid",
+                    "description": "Re-embed only this agent's memories. Omit for all."
+                  },
+                  "batchSize": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 100,
+                    "default": 20,
+                    "description": "Memories per batch"
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "202": {
+            "description": "Re-embedding started"
+          }
+        }
+      }
+    },
     "/api/prompt-templates/resolved": {
       "get": {
         "summary": "Resolve a prompt template for a given event type and scope chain",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.64.0",
+  "version": "1.65.0",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",
@@ -23,6 +23,7 @@
   },
   "files": [
     "src/",
+    "tsconfig.json",
     "plugin/commands/",
     "plugin/agents/",
     "plugin/skills/",
@@ -121,6 +122,7 @@
     "openai": "^6.22.0",
     "react": "^19.2.3",
     "react-devtools-core": "^7.0.1",
+    "sqlite-vec": "^0.1.9",
     "svix": "^1.62.0",
     "viem": "^2.46.3",
     "zod": "^4.2.1",

package/src/be/db.ts

@@ -7,9 +7,6 @@ import type {
   AgentLog,
   AgentLogEventType,
   AgentMcpServer,
-  AgentMemory,
-  AgentMemoryScope,
-  AgentMemorySource,
   AgentSkill,
   AgentStatus,
   AgentTask,
@@ -64,6 +61,11 @@ import { runMigrations } from "./migrations/runner";
 import { seedDefaultTemplates } from "./seed";
 
 let db: Database | null = null;
+let sqliteVecAvailable = false;
+
+export function isSqliteVecAvailable(): boolean {
+  return sqliteVecAvailable;
+}
 
 export function initDb(dbPath = "./agent-swarm-db.sqlite"): Database {
   if (db) {
@@ -88,6 +90,19 @@ export function initDb(dbPath = "./agent-swarm-db.sqlite"): Database {
   database.run("PRAGMA journal_mode = WAL;");
   database.run("PRAGMA foreign_keys = ON;");
 
+  // Load sqlite-vec extension for vector search
+  try {
+    const sqliteVec = require("sqlite-vec");
+    sqliteVec.load(database);
+    sqliteVecAvailable = true;
+    console.log("[db] sqlite-vec loaded");
+  } catch (err) {
+    console.warn(
+      "[db] sqlite-vec not available, falling back to in-memory cosine:",
+      (err as Error).message,
+    );
+  }
+
   // Run database migrations (schema creation + incremental changes)
   runMigrations(database);
 
@@ -4684,293 +4699,6 @@ export function deleteSwarmRepo(id: string): boolean {
   return result.changes > 0;
 }
 
-// ============================================================================
-// Agent Memory Functions
-// ============================================================================
-
-type AgentMemoryRow = {
-  id: string;
-  agentId: string | null;
-  scope: string;
-  name: string;
-  content: string;
-  summary: string | null;
-  embedding: Buffer | null;
-  source: string;
-  sourceTaskId: string | null;
-  sourcePath: string | null;
-  chunkIndex: number;
-  totalChunks: number;
-  tags: string;
-  createdAt: string;
-  accessedAt: string;
-};
-
-function rowToAgentMemory(row: AgentMemoryRow): AgentMemory {
-  return {
-    id: row.id,
-    agentId: row.agentId,
-    scope: row.scope as AgentMemoryScope,
-    name: row.name,
-    content: row.content,
-    summary: row.summary,
-    source: row.source as AgentMemorySource,
-    sourceTaskId: row.sourceTaskId,
-    sourcePath: row.sourcePath,
-    chunkIndex: row.chunkIndex,
-    totalChunks: row.totalChunks,
-    tags: JSON.parse(row.tags || "[]"),
-    createdAt: row.createdAt,
-    accessedAt: row.accessedAt,
-  };
-}
-
-export interface CreateMemoryOptions {
-  agentId?: string | null;
-  scope: AgentMemoryScope;
-  name: string;
-  content: string;
-  summary?: string | null;
-  embedding?: Buffer | null;
-  source: AgentMemorySource;
-  sourceTaskId?: string | null;
-  sourcePath?: string | null;
-  chunkIndex?: number;
-  totalChunks?: number;
-  tags?: string[];
-}
-
-export function createMemory(data: CreateMemoryOptions): AgentMemory {
-  const id = crypto.randomUUID();
-  const now = new Date().toISOString();
-  const row = getDb()
-    .prepare<
-      AgentMemoryRow,
-      [
-        string,
-        string | null,
-        string,
-        string,
-        string,
-        string | null,
-        Buffer | null,
-        string,
-        string | null,
-        string | null,
-        number,
-        number,
-        string,
-        string,
-        string,
-      ]
-    >(
-      `INSERT INTO agent_memory (id, agentId, scope, name, content, summary, embedding, source, sourceTaskId, sourcePath, chunkIndex, totalChunks, tags, createdAt, accessedAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
-    )
-    .get(
-      id,
-      data.agentId ?? null,
-      data.scope,
-      data.name,
-      data.content,
-      data.summary ?? null,
-      data.embedding ?? null,
-      data.source,
-      data.sourceTaskId ?? null,
-      data.sourcePath ?? null,
-      data.chunkIndex ?? 0,
-      data.totalChunks ?? 1,
-      JSON.stringify(data.tags ?? []),
-      now,
-      now,
-    );
-
-  if (!row) throw new Error("Failed to create memory");
-  return rowToAgentMemory(row);
-}
-
-export function getMemoryById(id: string): AgentMemory | null {
-  const row = getDb()
-    .prepare<AgentMemoryRow, [string]>("SELECT * FROM agent_memory WHERE id = ?")
-    .get(id);
-  if (!row) return null;
-
-  // Update accessedAt
-  getDb()
-    .prepare("UPDATE agent_memory SET accessedAt = ? WHERE id = ?")
-    .run(new Date().toISOString(), id);
-
-  return rowToAgentMemory(row);
-}
-
-export function updateMemoryEmbedding(id: string, embedding: Buffer): void {
-  getDb().prepare("UPDATE agent_memory SET embedding = ? WHERE id = ?").run(embedding, id);
-}
-
-export interface SearchMemoriesOptions {
-  scope?: "agent" | "swarm" | "all";
-  limit?: number;
-  source?: AgentMemorySource;
-  isLead?: boolean;
-}
-
-export function searchMemoriesByVector(
-  queryEmbedding: Float32Array,
-  agentId: string,
-  options: SearchMemoriesOptions = {},
-): (AgentMemory & { similarity: number })[] {
-  const { scope = "all", limit = 10, source, isLead = false } = options;
-
-  // Build WHERE clause
-  const conditions: string[] = ["embedding IS NOT NULL"];
-  const params: (string | null)[] = [];
-
-  if (!isLead) {
-    // Workers see their own agent-scoped + all swarm-scoped
-    if (scope === "agent") {
-      conditions.push("agentId = ? AND scope = 'agent'");
-      params.push(agentId);
-    } else if (scope === "swarm") {
-      conditions.push("scope = 'swarm'");
-    } else {
-      // "all" - own agent + swarm
-      conditions.push("(agentId = ? OR scope = 'swarm')");
-      params.push(agentId);
-    }
-  } else {
-    // Leads see everything
-    if (scope === "agent") {
-      conditions.push("scope = 'agent'");
-    } else if (scope === "swarm") {
-      conditions.push("scope = 'swarm'");
-    }
-    // "all" for lead = no scope filter needed
-  }
-
-  if (source) {
-    conditions.push("source = ?");
-    params.push(source);
-  }
-
-  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-
-  const rows = getDb()
-    .prepare<AgentMemoryRow, (string | null)[]>(`SELECT * FROM agent_memory ${whereClause}`)
-    .all(...params);
-
-  // Import cosine similarity inline to avoid circular deps
-  const { cosineSimilarity, deserializeEmbedding } = require("./embedding");
-
-  // Compute similarities and sort
-  const results: (AgentMemory & { similarity: number })[] = [];
-  for (const row of rows) {
-    if (!row.embedding) continue;
-    const embedding = deserializeEmbedding(row.embedding);
-    // Skip embeddings with mismatched dimensions (can happen if embedding model changes)
-    if (embedding.length !== queryEmbedding.length) continue;
-    const similarity = cosineSimilarity(queryEmbedding, embedding) as number;
-    results.push({ ...rowToAgentMemory(row), similarity });
-  }
-
-  results.sort((a, b) => b.similarity - a.similarity);
-  return results.slice(0, limit);
-}
-
-export interface ListMemoriesOptions {
-  scope?: "agent" | "swarm" | "all";
-  limit?: number;
-  offset?: number;
-  isLead?: boolean;
-}
-
-export function listMemoriesByAgent(
-  agentId: string,
-  options: ListMemoriesOptions = {},
-): AgentMemory[] {
-  const { scope = "all", limit = 20, offset = 0, isLead = false } = options;
-
-  const conditions: string[] = [];
-  const params: (string | number)[] = [];
-
-  if (!isLead) {
-    if (scope === "agent") {
-      conditions.push("agentId = ? AND scope = 'agent'");
-      params.push(agentId);
-    } else if (scope === "swarm") {
-      conditions.push("scope = 'swarm'");
-    } else {
-      conditions.push("(agentId = ? OR scope = 'swarm')");
-      params.push(agentId);
-    }
-  } else {
-    if (scope === "agent") {
-      conditions.push("scope = 'agent'");
-    } else if (scope === "swarm") {
-      conditions.push("scope = 'swarm'");
-    }
-  }
-
-  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-
-  params.push(limit, offset);
-
-  const rows = getDb()
-    .prepare<AgentMemoryRow, (string | number)[]>(
-      `SELECT * FROM agent_memory ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
-    )
-    .all(...params);
-
-  return rows.map(rowToAgentMemory);
-}
-
-export function deleteMemoriesBySourcePath(sourcePath: string, agentId: string): number {
-  const result = getDb()
-    .prepare("DELETE FROM agent_memory WHERE sourcePath = ? AND agentId = ?")
-    .run(sourcePath, agentId);
-  return result.changes;
-}
-
-export function deleteMemory(id: string): boolean {
-  const result = getDb().prepare("DELETE FROM agent_memory WHERE id = ?").run(id);
-  return result.changes > 0;
-}
-
-export function getMemoryStats(agentId: string): {
-  total: number;
-  bySource: Record<string, number>;
-  byScope: Record<string, number>;
-} {
-  const total = getDb()
-    .prepare<{ count: number }, [string]>(
-      "SELECT COUNT(*) as count FROM agent_memory WHERE agentId = ?",
-    )
-    .get(agentId);
-
-  const bySourceRows = getDb()
-    .prepare<{ source: string; count: number }, [string]>(
-      "SELECT source, COUNT(*) as count FROM agent_memory WHERE agentId = ? GROUP BY source",
-    )
-    .all(agentId);
-
-  const byScopeRows = getDb()
-    .prepare<{ scope: string; count: number }, [string]>(
-      "SELECT scope, COUNT(*) as count FROM agent_memory WHERE agentId = ? GROUP BY scope",
-    )
-    .all(agentId);
-
-  const bySource: Record<string, number> = {};
-  for (const row of bySourceRows) {
-    bySource[row.source] = row.count;
-  }
-
-  const byScope: Record<string, number> = {};
-  for (const row of byScopeRows) {
-    byScope[row.scope] = row.count;
-  }
-
-  return { total: total?.count ?? 0, bySource, byScope };
-}
-
 // ============================================================================
 // AgentMail Inbox Mapping Queries
 // ============================================================================

package/src/be/embedding.ts

@@ -1,41 +1,3 @@
-import OpenAI from "openai";
-
-let openai: OpenAI | null = null;
-
-function getClient(): OpenAI | null {
-  if (!process.env.OPENAI_API_KEY) return null;
-  if (!openai) openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
-  return openai;
-}
-
-/**
- * Generate an embedding vector for the given text using OpenAI text-embedding-3-small (512 dims).
- * Returns null if OPENAI_API_KEY is not set or the API call fails.
- */
-export async function getEmbedding(text: string): Promise<Float32Array | null> {
-  const client = getClient();
-  if (!client) return null;
-
-  try {
-    const cleaned = text.replace(/[\n\r]/g, " ").trim();
-    if (!cleaned) return null;
-
-    const response = await client.embeddings.create({
-      model: "text-embedding-3-small",
-      input: cleaned,
-      dimensions: 512,
-    });
-
-    const values = response.data[0]?.embedding;
-    if (!values) return null;
-
-    return new Float32Array(values);
-  } catch (err) {
-    console.error("[memory] Embedding failed:", (err as Error).message);
-    return null;
-  }
-}
-
 /**
  * Compute cosine similarity between two Float32Array vectors.
  * Returns a value between -1 and 1 (1 = identical, 0 = orthogonal, -1 = opposite).

package/src/be/memory/constants.ts

@@ -0,0 +1,26 @@
+import type { AgentMemorySource } from "@/types";
+
+function numEnv(key: string, fallback: number): number {
+  const val = process.env[key];
+  if (val === undefined) return fallback;
+  const parsed = Number(val);
+  return Number.isNaN(parsed) ? fallback : parsed;
+}
+
+// TTL defaults (in days) — null means no expiry
+export const TTL_DEFAULTS: Record<AgentMemorySource, number | null> = {
+  task_completion: 7,
+  session_summary: 3,
+  file_index: 30,
+  manual: null,
+};
+
+// Reranking parameters
+export const RECENCY_DECAY_HALF_LIFE_DAYS = numEnv("MEMORY_RECENCY_HALF_LIFE_DAYS", 14);
+export const ACCESS_BOOST_MAX_MULTIPLIER = numEnv("MEMORY_ACCESS_BOOST_MAX", 1.5);
+export const ACCESS_BOOST_RECENCY_WINDOW_HOURS = numEnv("MEMORY_ACCESS_RECENCY_HOURS", 48);
+export const CANDIDATE_SET_MULTIPLIER = numEnv("MEMORY_CANDIDATE_MULTIPLIER", 3);
+
+// Embedding defaults
+export const DEFAULT_EMBEDDING_DIMENSIONS = 512;
+export const DEFAULT_EMBEDDING_MODEL = "openai/text-embedding-3-small";

package/src/be/memory/index.ts

@@ -0,0 +1,22 @@
+import type { EmbeddingProvider, MemoryStore } from "./types";
+
+let embeddingProvider: EmbeddingProvider | null = null;
+let memoryStore: MemoryStore | null = null;
+
+export function getEmbeddingProvider(): EmbeddingProvider {
+  if (!embeddingProvider) {
+    const { OpenAIEmbeddingProvider } =
+      require("./providers/openai-embedding") as typeof import("./providers/openai-embedding");
+    embeddingProvider = new OpenAIEmbeddingProvider();
+  }
+  return embeddingProvider;
+}
+
+export function getMemoryStore(): MemoryStore {
+  if (!memoryStore) {
+    const { SqliteMemoryStore } =
+      require("./providers/sqlite-store") as typeof import("./providers/sqlite-store");
+    memoryStore = new SqliteMemoryStore();
+  }
+  return memoryStore;
+}

package/src/be/memory/providers/openai-embedding.ts

@@ -0,0 +1,94 @@
+import OpenAI from "openai";
+import { DEFAULT_EMBEDDING_DIMENSIONS, DEFAULT_EMBEDDING_MODEL } from "../constants";
+import type { EmbeddingProvider } from "../types";
+
+interface OpenAIEmbeddingConfig {
+  apiKey?: string;
+  model?: string;
+  dimensions?: number;
+}
+
+export class OpenAIEmbeddingProvider implements EmbeddingProvider {
+  readonly name: string;
+  readonly dimensions: number;
+
+  private client: OpenAI | null = null;
+  private readonly model: string;
+  private readonly apiKey: string | undefined;
+
+  constructor(config?: OpenAIEmbeddingConfig) {
+    this.apiKey = config?.apiKey ?? process.env.OPENAI_API_KEY;
+    this.model = config?.model ?? "text-embedding-3-small";
+    this.dimensions = config?.dimensions ?? DEFAULT_EMBEDDING_DIMENSIONS;
+    this.name = config?.model ? `openai/${config.model}` : DEFAULT_EMBEDDING_MODEL;
+  }
+
+  private getClient(): OpenAI | null {
+    if (!this.apiKey) return null;
+    if (!this.client) this.client = new OpenAI({ apiKey: this.apiKey });
+    return this.client;
+  }
+
+  async embed(text: string): Promise<Float32Array | null> {
+    const client = this.getClient();
+    if (!client) return null;
+
+    try {
+      const cleaned = text.replace(/[\n\r]/g, " ").trim();
+      if (!cleaned) return null;
+
+      const response = await client.embeddings.create({
+        model: this.model,
+        input: cleaned,
+        dimensions: this.dimensions,
+      });
+
+      const values = response.data[0]?.embedding;
+      if (!values) return null;
+
+      return new Float32Array(values);
+    } catch (err) {
+      console.error("[memory] Embedding failed:", (err as Error).message);
+      return null;
+    }
+  }
+
+  async embedBatch(texts: string[]): Promise<(Float32Array | null)[]> {
+    const client = this.getClient();
+    if (!client) return texts.map(() => null);
+
+    const cleaned = texts.map((t) => t.replace(/[\n\r]/g, " ").trim());
+    const nonEmptyIndices: number[] = [];
+    const nonEmptyTexts: string[] = [];
+
+    for (let i = 0; i < cleaned.length; i++) {
+      if (cleaned[i]) {
+        nonEmptyIndices.push(i);
+        nonEmptyTexts.push(cleaned[i]!);
+      }
+    }
+
+    if (nonEmptyTexts.length === 0) return texts.map(() => null);
+
+    try {
+      const response = await client.embeddings.create({
+        model: this.model,
+        input: nonEmptyTexts,
+        dimensions: this.dimensions,
+      });
+
+      const results: (Float32Array | null)[] = texts.map(() => null);
+      for (const item of response.data) {
+        const originalIndex = nonEmptyIndices[item.index];
+        if (originalIndex !== undefined && item.embedding) {
+          results[originalIndex] = new Float32Array(item.embedding);
+        }
+      }
+
+      return results;
+    } catch (err) {
+      console.error("[memory] Batch embedding failed:", (err as Error).message);
+      return texts.map(() => null);
+    }
+  }
+}