@desplega.ai/agent-swarm 1.64.1 → 1.66.0

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.64.0",
+    "version": "1.66.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.1",
+  "version": "1.66.0",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",
@@ -122,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

@@ -1,4 +1,5 @@
 import { Database } from "bun:sqlite";
+import pkg from "../../package.json";
 import { addEyesReactionOnTaskStart } from "../github/task-reactions";
 import { configureDbResolver } from "../prompts/resolver";
 import type {
@@ -7,9 +8,6 @@ import type {
   AgentLog,
   AgentLogEventType,
   AgentMcpServer,
-  AgentMemory,
-  AgentMemoryScope,
-  AgentMemorySource,
   AgentSkill,
   AgentStatus,
   AgentTask,
@@ -64,6 +62,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 +91,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);
 
@@ -749,6 +765,7 @@ type AgentTaskRow = {
   credentialKeySuffix: string | null;
   credentialKeyType: string | null;
   requestedByUserId: string | null;
+  swarmVersion: string | null;
 };
 
 function rowToAgentTask(row: AgentTaskRow): AgentTask {
@@ -808,6 +825,7 @@ function rowToAgentTask(row: AgentTaskRow): AgentTask {
     credentialKeySuffix: row.credentialKeySuffix ?? undefined,
     credentialKeyType: row.credentialKeyType ?? undefined,
     requestedByUserId: row.requestedByUserId ?? undefined,
+    swarmVersion: row.swarmVersion ?? undefined,
   };
 }
 
@@ -824,10 +842,11 @@ export const taskQueries = {
         string | null,
         string | null,
         string | null,
+        string,
       ]
     >(
-      `INSERT INTO agent_tasks (id, agentId, task, status, source, slackChannelId, slackThreadTs, slackUserId, createdAt, lastUpdatedAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) RETURNING *`,
+      `INSERT INTO agent_tasks (id, agentId, task, status, source, slackChannelId, slackThreadTs, slackUserId, swarmVersion, createdAt, lastUpdatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'), strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) RETURNING *`,
     ),
 
   getById: () => getDb().prepare<AgentTaskRow, [string]>("SELECT * FROM agent_tasks WHERE id = ?"),
@@ -898,6 +917,7 @@ export function createTask(
       options?.slackChannelId ?? null,
       options?.slackThreadTs ?? null,
       options?.slackUserId ?? null,
+      pkg.version,
     );
   if (!row) throw new Error("Failed to create task");
   try {
@@ -1937,8 +1957,8 @@ export function createTaskExtended(task: string, options?: CreateTaskOptions): A
         vcsInstallationId, vcsNodeId,
         agentmailInboxId, agentmailMessageId, agentmailThreadId,
         mentionMessageId, mentionChannelId, dir, parentTaskId, model, scheduleId,
-        workflowRunId, workflowRunStepId, outputSchema, requestedByUserId, createdAt, lastUpdatedAt
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+        workflowRunId, workflowRunStepId, outputSchema, requestedByUserId, swarmVersion, createdAt, lastUpdatedAt
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
     )
     .get(
       id,
@@ -1978,6 +1998,7 @@ export function createTaskExtended(task: string, options?: CreateTaskOptions): A
       options?.workflowRunStepId ?? null,
       options?.outputSchema ? JSON.stringify(options.outputSchema) : null,
       options?.requestedByUserId ?? null,
+      pkg.version,
       now,
       now,
     );
@@ -4684,293 +4705,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);
+    }
+  }
+}