mem0ai 3.0.10 → 3.0.12

package/dist/oss/index.mjs

@@ -1836,13 +1836,15 @@ var RedisDB = class {
   }
   async insert(vectors, ids, payloads) {
     const data = vectors.map((vector, idx) => {
+      var _a2, _b2;
       const payload = toSnakeCase(payloads[idx]);
       const id = ids[idx];
+      const createdAt = payload.created_at ? new Date(payload.created_at).getTime() : 0;
       const entry = {
         memory_id: id,
-        hash: payload.hash,
-        memory: payload.data,
-        created_at: new Date(payload.created_at).getTime(),
+        hash: (_a2 = payload.hash) != null ? _a2 : "",
+        memory: (_b2 = payload.data) != null ? _b2 : "",
+        created_at: createdAt,
         embedding: new Float32Array(vector).buffer
       };
       ["agent_id", "run_id", "user_id"].forEach((field) => {
@@ -2021,13 +2023,16 @@ var RedisDB = class {
     }
   }
   async update(vectorId, vector, payload) {
+    var _a2, _b2;
     const snakePayload = toSnakeCase(payload);
+    const createdAt = snakePayload.created_at ? new Date(snakePayload.created_at).getTime() : 0;
+    const updatedAt = snakePayload.updated_at ? new Date(snakePayload.updated_at).getTime() : 0;
     const entry = {
       memory_id: vectorId,
-      hash: snakePayload.hash,
-      memory: snakePayload.data,
-      created_at: new Date(snakePayload.created_at).getTime(),
-      updated_at: new Date(snakePayload.updated_at).getTime(),
+      hash: (_a2 = snakePayload.hash) != null ? _a2 : "",
+      memory: (_b2 = snakePayload.data) != null ? _b2 : "",
+      created_at: createdAt,
+      updated_at: updatedAt,
       embedding: Buffer.from(new Float32Array(vector).buffer)
     };
     ["agent_id", "run_id", "user_id"].forEach((field) => {
@@ -2273,6 +2278,66 @@ var DeepSeekLLM = class extends OpenAILLM {
   }
 };
 
+// src/oss/src/llms/litellm.ts
+var LiteLLM = class extends OpenAILLM {
+  constructor(config) {
+    super({
+      ...config,
+      apiKey: config.apiKey || process.env.LITELLM_API_KEY || "sk-anything",
+      baseURL: config.baseURL || process.env.LITELLM_API_BASE || "http://localhost:4000",
+      model: config.model || "gpt-5-mini"
+    });
+  }
+  async generateResponse(messages, responseFormat, tools) {
+    try {
+      return await super.generateResponse(messages, responseFormat, tools);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`LiteLLM failed: ${message}`);
+    }
+  }
+  async generateChat(messages) {
+    try {
+      return await super.generateChat(messages);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`LiteLLM failed: ${message}`);
+    }
+  }
+};
+
+// src/oss/src/llms/minimax.ts
+var MiniMaxLLM = class extends OpenAILLM {
+  constructor(config) {
+    const apiKey = config.apiKey || process.env.MINIMAX_API_KEY;
+    if (!apiKey) {
+      throw new Error("MiniMax API key is required");
+    }
+    super({
+      ...config,
+      apiKey,
+      baseURL: config.baseURL || process.env.MINIMAX_API_BASE || "https://api.minimax.io/v1",
+      model: config.model || "MiniMax-M2.7"
+    });
+  }
+  async generateResponse(messages, responseFormat, tools) {
+    try {
+      return await super.generateResponse(messages, responseFormat, tools);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`MiniMax LLM failed: ${message}`);
+    }
+  }
+  async generateChat(messages) {
+    try {
+      return await super.generateChat(messages);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`MiniMax LLM failed: ${message}`);
+    }
+  }
+};
+
 // src/oss/src/vector_stores/supabase.ts
 import { createClient as createClient2 } from "@supabase/supabase-js";
 var SupabaseDB = class {
@@ -4554,24 +4619,59 @@ function buildFilterConditions(filters, startIndex) {
   }
   return { conditions, values, paramIndex };
 }
+function getConnectionString(config) {
+  var _a2;
+  return ((_a2 = config.connectionString) == null ? void 0 : _a2.trim()) || void 0;
+}
+function validateConnectionConfig(config) {
+  if (getConnectionString(config)) {
+    return;
+  }
+  const missingFields = ["user", "password", "host", "port"].filter((field) => {
+    const v = config[field];
+    return v === void 0 || v === null || v === "";
+  });
+  if (missingFields.length > 0) {
+    throw new Error(
+      `PGVector requires either connectionString or ${missingFields.join(", ")}`
+    );
+  }
+}
+function buildClientConfig(config, database) {
+  const connectionString = getConnectionString(config);
+  if (connectionString) {
+    return {
+      connectionString,
+      ...config.ssl !== void 0 ? { ssl: config.ssl } : {}
+    };
+  }
+  return {
+    database,
+    user: config.user,
+    password: config.password,
+    host: config.host,
+    port: config.port,
+    ...config.ssl !== void 0 ? { ssl: config.ssl } : {}
+  };
+}
 var PGVector = class {
   constructor(config) {
+    validateConnectionConfig(config);
     this.collectionName = validateIdentifier(
       config.collectionName || "memories",
       "collectionName"
     );
     this.useDiskann = config.diskann || false;
     this.useHnsw = config.hnsw || false;
-    this.dbName = validateIdentifier(config.dbname || "vector_store", "dbname");
+    this.useDirectConnection = !!getConnectionString(config);
+    this.dbName = this.useDirectConnection ? "" : validateIdentifier(config.dbname || "vector_store", "dbname");
     this.config = config;
-    this.client = new Client({
-      database: "postgres",
-      // Initially connect to default postgres database
-      user: config.user,
-      password: config.password,
-      host: config.host,
-      port: config.port
-    });
+    this.client = new Client(
+      buildClientConfig(
+        config,
+        this.useDirectConnection ? void 0 : "postgres"
+      )
+    );
     this.initialize().catch(console.error);
   }
   col() {
@@ -4586,19 +4686,15 @@ var PGVector = class {
   async _doInitialize() {
     try {
       await this.client.connect();
-      const dbExists = await this.checkDatabaseExists(this.dbName);
-      if (!dbExists) {
-        await this.createDatabase(this.dbName);
-      }
-      await this.client.end();
-      this.client = new Client({
-        database: this.dbName,
-        user: this.config.user,
-        password: this.config.password,
-        host: this.config.host,
-        port: this.config.port
-      });
-      await this.client.connect();
+      if (!this.useDirectConnection) {
+        const dbExists = await this.checkDatabaseExists(this.dbName);
+        if (!dbExists) {
+          await this.createDatabase(this.dbName);
+        }
+        await this.client.end();
+        this.client = new Client(buildClientConfig(this.config, this.dbName));
+        await this.client.connect();
+      }
       await this.client.query("CREATE EXTENSION IF NOT EXISTS vector");
       await this.client.query(`
         CREATE TABLE IF NOT EXISTS memory_migrations (
@@ -4869,6 +4965,10 @@ var LLMFactory = class {
         return new LangchainLLM(config);
       case "deepseek":
         return new DeepSeekLLM(config);
+      case "litellm":
+        return new LiteLLM(config);
+      case "minimax":
+        return new MiniMaxLLM(config);
       default:
         throw new Error(`Unsupported LLM provider: ${provider}`);
     }
@@ -5121,7 +5221,7 @@ var parse_vision_messages = async (messages) => {
 };
 
 // src/oss/src/utils/telemetry.ts
-var version = true ? "3.0.10" : "dev";
+var version = true ? "3.0.12" : "dev";
 var MEM0_TELEMETRY = true;
 var _a, _b;
 try {
@@ -6654,7 +6754,24 @@ var NON_SPECIFIC_ADJ = /* @__PURE__ */ new Set([
   "collaborative",
   "final",
   "initial",
-  "side"
+  "side",
+  "top"
+]);
+var TOPIC_PREFIX_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "my",
+  "your",
+  "our",
+  "their",
+  "his",
+  "her",
+  "its",
+  "this",
+  "that",
+  "these",
+  "those"
 ]);
 var GENERIC_ENDINGS = /* @__PURE__ */ new Set([
   "work",
@@ -6721,6 +6838,23 @@ var GENERIC_CAPS = /* @__PURE__ */ new Set([
   "advantages",
   "disadvantages"
 ]);
+var GENERIC_SINGLE_ENTITY_TERMS = /* @__PURE__ */ new Set([
+  "user",
+  "assistant",
+  "agent",
+  "customer",
+  "client",
+  "person",
+  "people",
+  "human",
+  "memory",
+  "message",
+  "conversation",
+  "chat",
+  "session",
+  "system",
+  "top"
+]);
 var FORMATTING_MARKERS = /* @__PURE__ */ new Set([
   "*",
   "-",
@@ -6767,22 +6901,64 @@ function stripGenericEnding(words) {
   }
   return words;
 }
-function isSentenceStart(tokens, idx, rawText) {
-  if (idx === 0) {
-    return true;
+function stripTopicPrefix(words) {
+  let start = 0;
+  while (start < words.length && TOPIC_PREFIX_WORDS.has(words[start].toLowerCase())) {
+    start++;
   }
-  const prev = tokens[idx - 1];
-  if (/[.!?:]$/.test(prev)) {
-    return true;
-  }
-  if (FORMATTING_MARKERS.has(prev)) {
-    return true;
-  }
-  const tokenStart = rawText.indexOf(tokens[idx]);
-  if (tokenStart > 0 && rawText.charAt(tokenStart - 1) === "\n") {
+  return words.slice(start);
+}
+function cleanToken(token) {
+  return token.replace(/^[^\w.]+|[^\w.]+$/g, "");
+}
+function tokenize(text) {
+  var _a2;
+  return (_a2 = text.match(
+    /[A-Za-z_][\w-]*(?:\.[A-Za-z_][\w-]*)*|\d[\d,]*(?:\.\d+)?|[,:;.!?&]/g
+  )) != null ? _a2 : [];
+}
+function isCapitalized(token) {
+  return /^[A-Z]/.test(token) && /[A-Za-z]/.test(token);
+}
+function hasInternalCapOrDigit(token) {
+  return /\d/.test(token) || /[A-Z]/.test(token.slice(1)) || /^[A-Z]{2,}$/.test(token);
+}
+function isBadSingleNameToken(token) {
+  const lower = token.toLowerCase();
+  return GENERIC_SINGLE_ENTITY_TERMS.has(lower) || GENERIC_CAPS.has(lower);
+}
+function looksLikeMetricCount(token) {
+  return /^\d[\d,]*(?:\.\d+)?$/.test(token);
+}
+function isMetricListContext(tokens, idx) {
+  const prev = idx > 0 ? tokens[idx - 1] : "";
+  const next = idx + 1 < tokens.length ? tokens[idx + 1] : "";
+  return [":", ",", ";"].includes(prev) || [",", ";"].includes(next);
+}
+function isSentenceStart(tokens, idx) {
+  if (idx === 0) return true;
+  return [".", "!", "?", ":"].includes(tokens[idx - 1]) || FORMATTING_MARKERS.has(tokens[idx - 1]);
+}
+function isListItemNameToken(tokens, idx) {
+  const token = cleanToken(tokens[idx]);
+  if (!isCapitalized(token) || isBadSingleNameToken(token)) return false;
+  const next = idx + 1 < tokens.length ? cleanToken(tokens[idx + 1]) : "";
+  if (!looksLikeMetricCount(next)) return false;
+  return isMetricListContext(tokens, idx) || isMetricListContext(tokens, idx + 1);
+}
+function isNameToken(tokens, idx) {
+  const token = cleanToken(tokens[idx]);
+  if (!token || !isCapitalized(token) || isBadSingleNameToken(token))
+    return false;
+  if (hasInternalCapOrDigit(token) || isListItemNameToken(tokens, idx))
     return true;
-  }
-  return false;
+  return !isSentenceStart(tokens, idx);
+}
+function cleanEntityText(text) {
+  return text.replace(/^\*+\s*|\s*\*+$/g, "").replace(/\s*:+$/g, "").replace(/^\d+\s*\.\s*/, "").replace(/\s+\d[\d,]*(?:\.\d+)?$/g, "").replace(/[.,;!?]+$/, "").trim().replace(/\s+/g, " ");
+}
+function isCoordinatedNameTopic(text) {
+  return /\b[A-Z][\w-]+\s+and\s+[A-Z][\w-]+\b/.test(text);
 }
 function extractQuoted(text) {
   const entities = [];
@@ -6803,62 +6979,57 @@ function extractQuoted(text) {
   }
   return entities;
 }
+function extractIdentifiers(text) {
+  const entities = [];
+  const identifierRe = /\b[A-Za-z_][\w-]*(?:\.[A-Za-z_][\w-]*)+\b/g;
+  let match;
+  while ((match = identifierRe.exec(text)) !== null) {
+    entities.push({ type: "IDENTIFIER", text: match[0] });
+  }
+  return entities;
+}
 function extractProper(text) {
   const entities = [];
-  const tokens = text.split(/\s+/).filter(Boolean);
-  const functionWords = /* @__PURE__ */ new Set([
-    "'s",
-    "of",
-    "the",
-    "in",
-    "and",
-    "for",
-    "at",
-    "is"
-  ]);
+  const tokens = tokenize(text);
+  const innerConnectors = /* @__PURE__ */ new Set(["of", "the", "in", "for", "at"]);
   let i = 0;
   while (i < tokens.length) {
-    const tok = tokens[i];
-    if (FORMATTING_MARKERS.has(tok)) {
+    const token = cleanToken(tokens[i]);
+    const next = i + 1 < tokens.length ? tokens[i + 1] : "";
+    const afterNext = i + 2 < tokens.length ? cleanToken(tokens[i + 2]) : "";
+    if (token && next === "&" && afterNext && isCapitalized(token) && isCapitalized(afterNext) && !isBadSingleNameToken(token) && !isBadSingleNameToken(afterNext)) {
+      entities.push({
+        type: "PROPER",
+        text: cleanEntityText(`${token} & ${afterNext}`)
+      });
+      i += 3;
+      continue;
+    }
+    if (!isNameToken(tokens, i)) {
       i++;
       continue;
     }
-    const isLabel = i + 1 < tokens.length && tokens[i + 1] === ":";
-    const isCap = tok.length > 0 && tok.charAt(0) === tok.charAt(0).toUpperCase() && /[A-Z]/.test(tok.charAt(0));
-    if (isCap && !isLabel) {
-      const seq = [
-        { token: tok, idx: i }
-      ];
-      let j = i + 1;
-      while (j < tokens.length) {
-        const t = tokens[j];
-        const tIsCap = t.length > 0 && t.charAt(0) === t.charAt(0).toUpperCase() && /[A-Z]/.test(t.charAt(0));
-        if (tIsCap || functionWords.has(t.toLowerCase())) {
-          seq.push({ token: t, idx: j });
-          j++;
-        } else {
-          break;
-        }
-      }
-      while (seq.length > 0 && functionWords.has(seq[seq.length - 1].token.toLowerCase())) {
-        seq.pop();
+    const span = [cleanToken(tokens[i])];
+    let j = i + 1;
+    while (j < tokens.length) {
+      const current = cleanToken(tokens[j]);
+      if (isNameToken(tokens, j)) {
+        span.push(current);
+        j++;
+        continue;
       }
-      if (seq.length > 0) {
-        const hasMidCap = seq.some(({ token, idx: tokenIdx }) => {
-          const isCapWord = /[A-Z]/.test(token.charAt(0)) && !functionWords.has(token.toLowerCase());
-          return isCapWord && !isSentenceStart(tokens, tokenIdx, text);
-        });
-        if (hasMidCap) {
-          const phrase = seq.map((s) => s.token).join(" ");
-          if (phrase.length > 2) {
-            entities.push({ type: "PROPER", text: phrase });
-          }
-        }
+      if (innerConnectors.has(current.toLowerCase()) && j + 1 < tokens.length && isNameToken(tokens, j + 1)) {
+        span.push(current, cleanToken(tokens[j + 1]));
+        j += 2;
+        continue;
       }
-      i = j;
-    } else {
-      i++;
+      break;
+    }
+    const phrase = cleanEntityText(span.join(" "));
+    if (phrase.length > 2) {
+      entities.push({ type: "PROPER", text: phrase });
     }
+    i = Math.max(j, i + 1);
   }
   return entities;
 }
@@ -6890,11 +7061,11 @@ function extractCompoundsWithNlp(text) {
     const filtered = words.filter(
       (w) => !NON_SPECIFIC_ADJ.has(w.toLowerCase())
     );
-    const cleaned = stripGenericEnding(filtered);
+    const cleaned = stripGenericEnding(stripTopicPrefix(filtered));
     if (cleaned.length >= 2) {
-      const phrase = cleaned.join(" ");
+      const phrase = cleanEntityText(cleaned.join(" "));
       if (phrase.length > 3) {
-        entities.push({ type: "COMPOUND", text: phrase });
+        entities.push({ type: "TOPIC", text: phrase });
       }
     }
   }
@@ -6902,7 +7073,7 @@ function extractCompoundsWithNlp(text) {
 }
 function extractCompoundsRegex(text) {
   const entities = [];
-  const compoundRe = /\b([A-Z][a-z]+(?:\s+(?:of|and|the|for|in)\s+)?[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b/g;
+  const compoundRe = /\b([A-Z][a-z]+(?:\s+(?:of|the|for|in)\s+)?[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b/g;
   let match;
   while ((match = compoundRe.exec(text)) !== null) {
     const phrase = match[1].trim();
@@ -6913,9 +7084,12 @@ function extractCompoundsRegex(text) {
         const filtered = words.filter(
           (w) => !NON_SPECIFIC_ADJ.has(w.toLowerCase())
         );
-        const cleaned = stripGenericEnding(filtered);
+        const cleaned = stripGenericEnding(stripTopicPrefix(filtered));
         if (cleaned.length >= 2) {
-          entities.push({ type: "COMPOUND", text: cleaned.join(" ") });
+          entities.push({
+            type: "TOPIC",
+            text: cleanEntityText(cleaned.join(" "))
+          });
         }
       }
     }
@@ -6937,9 +7111,12 @@ function extractCompoundsRegex(text) {
           const filtered = words.filter(
             (w) => !NON_SPECIFIC_ADJ.has(w.toLowerCase())
           );
-          const cleaned = stripGenericEnding(filtered);
+          const cleaned = stripGenericEnding(stripTopicPrefix(filtered));
           if (cleaned.length >= 2) {
-            entities.push({ type: "COMPOUND", text: cleaned.join(" ") });
+            entities.push({
+              type: "TOPIC",
+              text: cleanEntityText(cleaned.join(" "))
+            });
           }
         }
       }
@@ -6952,6 +7129,7 @@ function extractEntities(text) {
   const raw = [];
   raw.push(...extractQuoted(text));
   raw.push(...extractProper(text));
+  raw.push(...extractIdentifiers(text));
   if (nlp) {
     raw.push(...extractCompoundsWithNlp(text));
   } else {
@@ -6969,13 +7147,13 @@ function extractEntities(text) {
   const cleaned = [];
   for (const entity of deduped) {
     let txt = entity.text.trim();
-    txt = txt.replace(/^\*+\s*|\s*\*+$/g, "");
-    txt = txt.replace(/\s*:+$/, "");
-    txt = txt.replace(/^\d+\s*\.\s*/, "");
-    txt = txt.replace(/[.,;!?]+$/, "").trim();
+    txt = cleanEntityText(txt);
     if (!txt || txt.length <= 2 || hasArtifacts(txt)) {
       continue;
     }
+    if (entity.type === "TOPIC" && (/^\d/.test(txt) || isCoordinatedNameTopic(txt))) {
+      continue;
+    }
     if (entity.type === "PROPER" && !txt.includes(" ") && GENERIC_CAPS.has(txt.toLowerCase())) {
       continue;
     }
@@ -6983,9 +7161,9 @@ function extractEntities(text) {
   }
   const typePriority = {
     PROPER: 0,
-    COMPOUND: 1,
+    IDENTIFIER: 1,
     QUOTED: 2,
-    NOUN: 3
+    TOPIC: 3
   };
   const best = /* @__PURE__ */ new Map();
   for (const entity of cleaned) {
@@ -6996,10 +7174,14 @@ function extractEntities(text) {
     }
   }
   const bestEntities = Array.from(best.values());
-  const allLower = bestEntities.map((e) => e.text.toLowerCase());
   return bestEntities.filter(
-    (entity) => !allLower.some(
-      (other) => entity.text.toLowerCase() !== other && other.includes(entity.text.toLowerCase())
+    (entity) => !bestEntities.some(
+      (other) => {
+        var _a3, _b3;
+        return entity.text.toLowerCase() !== other.text.toLowerCase() && ((_a3 = typePriority[entity.type]) != null ? _a3 : 99) >= ((_b3 = typePriority[other.type]) != null ? _b3 : 99) && new RegExp(
+          `(^|\\s)${entity.text.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(\\s|$)`
+        ).test(other.text.toLowerCase());
+      }
     )
   );
 }
@@ -7291,6 +7473,32 @@ var Memory = class _Memory {
     if (payload.run_id) filters.run_id = payload.run_id;
     return filters;
   }
+  _normalizeEntityText(value) {
+    return value.trim().toLowerCase().replace(/\s+/g, " ");
+  }
+  async _existingEntitiesByText(entityStore, filters) {
+    var _a2;
+    const rowsByText = /* @__PURE__ */ new Map();
+    let rows = [];
+    try {
+      const listed = await entityStore.list(filters, 1e4);
+      rows = Array.isArray(listed) && Array.isArray(listed[0]) ? listed[0] : listed;
+    } catch (e) {
+      console.debug(
+        `Exact entity lookup failed, falling back to semantic dedup: ${e}`
+      );
+      return rowsByText;
+    }
+    for (const row of rows) {
+      const text = (_a2 = row.payload) == null ? void 0 : _a2.data;
+      if (typeof text !== "string") continue;
+      const key = this._normalizeEntityText(text);
+      if (key && !rowsByText.has(key)) {
+        rowsByText.set(key, row);
+      }
+    }
+    return rowsByText;
+  }
   /**
    * Remove `memoryId` from every entity record scoped to `filters`.
    * If an entity's `linkedMemoryIds` becomes empty after removal, the
@@ -7368,6 +7576,10 @@ var Memory = class _Memory {
       const entities = extractEntities(text);
       if (entities.length === 0) return;
       const entityStore = await this.getEntityStore();
+      const exactMatches = await this._existingEntitiesByText(
+        entityStore,
+        filters
+      );
       for (const entity of entities) {
         try {
           let entityVec;
@@ -7378,12 +7590,18 @@ var Memory = class _Memory {
             continue;
           }
           let matches = [];
-          try {
-            matches = await entityStore.search(entityVec, 1, filters);
-          } catch (e) {
+          const exactMatch = exactMatches.get(
+            this._normalizeEntityText(entity.text)
+          );
+          if (!exactMatch) {
+            try {
+              matches = await entityStore.search(entityVec, 1, filters);
+            } catch (e) {
+            }
           }
-          if (matches.length > 0 && ((_a2 = matches[0].score) != null ? _a2 : 0) >= 0.95) {
-            const match = matches[0];
+          const semanticMatch = matches.length > 0 && ((_a2 = matches[0].score) != null ? _a2 : 0) >= 0.95 ? matches[0] : void 0;
+          const match = exactMatch != null ? exactMatch : semanticMatch;
+          if (match) {
             const payload = match.payload || {};
             const linked = new Set(
               Array.isArray(payload.linkedMemoryIds) ? payload.linkedMemoryIds : []
@@ -7900,6 +8118,10 @@ var Memory = class _Memory {
         }
         if (valid.length > 0) {
           const entityStore = await this.getEntityStore();
+          const exactMatches = await this._existingEntitiesByText(
+            entityStore,
+            filters
+          );
           const toInsertVectors = [];
           const toInsertIds = [];
           const toInsertPayloads = [];
@@ -7907,12 +8129,16 @@ var Memory = class _Memory {
             const { entityType, entityText, memoryIds } = globalEntities[key];
             const entityVec = entityEmbeddings[j];
             let matches = [];
-            try {
-              matches = await entityStore.search(entityVec, 1, filters);
-            } catch (e) {
+            const exactMatch = exactMatches.get(key);
+            if (!exactMatch) {
+              try {
+                matches = await entityStore.search(entityVec, 1, filters);
+              } catch (e) {
+              }
             }
-            if (matches.length > 0 && ((_f = matches[0].score) != null ? _f : 0) >= 0.95) {
-              const match = matches[0];
+            const semanticMatch = matches.length > 0 && ((_f = matches[0].score) != null ? _f : 0) >= 0.95 ? matches[0] : void 0;
+            const match = exactMatch != null ? exactMatch : semanticMatch;
+            if (match) {
               const payload = match.payload || {};
               const linked = new Set((_g = payload.linkedMemoryIds) != null ? _g : []);
               for (const mid of memoryIds) linked.add(mid);
@@ -8284,7 +8510,9 @@ var Memory = class _Memory {
       has_agent_id: !!config.agentId,
       has_run_id: !!config.runId
     });
-    const { userId, agentId, runId } = config;
+    const userId = validateAndTrimEntityId(config.userId, "userId");
+    const agentId = validateAndTrimEntityId(config.agentId, "agentId");
+    const runId = validateAndTrimEntityId(config.runId, "runId");
     const filters = {};
     if (userId) filters.user_id = userId;
     if (agentId) filters.agent_id = agentId;
@@ -8641,6 +8869,7 @@ export {
   LangchainEmbedder,
   LangchainLLM,
   LangchainVectorStore,
+  LiteLLM,
   Memory,
   MemoryConfigSchema,
   MemoryVectorStore,