@agentskit/memory 0.9.0 → 0.10.0

package/dist/index.cjs

@@ -2,6 +2,8 @@
 
 var core = require('@agentskit/core');
 var security = require('@agentskit/core/security');
+var promises = require('fs/promises');
+var path = require('path');
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -1367,14 +1369,453 @@ function wrapVectorMemoryWithRedaction(inner, options) {
   };
 }
 
+// src/kv-store-types.ts
+var isExpired = (entry, ttlSeconds, now) => {
+  if (ttlSeconds === void 0) return false;
+  return now - entry.insertedAt > ttlSeconds * 1e3;
+};
+var enforceMaxMessages = (map, maxMessages) => {
+  if (maxMessages === void 0) return;
+  while (map.size > maxMessages) {
+    const oldest = map.keys().next().value;
+    if (oldest === void 0) break;
+    map.delete(oldest);
+  }
+};
+
+// src/kv-store-basic.ts
+var createInMemoryStore = (config) => {
+  const store = /* @__PURE__ */ new Map();
+  const now = () => Date.now();
+  return {
+    id: "in-memory",
+    async get(key) {
+      const entry = store.get(key);
+      if (!entry) return void 0;
+      if (isExpired(entry, config.ttlSeconds, now())) {
+        store.delete(key);
+        return void 0;
+      }
+      return entry.value;
+    },
+    async set(key, value) {
+      store.set(key, { value, insertedAt: now() });
+      enforceMaxMessages(store, config.maxMessages);
+    }
+  };
+};
+var createFileStore = (config) => {
+  const path$1 = config.path;
+  let cache;
+  const load = async () => {
+    if (cache) return cache;
+    try {
+      const parsed = JSON.parse(await promises.readFile(path$1, "utf8"));
+      cache = new Map(Object.entries(parsed));
+    } catch (err) {
+      if (err.code === "ENOENT") cache = /* @__PURE__ */ new Map();
+      else throw err;
+    }
+    return cache;
+  };
+  const persist = async (map) => {
+    await promises.mkdir(path.dirname(path$1), { recursive: true });
+    await promises.writeFile(path$1, JSON.stringify(Object.fromEntries(map), null, 2), { encoding: "utf8", mode: 384 });
+  };
+  return {
+    id: `file:${path$1}`,
+    async get(key) {
+      const map = await load();
+      const entry = map.get(key);
+      if (!entry) return void 0;
+      if (isExpired(entry, config.ttlSeconds, Date.now())) {
+        map.delete(key);
+        await persist(map);
+        return void 0;
+      }
+      return entry.value;
+    },
+    async set(key, value) {
+      const map = await load();
+      map.set(key, { value, insertedAt: Date.now() });
+      enforceMaxMessages(map, config.maxMessages);
+      await persist(map);
+    }
+  };
+};
+var resolveLocalStorage = () => {
+  const maybe = globalThis.localStorage;
+  return maybe && typeof maybe.getItem === "function" && typeof maybe.setItem === "function" ? maybe : void 0;
+};
+var defaultLocalStoragePath = () => `${process.cwd()}/.agentskit/memory-localstorage.json`;
+var createLocalStorageStore = ({
+  config,
+  storage = resolveLocalStorage(),
+  filePath = defaultLocalStoragePath()
+}) => {
+  const key = config.key;
+  let cache;
+  const mapFromJson = (raw) => raw ? new Map(Object.entries(JSON.parse(raw))) : /* @__PURE__ */ new Map();
+  const loadFromFile = async () => {
+    if (cache) return cache;
+    try {
+      cache = mapFromJson(await promises.readFile(filePath, "utf8"));
+    } catch (err) {
+      if (err.code === "ENOENT") cache = /* @__PURE__ */ new Map();
+      else throw err;
+    }
+    return cache;
+  };
+  const load = async () => storage ? mapFromJson(storage.getItem(key)) : loadFromFile();
+  const persist = async (map) => {
+    const raw = JSON.stringify(Object.fromEntries(map), null, 2);
+    if (storage) {
+      storage.setItem(key, raw);
+      return;
+    }
+    await promises.mkdir(path.dirname(filePath), { recursive: true });
+    await promises.writeFile(filePath, raw, { encoding: "utf8", mode: 384 });
+  };
+  return {
+    id: storage ? `localstorage:${key}` : `localstorage-file:${filePath}:${key}`,
+    async get(itemKey) {
+      const map = await load();
+      const entry = map.get(itemKey);
+      if (!entry) return void 0;
+      if (isExpired(entry, config.ttlSeconds, Date.now())) {
+        map.delete(itemKey);
+        await persist(map);
+        return void 0;
+      }
+      return entry.value;
+    },
+    async set(itemKey, value) {
+      const map = await load();
+      map.set(itemKey, { value, insertedAt: Date.now() });
+      enforceMaxMessages(map, config.maxMessages);
+      await persist(map);
+    }
+  };
+};
+
+// src/kv-store-sqlite.ts
+var createSqliteStore = ({ config, open }) => {
+  const db = open(config.path);
+  db.exec(
+    `CREATE TABLE IF NOT EXISTS memory (
+       key TEXT PRIMARY KEY,
+       value TEXT NOT NULL,
+       inserted_at INTEGER NOT NULL
+     )`
+  );
+  const getStmt = db.prepare("SELECT value, inserted_at FROM memory WHERE key = ?");
+  const setStmt = db.prepare(
+    "INSERT INTO memory(key, value, inserted_at) VALUES(?, ?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value, inserted_at=excluded.inserted_at"
+  );
+  const delStmt = db.prepare("DELETE FROM memory WHERE key = ?");
+  const oldestStmt = db.prepare("SELECT key FROM memory ORDER BY inserted_at ASC LIMIT 1");
+  const countStmt = db.prepare("SELECT COUNT(*) as n FROM memory");
+  const enforce = () => {
+    if (config.maxMessages === void 0) return;
+    const countResult = countStmt.get();
+    let count = countResult ? countResult.n : 0;
+    while (count > config.maxMessages) {
+      const oldest = oldestStmt.get();
+      if (!oldest) break;
+      delStmt.run(oldest.key);
+      count -= 1;
+    }
+  };
+  return {
+    id: `sqlite:${config.path}`,
+    async get(key) {
+      const row = getStmt.get(key);
+      if (!row) return void 0;
+      if (isExpired({ insertedAt: row.inserted_at }, config.ttlSeconds, Date.now())) {
+        delStmt.run(key);
+        return void 0;
+      }
+      return JSON.parse(row.value);
+    },
+    async set(key, value) {
+      setStmt.run(key, JSON.stringify(value), Date.now());
+      enforce();
+    }
+  };
+};
+var tryDefaultSqliteOpener = async () => {
+  try {
+    const moduleId = "better-sqlite3";
+    const mod = await import(
+      /* @vite-ignore */
+      moduleId
+    );
+    const Ctor = mod.default;
+    if (typeof Ctor !== "function") return void 0;
+    return (path) => new Ctor(path);
+  } catch {
+    return void 0;
+  }
+};
+var createRedisStore = ({ config, client }) => {
+  const prefix = config.prefix;
+  const namespaced = (key) => `${prefix}${key}`;
+  const wrap = async (op, fn) => {
+    try {
+      return await fn();
+    } catch (cause) {
+      throw new core.MemoryError({
+        code: "AK_MEMORY_REDIS_CONNECTION_FAILED",
+        message: `createRedisStore.${op}: redis command failed \u2014 ${cause instanceof Error ? cause.message : String(cause)}`,
+        cause: cause instanceof Error ? cause : void 0
+      });
+    }
+  };
+  const enforce = async () => {
+    if (config.maxMessages === void 0) return;
+    const keys = await wrap("enforce", () => Promise.resolve(client.keys(`${prefix}*`)));
+    if (keys.length <= config.maxMessages) return;
+    const envelopes = [];
+    for (const fullKey of keys) {
+      const raw = await wrap("enforce", () => Promise.resolve(client.get(fullKey)));
+      if (raw === null) continue;
+      envelopes.push({ key: fullKey, insertedAt: JSON.parse(raw).insertedAt });
+    }
+    envelopes.sort((a, b) => a.insertedAt - b.insertedAt);
+    let excess = envelopes.length - config.maxMessages;
+    for (const entry of envelopes) {
+      if (excess <= 0) break;
+      await wrap("enforce", () => Promise.resolve(client.del(entry.key)));
+      excess -= 1;
+    }
+  };
+  return {
+    id: `redis:${prefix}`,
+    async get(key) {
+      const raw = await wrap("get", () => Promise.resolve(client.get(namespaced(key))));
+      if (raw === null) return void 0;
+      const envelope = JSON.parse(raw);
+      if (isExpired({ value: envelope.value, insertedAt: envelope.insertedAt }, config.ttlSeconds, Date.now())) {
+        await wrap("get", () => Promise.resolve(client.del(namespaced(key))));
+        return void 0;
+      }
+      return envelope.value;
+    },
+    async set(key, value) {
+      const payload = JSON.stringify({ value, insertedAt: Date.now() });
+      const options = config.ttlSeconds === void 0 ? void 0 : { EX: config.ttlSeconds };
+      await wrap("set", () => Promise.resolve(client.set(namespaced(key), payload, options)));
+      await enforce();
+    }
+  };
+};
+var adaptIoredis = (io) => ({
+  get: (key) => io.get(key),
+  set: (key, value, options) => options?.EX === void 0 ? io.set(key, value) : io.set(key, value, "EX", options.EX),
+  del: (key) => io.del(key),
+  keys: (pattern) => io.keys(pattern)
+});
+var tryDefaultRedisClient = async (url) => {
+  try {
+    const moduleId = "redis";
+    const mod = await import(
+      /* @vite-ignore */
+      moduleId
+    );
+    const createClient = mod.createClient;
+    if (typeof createClient !== "function") return void 0;
+    const client = createClient({ url });
+    try {
+      await client.connect();
+    } catch (cause) {
+      throw new core.MemoryError({
+        code: "AK_MEMORY_REDIS_CONNECTION_FAILED",
+        message: `tryDefaultRedisClient: redis connect() failed \u2014 ${cause instanceof Error ? cause.message : String(cause)}`,
+        cause: cause instanceof Error ? cause : void 0
+      });
+    }
+    return client;
+  } catch (err) {
+    if (err instanceof core.MemoryError) throw err;
+    return void 0;
+  }
+};
+var createVectorStore = ({
+  config,
+  vectorStore,
+  embedder
+}) => {
+  const collection = config.collection;
+  const embedOne = async (text) => {
+    const [vec] = await embedder.embed([text]);
+    if (vec === void 0) {
+      throw new core.MemoryError({
+        code: "AK_MEMORY_VECTOR_EMBEDDER_REQUIRED",
+        message: "createVectorStore: embedder returned no vector for the input text."
+      });
+    }
+    return vec;
+  };
+  return {
+    id: `vector:${config.provider}:${collection}`,
+    async get(key) {
+      const vec = await embedOne(key);
+      const hits = await vectorStore.query(vec, 1, { __collection: collection, __key: key });
+      const hit = hits[0];
+      if (hit === void 0) return void 0;
+      if (hit.metadata["__key"] !== key) return void 0;
+      const insertedAt = hit.metadata["__insertedAt"];
+      if (typeof insertedAt === "number" && isExpired({ insertedAt }, config.ttlSeconds, Date.now())) {
+        return void 0;
+      }
+      return hit.metadata["__value"];
+    },
+    async set(key, value) {
+      const vec = await embedOne(key);
+      await vectorStore.upsert([
+        {
+          chunkId: `${collection}:${key}`,
+          vec,
+          metadata: { __collection: collection, __key: key, __value: value, __insertedAt: Date.now() }
+        }
+      ]);
+    },
+    async recall(query, k = 5) {
+      const vec = await embedOne(query);
+      const hits = await vectorStore.query(vec, k, { __collection: collection });
+      const now = Date.now();
+      const results = [];
+      for (const hit of hits) {
+        const insertedAt = hit.metadata["__insertedAt"];
+        if (typeof insertedAt === "number" && isExpired({ insertedAt }, config.ttlSeconds, now)) {
+          continue;
+        }
+        results.push(hit.metadata["__value"]);
+      }
+      return results;
+    }
+  };
+};
+var MemoryBackendNotImplementedError = class extends Error {
+  constructor(backend) {
+    super(
+      `Memory backend "${backend}" is not implemented. Supported: "in-memory", "file", "sqlite", "localstorage", "redis", "vector".`
+    );
+    this.code = "MEMORY_BACKEND_NOT_IMPLEMENTED";
+    this.backend = backend;
+  }
+};
+var MEMORY_BACKEND_SUPPORT = {
+  "in-memory": "supported",
+  file: "supported",
+  sqlite: "supported",
+  redis: "supported",
+  vector: "supported",
+  localstorage: "supported"
+};
+var isMemoryBackendSupported = (backend) => MEMORY_BACKEND_SUPPORT[backend] === "supported";
+var createKvMemoryFromConfig = ({
+  config,
+  sqlite,
+  localStorageFilePath,
+  redis,
+  vectorStore,
+  embedder
+}) => {
+  if (config.backend === "in-memory") return createInMemoryStore(config);
+  if (config.backend === "file") return createFileStore(config);
+  if (config.backend === "localstorage") {
+    return createLocalStorageStore({
+      config,
+      ...localStorageFilePath ? { filePath: localStorageFilePath } : {}
+    });
+  }
+  if (config.backend === "sqlite") {
+    if (!sqlite) {
+      throw new core.MemoryError({
+        code: "AK_MEMORY_SQLITE_OPENER_REQUIRED",
+        message: "createKvMemoryFromConfig: sqlite backend requires an `open` function (better-sqlite3), or call createKvMemoryFromConfigAuto which lazy-imports it."
+      });
+    }
+    return createSqliteStore({ config, open: sqlite });
+  }
+  if (config.backend === "redis") {
+    if (!redis) {
+      throw new core.MemoryError({
+        code: "AK_MEMORY_REDIS_CLIENT_REQUIRED",
+        message: "createKvMemoryFromConfig: redis backend requires a `redis` client, or call createKvMemoryFromConfigAuto which lazy-imports it."
+      });
+    }
+    return createRedisStore({ config, client: redis });
+  }
+  if (config.backend === "vector") {
+    if (!vectorStore) {
+      throw new core.MemoryError({
+        code: "AK_MEMORY_VECTOR_STORE_REQUIRED",
+        message: "createKvMemoryFromConfig: vector backend requires a `vectorStore`."
+      });
+    }
+    if (!embedder) {
+      throw new core.MemoryError({
+        code: "AK_MEMORY_VECTOR_EMBEDDER_REQUIRED",
+        message: "createKvMemoryFromConfig: vector backend requires an `embedder`."
+      });
+    }
+    return createVectorStore({ config, vectorStore, embedder });
+  }
+  const exhausted = config;
+  throw new MemoryBackendNotImplementedError(exhausted.backend);
+};
+var createKvMemoryFromConfigAuto = async (config) => {
+  if (config.backend === "sqlite") {
+    const sqlite = await tryDefaultSqliteOpener();
+    if (!sqlite) {
+      throw new core.MemoryError({
+        code: "AK_MEMORY_PEER_MISSING",
+        message: "createKvMemoryFromConfigAuto: sqlite backend needs `better-sqlite3` (pnpm add better-sqlite3)."
+      });
+    }
+    return createKvMemoryFromConfig({ config, sqlite });
+  }
+  if (config.backend === "redis") {
+    const redis = await tryDefaultRedisClient(config.url);
+    if (!redis) {
+      throw new core.MemoryError({
+        code: "AK_MEMORY_PEER_MISSING",
+        message: "createKvMemoryFromConfigAuto: redis backend needs `redis` (pnpm add redis)."
+      });
+    }
+    return createKvMemoryFromConfig({ config, redis });
+  }
+  if (config.backend === "vector") {
+    throw new core.MemoryError({
+      code: "AK_MEMORY_VECTOR_STORE_REQUIRED",
+      message: "createKvMemoryFromConfigAuto: vector backend requires an injected vectorStore + embedder."
+    });
+  }
+  return createKvMemoryFromConfig({ config });
+};
+
+exports.MEMORY_BACKEND_SUPPORT = MEMORY_BACKEND_SUPPORT;
+exports.MemoryBackendNotImplementedError = MemoryBackendNotImplementedError;
+exports.adaptIoredis = adaptIoredis;
 exports.chroma = chroma;
 exports.createEncryptedMemory = createEncryptedMemory;
+exports.createFileStore = createFileStore;
 exports.createHierarchicalMemory = createHierarchicalMemory;
 exports.createInMemoryGraph = createInMemoryGraph;
 exports.createInMemoryPersonalization = createInMemoryPersonalization;
+exports.createInMemoryStore = createInMemoryStore;
+exports.createKvMemoryFromConfig = createKvMemoryFromConfig;
+exports.createKvMemoryFromConfigAuto = createKvMemoryFromConfigAuto;
+exports.createLocalStorageStore = createLocalStorageStore;
+exports.createRedisStore = createRedisStore;
+exports.createSqliteStore = createSqliteStore;
+exports.createVectorStore = createVectorStore;
 exports.fileChatMemory = fileChatMemory;
 exports.fileVectorMemory = fileVectorMemory;
 exports.forgetSubject = forgetSubject;
+exports.isMemoryBackendSupported = isMemoryBackendSupported;
 exports.makeForgettable = makeForgettable;
 exports.matchesFilter = matchesFilter;
 exports.milvusVectorStore = milvusVectorStore;
@@ -1387,6 +1828,8 @@ exports.redisVectorMemory = redisVectorMemory;
 exports.renderProfileContext = renderProfileContext;
 exports.sqliteChatMemory = sqliteChatMemory;
 exports.supabaseVectorStore = supabaseVectorStore;
+exports.tryDefaultRedisClient = tryDefaultRedisClient;
+exports.tryDefaultSqliteOpener = tryDefaultSqliteOpener;
 exports.tursoChatMemory = tursoChatMemory;
 exports.upstashVector = upstashVector;
 exports.weaviateVectorStore = weaviateVectorStore;