@agentskit/memory 0.8.3 → 0.10.0

package/dist/chunk-G5S2A3MJ.js

@@ -0,0 +1,48 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// 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")}`;
+}
+
+export { __require, createInMemoryPersonalization, renderProfileContext };
+//# sourceMappingURL=chunk-G5S2A3MJ.js.map
+//# sourceMappingURL=chunk-G5S2A3MJ.js.map

package/dist/chunk-G5S2A3MJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/personalization.ts"],"names":[],"mappings":";;;;;;;;AA0BO,SAAS,6BAAA,GAAsD;AACpE,EAAA,MAAM,QAAA,uBAAe,GAAA,EAAoC;AAEzD,EAAA,OAAO;AAAA,IACL,MAAM,IAAI,SAAA,EAAW;AACnB,MAAA,MAAM,GAAA,GAAM,QAAA,CAAS,GAAA,CAAI,SAAS,CAAA;AAClC,MAAA,OAAO,GAAA,GAAM,EAAE,GAAG,GAAA,EAAK,MAAA,EAAQ,EAAE,GAAG,GAAA,CAAI,MAAA,EAAO,EAAE,GAAI,IAAA;AAAA,IACvD,CAAA;AAAA,IACA,MAAM,IAAI,OAAA,EAAS;AACjB,MAAA,QAAA,CAAS,GAAA,CAAI,QAAQ,SAAA,EAAW;AAAA,QAC9B,GAAG,OAAA;AAAA,QACH,MAAA,EAAQ,EAAE,GAAG,OAAA,CAAQ,MAAA,EAAO;AAAA,QAC5B,WAAW,OAAA,CAAQ,SAAA,IAAA,iBAAa,IAAI,IAAA,IAAO,WAAA;AAAY,OACxD,CAAA;AAAA,IACH,CAAA;AAAA,IACA,MAAM,KAAA,CAAM,SAAA,EAAW,MAAA,EAAQ;AAC7B,MAAA,MAAM,QAAA,GAAW,QAAA,CAAS,GAAA,CAAI,SAAS,CAAA;AACvC,MAAA,MAAM,IAAA,GAA+B;AAAA,QACnC,SAAA;AAAA,QACA,MAAA,EAAQ,EAAE,GAAI,QAAA,EAAU,UAAU,EAAC,EAAI,GAAG,MAAA,EAAO;AAAA,QACjD,SAAA,EAAA,iBAAW,IAAI,IAAA,EAAK,EAAE,WAAA;AAAY,OACpC;AACA,MAAA,QAAA,CAAS,GAAA,CAAI,WAAW,IAAI,CAAA;AAC5B,MAAA,OAAO,EAAE,GAAG,IAAA,EAAM,MAAA,EAAQ,EAAE,GAAG,IAAA,CAAK,QAAO,EAAE;AAAA,IAC/C,CAAA;AAAA,IACA,MAAM,OAAO,SAAA,EAAW;AACtB,MAAA,QAAA,CAAS,OAAO,SAAS,CAAA;AAAA,IAC3B;AAAA,GACF;AACF;AAOO,SAAS,qBAAqB,OAAA,EAAgD;AACnF,EAAA,IAAI,CAAC,WAAW,MAAA,CAAO,IAAA,CAAK,QAAQ,MAAM,CAAA,CAAE,MAAA,KAAW,CAAA,EAAG,OAAO,EAAA;AACjE,EAAA,MAAM,QAAQ,MAAA,CAAO,OAAA,CAAQ,OAAA,CAAQ,MAAM,EACxC,MAAA,CAAO,CAAC,GAAG,KAAK,CAAA,KAAM,KAAA,KAAU,MAAA,IAAa,KAAA,KAAU,QAAQ,KAAA,KAAU,EAAE,CAAA,CAC3E,GAAA,CAAI,CAAC,CAAC,GAAA,EAAK,KAAK,CAAA,KAAM,KAAK,GAAG,CAAA,EAAA,EAAK,OAAO,KAAA,KAAU,WAAW,KAAA,GAAQ,IAAA,CAAK,SAAA,CAAU,KAAK,CAAC,CAAA,CAAE,CAAA;AACjG,EAAA,IAAI,KAAA,CAAM,MAAA,KAAW,CAAA,EAAG,OAAO,EAAA;AAC/B,EAAA,OAAO,CAAA;AAAA,EAAoB,KAAA,CAAM,IAAA,CAAK,IAAI,CAAC,CAAA,CAAA;AAC7C","file":"chunk-G5S2A3MJ.js","sourcesContent":["/**\n * Personalization — a persisted profile per subject (user id,\n * account id, device). The agent reads it on every run to\n * condition responses; the runtime updates it when new facts\n * appear.\n */\n\nexport interface PersonalizationProfile {\n  subjectId: string\n  /** Human-editable notes, facts, preferences. */\n  traits: Record<string, unknown>\n  /** ISO timestamp of the latest update. */\n  updatedAt: string\n}\n\nexport interface PersonalizationStore {\n  get: (subjectId: string) => Promise<PersonalizationProfile | null>\n  set: (profile: PersonalizationProfile) => Promise<void>\n  merge: (subjectId: string, traits: Record<string, unknown>) => Promise<PersonalizationProfile>\n  delete?: (subjectId: string) => Promise<void>\n}\n\n/**\n * In-memory personalization store — tests, single-process demos.\n * Bring your own for production (Postgres, Redis, DynamoDB).\n */\nexport function createInMemoryPersonalization(): PersonalizationStore {\n  const profiles = new Map<string, PersonalizationProfile>()\n\n  return {\n    async get(subjectId) {\n      const hit = profiles.get(subjectId)\n      return hit ? { ...hit, traits: { ...hit.traits } } : null\n    },\n    async set(profile) {\n      profiles.set(profile.subjectId, {\n        ...profile,\n        traits: { ...profile.traits },\n        updatedAt: profile.updatedAt || new Date().toISOString(),\n      })\n    },\n    async merge(subjectId, traits) {\n      const existing = profiles.get(subjectId)\n      const next: PersonalizationProfile = {\n        subjectId,\n        traits: { ...(existing?.traits ?? {}), ...traits },\n        updatedAt: new Date().toISOString(),\n      }\n      profiles.set(subjectId, next)\n      return { ...next, traits: { ...next.traits } }\n    },\n    async delete(subjectId) {\n      profiles.delete(subjectId)\n    },\n  }\n}\n\n/**\n * Render a profile into a system-prompt fragment the runtime can\n * prepend. Kept intentionally short — full profile dumps bloat\n * context and leak unnecessary detail to the model.\n */\nexport function renderProfileContext(profile: PersonalizationProfile | null): string {\n  if (!profile || Object.keys(profile.traits).length === 0) return ''\n  const lines = Object.entries(profile.traits)\n    .filter(([, value]) => value !== undefined && value !== null && value !== '')\n    .map(([key, value]) => `- ${key}: ${typeof value === 'string' ? value : JSON.stringify(value)}`)\n  if (lines.length === 0) return ''\n  return `## User profile\\n${lines.join('\\n')}`\n}\n"]}

package/dist/index.cjs

@@ -1,6 +1,9 @@
 'use strict';
 
 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]
@@ -21,7 +24,11 @@ function fileChatMemory(path) {
     },
     async save(messages) {
       const fs = await import('fs/promises');
-      await fs.writeFile(path, JSON.stringify(core.serializeMessages(messages), null, 2), "utf8");
+      await fs.writeFile(
+        path,
+        JSON.stringify(core.serializeMessages(messages), null, 2),
+        { encoding: "utf8", mode: 384 }
+      );
     },
     async clear() {
       try {
@@ -197,7 +204,7 @@ async function createRedisClientAdapter(url) {
       return await client.keys(pattern);
     },
     async disconnect() {
-      await client.disconnect();
+      await client.close();
     },
     async call(command, ...args) {
       return await client.sendCommand([command, ...args.map(String)]);
@@ -425,16 +432,23 @@ function createVectraStore(dirPath) {
   return {
     async upsert(docs) {
       const idx = await getIndex();
-      for (const doc of docs) {
-        await idx.insertItem({
-          vector: doc.vector,
-          metadata: { _id: doc.id, ...doc.metadata }
-        });
+      await idx.beginUpdate();
+      try {
+        for (const doc of docs) {
+          await idx.insertItem({
+            vector: doc.vector,
+            metadata: { _id: doc.id, ...doc.metadata }
+          });
+        }
+        await idx.endUpdate();
+      } catch (err) {
+        idx.cancelUpdate();
+        throw err;
       }
     },
     async query(vector, topK) {
       const idx = await getIndex();
-      const results = await idx.queryItems(vector, topK);
+      const results = await idx.queryItems(vector, "", topK);
       return results.map((r) => ({
         id: String(r.item.metadata._id ?? ""),
         score: r.score,
@@ -1259,13 +1273,550 @@ function createHierarchicalMemory(options) {
   };
 }
 
+// src/forget.ts
+function isForgettable(value) {
+  return !!value && typeof value === "object" && "forgetSubject" in value && typeof value.forgetSubject === "function";
+}
+async function hash(input) {
+  const encoded = new TextEncoder().encode(input);
+  const digest = await crypto.subtle.digest("SHA-256", encoded);
+  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function forgetSubject(memories, subjectId) {
+  const reports = [];
+  for (const memory of memories) {
+    if (!isForgettable(memory)) continue;
+    reports.push(await memory.forgetSubject(subjectId));
+  }
+  const totalDeleted = reports.reduce((sum, r) => sum + r.deletedCount, 0);
+  const evidenceHash = await hash(
+    JSON.stringify({ subjectId, reports: reports.map((r) => ({ b: r.backend, n: r.deletedCount, at: r.at })) })
+  );
+  return { subjectId, reports, totalDeleted, evidenceHash };
+}
+function makeForgettable(memory, options) {
+  return Object.assign(memory, {
+    __agentskitBackend: options.backend,
+    forgetSubject: async (subjectId) => {
+      const ids = await options.listIds(subjectId);
+      const failures = [];
+      try {
+        await options.deleteIds(ids);
+      } catch (err) {
+        for (const id of ids) failures.push({ id, reason: err.message });
+      }
+      return {
+        backend: options.backend,
+        deletedCount: ids.length - failures.length,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        failures: failures.length ? failures : void 0
+      };
+    }
+  });
+}
+async function transform(input, opts) {
+  if (opts.mode === "tokenize") {
+    if (!opts.vault) {
+      throw new core.ConfigError({
+        code: core.ErrorCodes.AK_CONFIG_INVALID,
+        message: 'wrapMemoryWithRedaction: vault is required when mode is "tokenize"'
+      });
+    }
+    if (!opts.allowedRoles) {
+      throw new core.ConfigError({
+        code: core.ErrorCodes.AK_CONFIG_INVALID,
+        message: 'wrapMemoryWithRedaction: allowedRoles is required when mode is "tokenize"'
+      });
+    }
+    const result = await security.tokenize(input, {
+      rules: opts.rules,
+      vault: opts.vault,
+      allowedRoles: opts.allowedRoles,
+      audit: opts.audit
+    });
+    return result.value;
+  }
+  return security.createPIIRedactor({ rules: opts.rules }).redact(input).value;
+}
+function wrapChatMemoryWithRedaction(inner, options) {
+  return {
+    load: () => inner.load(),
+    save: async (messages) => {
+      const redacted = await Promise.all(
+        messages.map(async (m) => ({
+          ...m,
+          content: await transform(m.content ?? "", options)
+        }))
+      );
+      await inner.save(redacted);
+    },
+    clear: inner.clear ? () => inner.clear() : void 0
+  };
+}
+function wrapVectorMemoryWithRedaction(inner, options) {
+  return {
+    store: async (docs) => {
+      const redacted = await Promise.all(
+        docs.map(async (d) => ({
+          ...d,
+          content: await transform(d.content, options)
+        }))
+      );
+      await inner.store(redacted);
+    },
+    search: (embedding, opts) => inner.search(embedding, opts),
+    delete: inner.delete ? (ids) => inner.delete(ids) : void 0
+  };
+}
+
+// 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;
 exports.mongoAtlasVectorStore = mongoAtlasVectorStore;
@@ -1277,8 +1828,12 @@ 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;
+exports.wrapChatMemoryWithRedaction = wrapChatMemoryWithRedaction;
+exports.wrapVectorMemoryWithRedaction = wrapVectorMemoryWithRedaction;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map