@agentskit/memory 0.8.3 → 0.10.0

package/dist/index.js

@@ -1,11 +1,10 @@
+import { __require } from './chunk-G5S2A3MJ.js';
+export { createInMemoryPersonalization, renderProfileContext } from './chunk-G5S2A3MJ.js';
 import { serializeMessages, deserializeMessages, MemoryError, ErrorCodes, ConfigError } from '@agentskit/core';
+import { tokenize, createPIIRedactor } from '@agentskit/core/security';
+import { readFile, mkdir, writeFile } from 'fs/promises';
+import { dirname } from 'path';
 
-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');
-});
 function fileChatMemory(path) {
   return {
     async load() {
@@ -19,7 +18,11 @@ function fileChatMemory(path) {
     },
     async save(messages) {
       const fs = await import('fs/promises');
-      await fs.writeFile(path, JSON.stringify(serializeMessages(messages), null, 2), "utf8");
+      await fs.writeFile(
+        path,
+        JSON.stringify(serializeMessages(messages), null, 2),
+        { encoding: "utf8", mode: 384 }
+      );
     },
     async clear() {
       try {
@@ -195,7 +198,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)]);
@@ -423,16 +426,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,
@@ -483,44 +493,6 @@ 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();
@@ -1257,6 +1229,529 @@ function createHierarchicalMemory(options) {
   };
 }
 
-export { chroma, createEncryptedMemory, createHierarchicalMemory, createInMemoryGraph, createInMemoryPersonalization, fileChatMemory, fileVectorMemory, matchesFilter, milvusVectorStore, mongoAtlasVectorStore, pgvector, pinecone, qdrant, redisChatMemory, redisVectorMemory, renderProfileContext, sqliteChatMemory, supabaseVectorStore, tursoChatMemory, upstashVector, weaviateVectorStore };
+// 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 ConfigError({
+        code: ErrorCodes.AK_CONFIG_INVALID,
+        message: 'wrapMemoryWithRedaction: vault is required when mode is "tokenize"'
+      });
+    }
+    if (!opts.allowedRoles) {
+      throw new ConfigError({
+        code: ErrorCodes.AK_CONFIG_INVALID,
+        message: 'wrapMemoryWithRedaction: allowedRoles is required when mode is "tokenize"'
+      });
+    }
+    const result = await tokenize(input, {
+      rules: opts.rules,
+      vault: opts.vault,
+      allowedRoles: opts.allowedRoles,
+      audit: opts.audit
+    });
+    return result.value;
+  }
+  return 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 = config.path;
+  let cache;
+  const load = async () => {
+    if (cache) return cache;
+    try {
+      const parsed = JSON.parse(await readFile(path, "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 mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(Object.fromEntries(map), null, 2), { encoding: "utf8", mode: 384 });
+  };
+  return {
+    id: `file:${path}`,
+    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 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 mkdir(dirname(filePath), { recursive: true });
+    await 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 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 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 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 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 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 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 MemoryError({
+        code: "AK_MEMORY_VECTOR_STORE_REQUIRED",
+        message: "createKvMemoryFromConfig: vector backend requires a `vectorStore`."
+      });
+    }
+    if (!embedder) {
+      throw new 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 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 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 MemoryError({
+      code: "AK_MEMORY_VECTOR_STORE_REQUIRED",
+      message: "createKvMemoryFromConfigAuto: vector backend requires an injected vectorStore + embedder."
+    });
+  }
+  return createKvMemoryFromConfig({ config });
+};
+
+export { MEMORY_BACKEND_SUPPORT, MemoryBackendNotImplementedError, adaptIoredis, chroma, createEncryptedMemory, createFileStore, createHierarchicalMemory, createInMemoryGraph, createInMemoryStore, createKvMemoryFromConfig, createKvMemoryFromConfigAuto, createLocalStorageStore, createRedisStore, createSqliteStore, createVectorStore, fileChatMemory, fileVectorMemory, forgetSubject, isMemoryBackendSupported, makeForgettable, matchesFilter, milvusVectorStore, mongoAtlasVectorStore, pgvector, pinecone, qdrant, redisChatMemory, redisVectorMemory, sqliteChatMemory, supabaseVectorStore, tryDefaultRedisClient, tryDefaultSqliteOpener, tursoChatMemory, upstashVector, weaviateVectorStore, wrapChatMemoryWithRedaction, wrapVectorMemoryWithRedaction };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map