@agentskit/memory 0.6.1 → 0.8.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,236 @@ 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/vector/weaviate.ts
+async function call5(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 ? { authorization: `Bearer ${config.apiKey}` } : {}
+    },
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`weaviate ${response.status}: ${text.slice(0, 200)}`);
+  return text.length > 0 ? JSON.parse(text) : {};
+}
+function weaviateVectorStore(config) {
+  const defaultTopK = Math.max(1, config.topK ?? 10);
+  const className = config.className;
+  return {
+    async store(docs) {
+      if (docs.length === 0) return;
+      await call5(config, "POST", "/v1/batch/objects", {
+        objects: docs.map((d) => ({
+          class: className,
+          id: d.id,
+          properties: { content: d.content, ...d.metadata ?? {} },
+          vector: d.embedding
+        }))
+      });
+    },
+    async search(embedding, options = {}) {
+      const topK = options.topK ?? defaultTopK;
+      const threshold = options.threshold ?? 0;
+      const query = `{
+        Get {
+          ${className}(nearVector: { vector: [${embedding.join(",")}] }, limit: ${topK}) {
+            content
+            _additional { id certainty }
+          }
+        }
+      }`;
+      const result = await call5(config, "POST", "/v1/graphql", { query });
+      const rows = result.data?.Get?.[className] ?? [];
+      return rows.map((row) => ({
+        id: String(row._additional?.id ?? ""),
+        content: String(row.content ?? ""),
+        score: row._additional?.certainty ?? 0,
+        metadata: row
+      })).filter((r) => (r.score ?? 0) >= threshold);
+    },
+    async delete(ids) {
+      for (const id of ids) {
+        await call5(config, "DELETE", `/v1/objects/${className}/${id}`);
+      }
+    }
+  };
+}
+
+// src/vector/milvus.ts
+async function call6(config, path, body) {
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(`${config.url}${path}`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...config.token ? { authorization: `Bearer ${config.token}` } : {}
+    },
+    body: JSON.stringify(body)
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`milvus ${response.status}: ${text.slice(0, 200)}`);
+  return text.length > 0 ? JSON.parse(text) : {};
+}
+function milvusVectorStore(config) {
+  const defaultTopK = Math.max(1, config.topK ?? 10);
+  const vectorField = config.vectorField ?? "vector";
+  return {
+    async store(docs) {
+      if (docs.length === 0) return;
+      await call6(config, "/v2/vectordb/entities/upsert", {
+        collectionName: config.collection,
+        data: docs.map((d) => ({
+          id: d.id,
+          [vectorField]: d.embedding,
+          content: d.content,
+          metadata: d.metadata ?? {}
+        }))
+      });
+    },
+    async search(embedding, options = {}) {
+      const topK = options.topK ?? defaultTopK;
+      const threshold = options.threshold ?? 0;
+      const result = await call6(config, "/v2/vectordb/entities/search", {
+        collectionName: config.collection,
+        data: [embedding],
+        annsField: vectorField,
+        limit: topK,
+        outputFields: ["content", "metadata"]
+      });
+      return (result.data ?? []).map((m) => ({
+        id: String(m.id),
+        content: String(m.content ?? ""),
+        score: 1 - m.distance,
+        metadata: m.metadata
+      })).filter((r) => (r.score ?? 0) >= threshold);
+    },
+    async delete(ids) {
+      if (ids.length === 0) return;
+      await call6(config, "/v2/vectordb/entities/delete", {
+        collectionName: config.collection,
+        filter: `id in [${ids.map((id) => `"${id}"`).join(",")}]`
+      });
+    }
+  };
+}
+
+// src/vector/mongo-atlas.ts
+function mongoAtlasVectorStore(config) {
+  const defaultTopK = Math.max(1, config.topK ?? 10);
+  const vectorField = config.vectorField ?? "embedding";
+  return {
+    async store(docs) {
+      if (docs.length === 0) return;
+      await config.collection.insertMany(docs.map((d) => ({
+        _id: d.id,
+        content: d.content,
+        [vectorField]: d.embedding,
+        metadata: d.metadata ?? {}
+      })));
+    },
+    async search(embedding, options = {}) {
+      const topK = options.topK ?? defaultTopK;
+      const threshold = options.threshold ?? 0;
+      const numCandidates = config.numCandidates ?? topK * 10;
+      const cursor = config.collection.aggregate([
+        {
+          $vectorSearch: {
+            index: config.indexName,
+            path: vectorField,
+            queryVector: embedding,
+            numCandidates,
+            limit: topK
+          }
+        },
+        { $project: { content: 1, metadata: 1, score: { $meta: "vectorSearchScore" } } }
+      ]);
+      const rows = await cursor.toArray();
+      return rows.map((row) => ({
+        id: String(row._id),
+        content: String(row.content ?? ""),
+        score: row.score,
+        metadata: row.metadata
+      })).filter((r) => (r.score ?? 0) >= threshold);
+    },
+    async delete(ids) {
+      if (ids.length === 0) return;
+      await config.collection.deleteMany({ _id: { $in: ids } });
+    }
+  };
+}
+
 // src/encrypted.ts
 function toBase64(bytes) {
   if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
@@ -879,6 +1216,9 @@ exports.createInMemoryGraph = createInMemoryGraph;
 exports.createInMemoryPersonalization = createInMemoryPersonalization;
 exports.fileChatMemory = fileChatMemory;
 exports.fileVectorMemory = fileVectorMemory;
+exports.matchesFilter = matchesFilter;
+exports.milvusVectorStore = milvusVectorStore;
+exports.mongoAtlasVectorStore = mongoAtlasVectorStore;
 exports.pgvector = pgvector;
 exports.pinecone = pinecone;
 exports.qdrant = qdrant;
@@ -886,6 +1226,9 @@ exports.redisChatMemory = redisChatMemory;
 exports.redisVectorMemory = redisVectorMemory;
 exports.renderProfileContext = renderProfileContext;
 exports.sqliteChatMemory = sqliteChatMemory;
+exports.supabaseVectorStore = supabaseVectorStore;
+exports.tursoChatMemory = tursoChatMemory;
 exports.upstashVector = upstashVector;
+exports.weaviateVectorStore = weaviateVectorStore;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map