@agentskit/memory 0.5.5 → 0.7.0

package/dist/index.cjs

@@ -89,6 +89,78 @@ function sqliteChatMemory(config) {
     }
   };
 }
+var cachedSdk = null;
+async function loadSdk() {
+  if (!cachedSdk) {
+    cachedSdk = (async () => {
+      try {
+        const moduleId = "@libsql/client";
+        return await import(
+          /* @vite-ignore */
+          moduleId
+        );
+      } catch {
+        throw new Error("Install @libsql/client to use tursoChatMemory: npm install @libsql/client");
+      }
+    })();
+  }
+  return cachedSdk;
+}
+function encodeMessages2(messages) {
+  return JSON.stringify(core.serializeMessages(messages));
+}
+function decodeMessages2(json) {
+  if (!json) return [];
+  try {
+    return core.deserializeMessages(JSON.parse(json));
+  } catch {
+    return [];
+  }
+}
+function tursoChatMemory(config) {
+  const conversationId = config.conversationId ?? "default";
+  let clientPromise = null;
+  const getClient = async () => {
+    if (!clientPromise) {
+      clientPromise = (async () => {
+        const sdk = await loadSdk();
+        const client = sdk.createClient({ url: config.url, authToken: config.authToken });
+        await client.execute({
+          sql: "CREATE TABLE IF NOT EXISTS conversations (id TEXT PRIMARY KEY, messages TEXT NOT NULL)"
+        });
+        return client;
+      })();
+    }
+    return clientPromise;
+  };
+  return {
+    async load() {
+      const client = await getClient();
+      const result = await client.execute({
+        sql: "SELECT messages FROM conversations WHERE id = ?",
+        args: [conversationId]
+      });
+      const row = result.rows[0];
+      return decodeMessages2(row?.messages);
+    },
+    async save(messages) {
+      const client = await getClient();
+      const json = encodeMessages2(messages);
+      await client.execute({
+        sql: `INSERT INTO conversations (id, messages) VALUES (?, ?)
+              ON CONFLICT(id) DO UPDATE SET messages = excluded.messages`,
+        args: [conversationId, json]
+      });
+    },
+    async clear() {
+      const client = await getClient();
+      await client.execute({
+        sql: "DELETE FROM conversations WHERE id = ?",
+        args: [conversationId]
+      });
+    }
+  };
+}
 
 // src/redis-client.ts
 async function createRedisClientAdapter(url) {
@@ -124,10 +196,10 @@ async function createRedisClientAdapter(url) {
 }
 
 // src/redis-chat.ts
-function encodeMessages2(messages) {
+function encodeMessages3(messages) {
   return JSON.stringify(core.serializeMessages(messages));
 }
-function decodeMessages2(json) {
+function decodeMessages3(json) {
   if (!json) return [];
   try {
     return core.deserializeMessages(JSON.parse(json));
@@ -149,11 +221,11 @@ function redisChatMemory(config) {
     async load() {
       const client = await getClient();
       const json = await client.get(key);
-      return decodeMessages2(json);
+      return decodeMessages3(json);
     },
     async save(messages) {
       const client = await getClient();
-      await client.set(key, encodeMessages2(messages));
+      await client.set(key, encodeMessages3(messages));
     },
     async clear() {
       const client = await getClient();
@@ -283,6 +355,40 @@ function redisVectorMemory(config) {
   };
 }
 
+// src/vector/filter.ts
+function isPrimitive(value) {
+  const t = typeof value;
+  return value === null || t === "string" || t === "number" || t === "boolean";
+}
+function evalOperator(actual, op) {
+  if ("$eq" in op) return actual === op.$eq;
+  if ("$ne" in op) return actual !== op.$ne;
+  if ("$in" in op) return op.$in.includes(actual);
+  if ("$nin" in op) return !op.$nin.includes(actual);
+  if ("$gt" in op) return actual > op.$gt;
+  if ("$gte" in op) return actual >= op.$gte;
+  if ("$lt" in op) return actual < op.$lt;
+  if ("$lte" in op) return actual <= op.$lte;
+  if ("$exists" in op) return actual !== void 0 === op.$exists;
+  return false;
+}
+function evalPredicate(actual, predicate) {
+  if (isPrimitive(predicate)) return actual === predicate;
+  return evalOperator(actual, predicate);
+}
+function matchesFilter(metadata, filter) {
+  if (!filter) return true;
+  const meta = metadata ?? {};
+  const compound = filter;
+  if (compound.$and) return compound.$and.every((f) => matchesFilter(meta, f));
+  if (compound.$or) return compound.$or.some((f) => matchesFilter(meta, f));
+  for (const [field, predicate] of Object.entries(filter)) {
+    if (field.startsWith("$")) continue;
+    if (!evalPredicate(meta[field], predicate)) return false;
+  }
+  return true;
+}
+
 // src/file-vector.ts
 function requireVectra() {
   try {
@@ -351,8 +457,9 @@ function fileVectorMemory(config) {
     async search(embedding, options) {
       const topK = options?.topK ?? 5;
       const threshold = options?.threshold ?? 0;
-      const results = await store.query(embedding, topK);
-      return results.filter((r) => r.score >= threshold).map((r) => ({
+      const fetchK = options?.filter ? Math.max(topK * 4, 50) : topK;
+      const results = await store.query(embedding, fetchK);
+      return results.filter((r) => r.score >= threshold).filter((r) => matchesFilter(r.metadata, options?.filter)).slice(0, topK).map((r) => ({
         id: r.id,
         content: String(r.metadata.content ?? contentCache.get(r.id) ?? ""),
         score: r.score,
@@ -366,10 +473,598 @@ function fileVectorMemory(config) {
   };
 }
 
+// src/personalization.ts
+function createInMemoryPersonalization() {
+  const profiles = /* @__PURE__ */ new Map();
+  return {
+    async get(subjectId) {
+      const hit = profiles.get(subjectId);
+      return hit ? { ...hit, traits: { ...hit.traits } } : null;
+    },
+    async set(profile) {
+      profiles.set(profile.subjectId, {
+        ...profile,
+        traits: { ...profile.traits },
+        updatedAt: profile.updatedAt || (/* @__PURE__ */ new Date()).toISOString()
+      });
+    },
+    async merge(subjectId, traits) {
+      const existing = profiles.get(subjectId);
+      const next = {
+        subjectId,
+        traits: { ...existing?.traits ?? {}, ...traits },
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      profiles.set(subjectId, next);
+      return { ...next, traits: { ...next.traits } };
+    },
+    async delete(subjectId) {
+      profiles.delete(subjectId);
+    }
+  };
+}
+function renderProfileContext(profile) {
+  if (!profile || Object.keys(profile.traits).length === 0) return "";
+  const lines = Object.entries(profile.traits).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => `- ${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`);
+  if (lines.length === 0) return "";
+  return `## User profile
+${lines.join("\n")}`;
+}
+
+// src/graph.ts
+function createInMemoryGraph() {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const matchesNode = (node, query) => {
+    if (!query) return true;
+    if (query.kind && node.kind !== query.kind) return false;
+    return true;
+  };
+  const matchesEdge = (edge, query) => {
+    if (!query) return true;
+    if (query.label && edge.label !== query.label) return false;
+    if (query.from && edge.from !== query.from) return false;
+    if (query.to && edge.to !== query.to) return false;
+    return true;
+  };
+  return {
+    async upsertNode(node) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const existing = nodes.get(node.id);
+      const merged = {
+        ...existing ?? {},
+        ...node,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now
+      };
+      nodes.set(node.id, merged);
+      return merged;
+    },
+    async upsertEdge(edge) {
+      edges.set(edge.id, edge);
+      return edge;
+    },
+    async getNode(id) {
+      const hit = nodes.get(id);
+      return hit ? { ...hit } : null;
+    },
+    async findNodes(query) {
+      return Array.from(nodes.values()).filter((n) => matchesNode(n, query)).map((n) => ({ ...n }));
+    },
+    async findEdges(query) {
+      return Array.from(edges.values()).filter((e) => matchesEdge(e, query)).map((e) => ({ ...e }));
+    },
+    async neighbors(id, options = {}) {
+      const depth = Math.max(1, options.depth ?? 1);
+      const visited = /* @__PURE__ */ new Set([id]);
+      let frontier = /* @__PURE__ */ new Set([id]);
+      for (let i = 0; i < depth; i++) {
+        const next = /* @__PURE__ */ new Set();
+        for (const edge of edges.values()) {
+          if (options.label && edge.label !== options.label) continue;
+          if (frontier.has(edge.from) && !visited.has(edge.to)) next.add(edge.to);
+          if (frontier.has(edge.to) && !visited.has(edge.from)) next.add(edge.from);
+        }
+        for (const n of next) visited.add(n);
+        frontier = next;
+        if (next.size === 0) break;
+      }
+      visited.delete(id);
+      return Array.from(visited, (nid) => nodes.get(nid)).filter((n) => Boolean(n)).map((n) => ({ ...n }));
+    },
+    async deleteNode(id) {
+      nodes.delete(id);
+      for (const [eid, edge] of edges) {
+        if (edge.from === id || edge.to === id) edges.delete(eid);
+      }
+    },
+    async deleteEdge(id) {
+      edges.delete(id);
+    },
+    async clear() {
+      nodes.clear();
+      edges.clear();
+    }
+  };
+}
+
+// src/vector/pgvector.ts
+function formatVector(embedding) {
+  return `[${embedding.join(",")}]`;
+}
+function pgvector(config) {
+  const table = config.table ?? "agentskit_vectors";
+  const defaultTopK = Math.max(1, config.topK ?? 10);
+  return {
+    async store(docs) {
+      if (docs.length === 0) return;
+      const values = [];
+      const placeholders = docs.map((doc, i) => {
+        const base = i * 4;
+        values.push(doc.id, doc.content, formatVector(doc.embedding), JSON.stringify(doc.metadata ?? {}));
+        return `($${base + 1}, $${base + 2}, $${base + 3}::vector, $${base + 4}::jsonb)`;
+      }).join(", ");
+      await config.runner.query(
+        `INSERT INTO ${table} (id, content, embedding, metadata) VALUES ${placeholders}
+         ON CONFLICT (id) DO UPDATE SET content = EXCLUDED.content, embedding = EXCLUDED.embedding, metadata = EXCLUDED.metadata`,
+        values
+      );
+    },
+    async search(embedding, options = {}) {
+      const topK = options.topK ?? defaultTopK;
+      const threshold = options.threshold ?? 0;
+      const { rows } = await config.runner.query(
+        `SELECT id, content, metadata, (embedding <=> $1::vector) AS distance
+         FROM ${table}
+         ORDER BY embedding <=> $1::vector
+         LIMIT $2`,
+        [formatVector(embedding), topK]
+      );
+      return rows.map((r) => ({
+        id: r.id,
+        content: r.content,
+        metadata: r.metadata ?? void 0,
+        score: 1 - r.distance
+      })).filter((r) => (r.score ?? 0) >= threshold);
+    },
+    async delete(ids) {
+      if (ids.length === 0) return;
+      const placeholders = ids.map((_, i) => `$${i + 1}`).join(",");
+      await config.runner.query(`DELETE FROM ${table} WHERE id IN (${placeholders})`, ids);
+    }
+  };
+}
+
+// src/vector/pinecone.ts
+async function call(config, path, body) {
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(`${config.indexUrl}${path}`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "api-key": config.apiKey
+    },
+    body: JSON.stringify(body)
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`pinecone ${response.status}: ${text.slice(0, 200)}`);
+  return text.length > 0 ? JSON.parse(text) : {};
+}
+function pinecone(config) {
+  const defaultTopK = Math.max(1, config.topK ?? 10);
+  const namespace = config.namespace ?? "";
+  return {
+    async store(docs) {
+      if (docs.length === 0) return;
+      await call(config, "/vectors/upsert", {
+        namespace,
+        vectors: docs.map((d) => ({
+          id: d.id,
+          values: d.embedding,
+          metadata: { content: d.content, ...d.metadata ?? {} }
+        }))
+      });
+    },
+    async search(embedding, options = {}) {
+      const topK = options.topK ?? defaultTopK;
+      const threshold = options.threshold ?? 0;
+      const result = await call(config, "/query", {
+        namespace,
+        topK,
+        vector: embedding,
+        includeMetadata: true
+      });
+      return (result.matches ?? []).filter((m) => m.score >= threshold).map((m) => ({
+        id: m.id,
+        content: String((m.metadata ?? {}).content ?? ""),
+        metadata: m.metadata,
+        score: m.score
+      }));
+    },
+    async delete(ids) {
+      if (ids.length === 0) return;
+      await call(config, "/vectors/delete", { namespace, ids });
+    }
+  };
+}
+
+// src/vector/qdrant.ts
+async function call2(config, method, path, body) {
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(`${config.url}${path}`, {
+    method,
+    headers: {
+      "content-type": "application/json",
+      ...config.apiKey ? { "api-key": config.apiKey } : {}
+    },
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`qdrant ${response.status}: ${text.slice(0, 200)}`);
+  return text.length > 0 ? JSON.parse(text) : {};
+}
+function qdrant(config) {
+  const defaultTopK = Math.max(1, config.topK ?? 10);
+  return {
+    async store(docs) {
+      if (docs.length === 0) return;
+      await call2(config, "PUT", `/collections/${config.collection}/points`, {
+        points: docs.map((d) => ({
+          id: d.id,
+          vector: d.embedding,
+          payload: { content: d.content, ...d.metadata ?? {} }
+        }))
+      });
+    },
+    async search(embedding, options = {}) {
+      const topK = options.topK ?? defaultTopK;
+      const threshold = options.threshold ?? 0;
+      const result = await call2(config, "POST", `/collections/${config.collection}/points/search`, {
+        vector: embedding,
+        limit: topK,
+        with_payload: true
+      });
+      return (result.result ?? []).filter((m) => m.score >= threshold).map((m) => ({
+        id: String(m.id),
+        content: String((m.payload ?? {}).content ?? ""),
+        metadata: m.payload,
+        score: m.score
+      }));
+    },
+    async delete(ids) {
+      if (ids.length === 0) return;
+      await call2(config, "POST", `/collections/${config.collection}/points/delete`, {
+        points: ids
+      });
+    }
+  };
+}
+
+// src/vector/chroma.ts
+async function call3(config, method, path, body) {
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(`${config.url}${path}`, {
+    method,
+    headers: { "content-type": "application/json" },
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`chroma ${response.status}: ${text.slice(0, 200)}`);
+  return text.length > 0 ? JSON.parse(text) : {};
+}
+function chroma(config) {
+  const defaultTopK = Math.max(1, config.topK ?? 10);
+  return {
+    async store(docs) {
+      if (docs.length === 0) return;
+      await call3(config, "POST", `/api/v1/collections/${config.collection}/upsert`, {
+        ids: docs.map((d) => d.id),
+        embeddings: docs.map((d) => d.embedding),
+        documents: docs.map((d) => d.content),
+        metadatas: docs.map((d) => d.metadata ?? {})
+      });
+    },
+    async search(embedding, options = {}) {
+      const topK = options.topK ?? defaultTopK;
+      const threshold = options.threshold ?? 0;
+      const result = await call3(config, "POST", `/api/v1/collections/${config.collection}/query`, {
+        query_embeddings: [embedding],
+        n_results: topK
+      });
+      const ids = result.ids?.[0] ?? [];
+      const documents = result.documents?.[0] ?? [];
+      const metadatas = result.metadatas?.[0] ?? [];
+      const distances = result.distances?.[0] ?? [];
+      return ids.map((id, i) => ({
+        id,
+        content: documents[i] ?? "",
+        metadata: metadatas[i],
+        score: distances[i] !== void 0 ? 1 - distances[i] : 0
+      })).filter((r) => (r.score ?? 0) >= threshold);
+    },
+    async delete(ids) {
+      if (ids.length === 0) return;
+      await call3(config, "POST", `/api/v1/collections/${config.collection}/delete`, { ids });
+    }
+  };
+}
+
+// src/vector/upstash.ts
+async function call4(config, path, body) {
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(`${config.url}${path}`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${config.token}`
+    },
+    body: JSON.stringify(body)
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`upstash-vector ${response.status}: ${text.slice(0, 200)}`);
+  return text.length > 0 ? JSON.parse(text) : {};
+}
+function upstashVector(config) {
+  const defaultTopK = Math.max(1, config.topK ?? 10);
+  return {
+    async store(docs) {
+      if (docs.length === 0) return;
+      await call4(
+        config,
+        "/upsert",
+        docs.map((d) => ({
+          id: d.id,
+          vector: d.embedding,
+          metadata: { content: d.content, ...d.metadata ?? {} }
+        }))
+      );
+    },
+    async search(embedding, options = {}) {
+      const topK = options.topK ?? defaultTopK;
+      const threshold = options.threshold ?? 0;
+      const result = await call4(config, "/query", { vector: embedding, topK, includeMetadata: true });
+      return (result.result ?? []).filter((m) => m.score >= threshold).map((m) => ({
+        id: m.id,
+        content: String((m.metadata ?? {}).content ?? ""),
+        metadata: m.metadata,
+        score: m.score
+      }));
+    },
+    async delete(ids) {
+      if (ids.length === 0) return;
+      await call4(config, "/delete", { ids });
+    }
+  };
+}
+
+// src/vector/supabase.ts
+var cachedSdk2 = null;
+async function loadSdk2() {
+  if (!cachedSdk2) {
+    cachedSdk2 = (async () => {
+      try {
+        const moduleId = "@supabase/supabase-js";
+        return await import(
+          /* @vite-ignore */
+          moduleId
+        );
+      } catch {
+        throw new Error(
+          "Install @supabase/supabase-js to use supabaseVectorStore: npm install @supabase/supabase-js"
+        );
+      }
+    })();
+  }
+  return cachedSdk2;
+}
+function buildRunner(client) {
+  return {
+    async query(sql, params) {
+      const result = await client.rpc("agentskit_execute_sql", { sql, params });
+      if (result.error) throw new Error(`supabase: ${result.error.message}`);
+      return { rows: result.data ?? [] };
+    }
+  };
+}
+function supabaseVectorStore(config) {
+  let runnerPromise = null;
+  const getRunner = () => {
+    if (!runnerPromise) {
+      runnerPromise = (async () => {
+        const sdk = await loadSdk2();
+        const client = sdk.createClient(config.url, config.serviceRoleKey);
+        return buildRunner(client);
+      })();
+    }
+    return runnerPromise;
+  };
+  let backend = null;
+  const getBackend = async () => {
+    if (!backend) {
+      const runner = await getRunner();
+      backend = pgvector({
+        runner,
+        table: config.table,
+        topK: config.topK
+      });
+    }
+    return backend;
+  };
+  return {
+    async store(docs) {
+      const b = await getBackend();
+      return b.store(docs);
+    },
+    async search(embedding, options) {
+      const b = await getBackend();
+      return b.search(embedding, options);
+    },
+    async delete(ids) {
+      const b = await getBackend();
+      return b.delete?.(ids);
+    }
+  };
+}
+
+// src/encrypted.ts
+function toBase64(bytes) {
+  if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
+  let binary = "";
+  for (const b of bytes) binary += String.fromCharCode(b);
+  return btoa(binary);
+}
+function fromBase64(value) {
+  if (typeof Buffer !== "undefined") return new Uint8Array(Buffer.from(value, "base64"));
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+async function resolveKey(subtle, material) {
+  if ("type" in material && material.type === "secret") return material;
+  const raw = material;
+  if (raw.byteLength !== 32) {
+    throw new Error(`createEncryptedMemory: key must be 32 bytes (got ${raw.byteLength})`);
+  }
+  return subtle.importKey("raw", raw, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+}
+async function createEncryptedMemory(options) {
+  const subtle = options.subtle ?? globalThis.crypto?.subtle;
+  const random = options.getRandomValues ?? ((v) => globalThis.crypto.getRandomValues(v));
+  if (!subtle) throw new Error("createEncryptedMemory: SubtleCrypto not available");
+  const key = await resolveKey(subtle, options.key);
+  const aad = options.aad;
+  const encrypt = async (plain) => {
+    const iv = random(new Uint8Array(12));
+    const data = new TextEncoder().encode(plain);
+    const params = aad ? { name: "AES-GCM", iv, additionalData: aad } : { name: "AES-GCM", iv };
+    const cipher = await subtle.encrypt(params, key, data);
+    return {
+      ciphertext: toBase64(new Uint8Array(cipher)),
+      iv: toBase64(iv),
+      length: plain.length
+    };
+  };
+  const decrypt = async (envelope) => {
+    const iv = fromBase64(envelope.iv);
+    const params = aad ? { name: "AES-GCM", iv, additionalData: aad } : { name: "AES-GCM", iv };
+    const plain = await subtle.decrypt(params, key, fromBase64(envelope.ciphertext));
+    return new TextDecoder().decode(plain);
+  };
+  const encryptMessage = async (m) => {
+    if (m.metadata?.agentskitEncrypted) return m;
+    const envelope = await encrypt(m.content ?? "");
+    return {
+      ...m,
+      content: "",
+      metadata: {
+        ...m.metadata ?? {},
+        agentskitEncrypted: true,
+        ciphertext: envelope.ciphertext,
+        iv: envelope.iv,
+        length: envelope.length
+      }
+    };
+  };
+  const decryptMessage = async (m) => {
+    if (!m.metadata?.agentskitEncrypted) return m;
+    const envelope = {
+      ciphertext: String(m.metadata.ciphertext),
+      iv: String(m.metadata.iv),
+      length: Number(m.metadata.length ?? 0)
+    };
+    const content = await decrypt(envelope);
+    const { agentskitEncrypted: _, ciphertext: __, iv: ___, length: ____, ...rest } = m.metadata;
+    return { ...m, content, metadata: Object.keys(rest).length > 0 ? rest : void 0 };
+  };
+  return {
+    async load() {
+      const stored = await options.backing.load();
+      return Promise.all(stored.map(decryptMessage));
+    },
+    async save(messages) {
+      const encrypted = await Promise.all(messages.map(encryptMessage));
+      await options.backing.save(encrypted);
+    },
+    async clear() {
+      await options.backing.clear?.();
+    }
+  };
+}
+
+// src/hierarchical.ts
+function mergeChronological(a, b) {
+  const out = [...a, ...b];
+  out.sort((x, y) => x.createdAt.getTime() - y.createdAt.getTime());
+  return out;
+}
+function createHierarchicalMemory(options) {
+  const workingLimit = Math.max(1, options.workingLimit ?? 50);
+  const recallTopK = Math.max(0, options.recallTopK ?? 5);
+  const loadAll = async (source) => [...await source.load()];
+  return {
+    async load() {
+      const hot = await loadAll(options.working);
+      if (!options.recall || recallTopK === 0) return hot;
+      let recalled = [];
+      try {
+        recalled = [...await options.recall.query({ working: hot, topK: recallTopK })];
+      } catch {
+        recalled = [];
+      }
+      const hotIds = new Set(hot.map((m) => m.id));
+      return mergeChronological(
+        recalled.filter((m) => !hotIds.has(m.id)),
+        hot
+      );
+    },
+    async save(messages) {
+      const knownArchival = await loadAll(options.archival);
+      const archivalIds = new Set(knownArchival.map((m) => m.id));
+      const fresh = messages.filter((m) => !archivalIds.has(m.id));
+      if (fresh.length > 0) {
+        await options.archival.save(mergeChronological(knownArchival, fresh));
+      }
+      const tail = messages.slice(Math.max(0, messages.length - workingLimit));
+      const overflow = messages.slice(0, Math.max(0, messages.length - workingLimit));
+      await options.working.save(tail);
+      if (options.recall) {
+        const knownOverflow = overflow.filter((m) => fresh.some((f) => f.id === m.id));
+        for (const m of knownOverflow) await options.recall.index(m);
+        const appended = fresh.filter((m) => !tail.some((t) => t.id === m.id));
+        for (const m of appended) await options.recall.index(m);
+      }
+    },
+    async clear() {
+      await options.working.clear?.();
+      await options.archival.clear?.();
+    },
+    async archival() {
+      return loadAll(options.archival);
+    },
+    async working() {
+      return loadAll(options.working);
+    }
+  };
+}
+
+exports.chroma = chroma;
+exports.createEncryptedMemory = createEncryptedMemory;
+exports.createHierarchicalMemory = createHierarchicalMemory;
+exports.createInMemoryGraph = createInMemoryGraph;
+exports.createInMemoryPersonalization = createInMemoryPersonalization;
 exports.fileChatMemory = fileChatMemory;
 exports.fileVectorMemory = fileVectorMemory;
+exports.matchesFilter = matchesFilter;
+exports.pgvector = pgvector;
+exports.pinecone = pinecone;
+exports.qdrant = qdrant;
 exports.redisChatMemory = redisChatMemory;
 exports.redisVectorMemory = redisVectorMemory;
+exports.renderProfileContext = renderProfileContext;
 exports.sqliteChatMemory = sqliteChatMemory;
+exports.supabaseVectorStore = supabaseVectorStore;
+exports.tursoChatMemory = tursoChatMemory;
+exports.upstashVector = upstashVector;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map