@agentskit/memory 0.6.1 → 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,
@@ -730,6 +837,75 @@ function upstashVector(config) {
   };
 }
 
+// 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");
@@ -879,6 +1055,7 @@ exports.createInMemoryGraph = createInMemoryGraph;
 exports.createInMemoryPersonalization = createInMemoryPersonalization;
 exports.fileChatMemory = fileChatMemory;
 exports.fileVectorMemory = fileVectorMemory;
+exports.matchesFilter = matchesFilter;
 exports.pgvector = pgvector;
 exports.pinecone = pinecone;
 exports.qdrant = qdrant;
@@ -886,6 +1063,8 @@ 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