mem0ai 3.0.6 → 3.0.8

package/dist/oss/index.mjs

@@ -68,6 +68,7 @@ var OpenAIEmbedder = class {
     const response = await this.openai.embeddings.create({
       model: this.model,
       input: text,
+      encoding_format: "float",
       ...this.embeddingDims !== void 0 && {
         dimensions: this.embeddingDims
       }
@@ -82,6 +83,7 @@ var OpenAIEmbedder = class {
       const response = await this.openai.embeddings.create({
         model: this.model,
         input: chunk,
+        encoding_format: "float",
         ...this.embeddingDims !== void 0 && {
           dimensions: this.embeddingDims
         }
@@ -168,8 +170,8 @@ var DEFAULT_MODEL = "nomic-ai/nomic-embed-text-v1.5-GGUF/nomic-embed-text-v1.5.f
 var DEFAULT_LMSTUDIO_API_KEY = "lm-studio";
 var LMStudioEmbedder = class {
   constructor(config) {
-    var _a2, _b;
-    const baseURL = (_b = (_a2 = config.baseURL) != null ? _a2 : config.url) != null ? _b : DEFAULT_BASE_URL;
+    var _a2, _b2;
+    const baseURL = (_b2 = (_a2 = config.baseURL) != null ? _a2 : config.url) != null ? _b2 : DEFAULT_BASE_URL;
     const apiKey = config.apiKey || DEFAULT_LMSTUDIO_API_KEY;
     this.openai = new OpenAI2({ apiKey, baseURL: String(baseURL) });
     this.model = config.model || DEFAULT_MODEL;
@@ -198,7 +200,7 @@ var LMStudioEmbedder = class {
         input: normalized,
         encoding_format: "float"
       });
-      return response.data.map((item) => item.embedding);
+      return response.data.sort((a, b) => a.index - b.index).map((item) => item.embedding);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       throw new Error(`LM Studio embedder failed: ${message}`);
@@ -1163,7 +1165,7 @@ var Qdrant = class {
     }
   }
   async ensureCollection(name, size) {
-    var _a2, _b, _c;
+    var _a2, _b2, _c;
     try {
       await this.client.createCollection(name, {
         vectors: {
@@ -1176,7 +1178,7 @@ var Qdrant = class {
         if (name === this.collectionName) {
           try {
             const collectionInfo = await this.client.getCollection(name);
-            const vectorConfig = (_b = (_a2 = collectionInfo.config) == null ? void 0 : _a2.params) == null ? void 0 : _b.vectors;
+            const vectorConfig = (_b2 = (_a2 = collectionInfo.config) == null ? void 0 : _a2.params) == null ? void 0 : _b2.vectors;
             if (vectorConfig && vectorConfig.size !== size) {
               throw new Error(
                 `Collection ${name} exists but has wrong vector size. Expected: ${size}, got: ${vectorConfig.size}`
@@ -1263,7 +1265,7 @@ var VectorizeDB = class {
     return null;
   }
   async search(query, topK = 5, filters) {
-    var _a2, _b;
+    var _a2, _b2;
     try {
       const result = await ((_a2 = this.client) == null ? void 0 : _a2.vectorize.indexes.query(
         this.indexName,
@@ -1275,7 +1277,7 @@ var VectorizeDB = class {
           topK
         }
       ));
-      return ((_b = result == null ? void 0 : result.matches) == null ? void 0 : _b.map((match) => ({
+      return ((_b2 = result == null ? void 0 : result.matches) == null ? void 0 : _b2.map((match) => ({
         id: match.id,
         payload: match.metadata,
         score: match.score
@@ -1370,7 +1372,7 @@ var VectorizeDB = class {
     }
   }
   async list(filters, topK = 20) {
-    var _a2, _b;
+    var _a2, _b2;
     try {
       const result = await ((_a2 = this.client) == null ? void 0 : _a2.vectorize.indexes.query(
         this.indexName,
@@ -1383,7 +1385,7 @@ var VectorizeDB = class {
           returnMetadata: "all"
         }
       ));
-      const matches = ((_b = result == null ? void 0 : result.matches) == null ? void 0 : _b.map((match) => ({
+      const matches = ((_b2 = result == null ? void 0 : result.matches) == null ? void 0 : _b2.map((match) => ({
         id: match.id,
         payload: match.metadata,
         score: match.score
@@ -1407,7 +1409,7 @@ var VectorizeDB = class {
     );
   }
   async getUserId() {
-    var _a2, _b, _c;
+    var _a2, _b2, _c;
     try {
       let found = false;
       for await (const index of this.client.vectorize.indexes.list({
@@ -1427,7 +1429,7 @@ var VectorizeDB = class {
           }
         }));
       }
-      const result = await ((_b = this.client) == null ? void 0 : _b.vectorize.indexes.query(
+      const result = await ((_b2 = this.client) == null ? void 0 : _b2.vectorize.indexes.query(
         "memory_migrations",
         {
           account_id: this.accountId,
@@ -1466,7 +1468,7 @@ var VectorizeDB = class {
     }
   }
   async setUserId(userId) {
-    var _a2, _b;
+    var _a2, _b2;
     try {
       const result = await ((_a2 = this.client) == null ? void 0 : _a2.vectorize.indexes.query(
         "memory_migrations",
@@ -1489,7 +1491,7 @@ var VectorizeDB = class {
           method: "POST",
           headers: {
             "Content-Type": "application/x-ndjson",
-            Authorization: `Bearer ${(_b = this.client) == null ? void 0 : _b.apiToken}`
+            Authorization: `Bearer ${(_b2 = this.client) == null ? void 0 : _b2.apiToken}`
           },
           body: JSON.stringify(data) + "\n"
           // ndjson format
@@ -1509,7 +1511,7 @@ var VectorizeDB = class {
     return this._initPromise;
   }
   async _doInitialize() {
-    var _a2, _b, _c, _d, _e;
+    var _a2, _b2, _c, _d, _e;
     try {
       let indexFound = false;
       for await (const idx of this.client.vectorize.indexes.list({
@@ -1532,7 +1534,7 @@ var VectorizeDB = class {
           }));
           const properties2 = ["userId", "agentId", "runId"];
           for (const propertyName of properties2) {
-            await ((_b = this.client) == null ? void 0 : _b.vectorize.indexes.metadataIndex.create(
+            await ((_b2 = this.client) == null ? void 0 : _b2.vectorize.indexes.metadataIndex.create(
               this.indexName,
               {
                 account_id: this.accountId,
@@ -1885,7 +1887,7 @@ var RedisDB = class {
         return {
           id: doc.value.memory_id,
           payload: toCamelCase(resultPayload),
-          score: (_a2 = Number(doc.value.__vector_score)) != null ? _a2 : 0
+          score: Math.max(0, 1 - ((_a2 = Number(doc.value.__vector_score)) != null ? _a2 : 0))
         };
       });
     } catch (error) {
@@ -2585,7 +2587,7 @@ var SQLiteManager = class {
   }
   async batchAddHistory(records) {
     const txn = this.db.transaction(() => {
-      var _a2, _b, _c;
+      var _a2, _b2, _c;
       for (const record of records) {
         this.stmtInsert.run(
           record.memoryId,
@@ -2593,7 +2595,7 @@ var SQLiteManager = class {
           record.newValue,
           record.action,
           (_a2 = record.createdAt) != null ? _a2 : null,
-          (_b = record.updatedAt) != null ? _b : null,
+          (_b2 = record.updatedAt) != null ? _b2 : null,
           (_c = record.isDeleted) != null ? _c : 0
         );
       }
@@ -3445,12 +3447,12 @@ function truncateContent(text, limit = PAST_MESSAGE_TRUNCATION_LIMIT) {
   return text.slice(0, limit) + "...";
 }
 function formatConversationHistory(messages) {
-  var _a2, _b;
+  var _a2, _b2;
   if (!messages || messages.length === 0) return "";
   let result = "";
   for (const msg of messages) {
     const role = (_a2 = msg.role) != null ? _a2 : "";
-    const content = (_b = msg.content) != null ? _b : "";
+    const content = (_b2 = msg.content) != null ? _b2 : "";
     if (role && content) {
       result += `${role}: ${truncateContent(content)}
 `;
@@ -3462,10 +3464,10 @@ function serializeMemories(memories) {
   return JSON.stringify(memories != null ? memories : []);
 }
 function generateAdditiveExtractionPrompt(options) {
-  var _a2, _b, _c;
+  var _a2, _b2, _c;
   const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const currentDate = (_a2 = options.currentDate) != null ? _a2 : now;
-  const observationDate = (_b = options.observationDate) != null ? _b : currentDate;
+  const observationDate = (_b2 = options.observationDate) != null ? _b2 : currentDate;
   const sections = [];
   sections.push("## Summary\n");
   sections.push(
@@ -3636,14 +3638,14 @@ var LangchainLLM = class {
     this.modelName = this.llmInstance.modelId || this.llmInstance.model || "langchain-model";
   }
   async generateResponse(messages, response_format, tools) {
-    var _a2, _b, _c, _d, _e;
+    var _a2, _b2, _c, _d, _e;
     const langchainMessages = convertToLangchainMessages(messages);
     let runnable = this.llmInstance;
     const invokeOptions = {};
     let isStructuredOutput = false;
     let selectedSchema = null;
     const systemPromptContent = ((_a2 = messages.find((m) => m.role === "system")) == null ? void 0 : _a2.content) || "";
-    const userPromptContent = ((_b = messages.find((m) => m.role === "user")) == null ? void 0 : _b.content) || "";
+    const userPromptContent = ((_b2 = messages.find((m) => m.role === "user")) == null ? void 0 : _b2.content) || "";
     if (systemPromptContent.includes("Personal Information Organizer") && systemPromptContent.includes("extract relevant pieces of information")) {
       selectedSchema = FactRetrievalSchema;
     } else if (userPromptContent.includes("smart memory manager") && userPromptContent.includes("Compare newly retrieved facts")) {
@@ -3773,7 +3775,7 @@ var LangchainVectorStore = class {
   // Simple in-memory user ID
   constructor(config) {
     this.storeUserId = "anonymous-langchain-user";
-    var _a2, _b;
+    var _a2, _b2;
     if (!config.client || typeof config.client !== "object") {
       throw new Error(
         "Langchain vector store provider requires an initialized Langchain VectorStore instance passed via the 'client' field."
@@ -3789,7 +3791,7 @@ var LangchainVectorStore = class {
     if (!this.dimension && ((_a2 = this.lcStore.embeddings) == null ? void 0 : _a2.embeddingDimension)) {
       this.dimension = this.lcStore.embeddings.embeddingDimension;
     }
-    if (!this.dimension && ((_b = this.lcStore.embedding) == null ? void 0 : _b.embeddingDimension)) {
+    if (!this.dimension && ((_b2 = this.lcStore.embedding) == null ? void 0 : _b2.embeddingDimension)) {
       this.dimension = this.lcStore.embedding.embeddingDimension;
     }
     if (!this.dimension) {
@@ -4935,13 +4937,13 @@ var DEFAULT_MEMORY_CONFIG = {
 // src/oss/src/config/manager.ts
 var ConfigManager = class {
   static mergeConfig(userConfig = {}) {
-    var _a2, _b, _c, _d, _e, _f, _g;
+    var _a2, _b2, _c, _d, _e, _f, _g;
     const mergedConfig = {
       version: userConfig.version || DEFAULT_MEMORY_CONFIG.version,
       embedder: {
         provider: ((_a2 = userConfig.embedder) == null ? void 0 : _a2.provider) || DEFAULT_MEMORY_CONFIG.embedder.provider,
         config: (() => {
-          var _a3, _b2, _c2, _d2;
+          var _a3, _b3, _c2, _d2;
           const defaultConf = DEFAULT_MEMORY_CONFIG.embedder.config;
           const userConf = (_a3 = userConfig.embedder) == null ? void 0 : _a3.config;
           let finalModel = defaultConf.model;
@@ -4950,7 +4952,7 @@ var ConfigManager = class {
           } else if ((userConf == null ? void 0 : userConf.model) && typeof userConf.model === "string") {
             finalModel = userConf.model;
           }
-          const baseURL = (_c2 = (_b2 = userConf == null ? void 0 : userConf.baseURL) != null ? _b2 : userConf == null ? void 0 : userConf.lmstudio_base_url) != null ? _c2 : userConf == null ? void 0 : userConf.url;
+          const baseURL = (_c2 = (_b3 = userConf == null ? void 0 : userConf.baseURL) != null ? _b3 : userConf == null ? void 0 : userConf.lmstudio_base_url) != null ? _c2 : userConf == null ? void 0 : userConf.url;
           const embeddingDims = (_d2 = userConf == null ? void 0 : userConf.embeddingDims) != null ? _d2 : userConf == null ? void 0 : userConf.embedding_dims;
           return {
             apiKey: (userConf == null ? void 0 : userConf.apiKey) !== void 0 ? userConf.apiKey : defaultConf.apiKey,
@@ -4963,12 +4965,12 @@ var ConfigManager = class {
         })()
       },
       vectorStore: {
-        provider: ((_b = userConfig.vectorStore) == null ? void 0 : _b.provider) || DEFAULT_MEMORY_CONFIG.vectorStore.provider,
+        provider: ((_b2 = userConfig.vectorStore) == null ? void 0 : _b2.provider) || DEFAULT_MEMORY_CONFIG.vectorStore.provider,
         config: (() => {
-          var _a3, _b2, _c2;
+          var _a3, _b3, _c2;
           const defaultConf = DEFAULT_MEMORY_CONFIG.vectorStore.config;
           const userConf = (_a3 = userConfig.vectorStore) == null ? void 0 : _a3.config;
-          const explicitDimension = (userConf == null ? void 0 : userConf.dimension) || ((_c2 = (_b2 = userConfig.embedder) == null ? void 0 : _b2.config) == null ? void 0 : _c2.embeddingDims) || void 0;
+          const explicitDimension = (userConf == null ? void 0 : userConf.dimension) || ((_c2 = (_b3 = userConfig.embedder) == null ? void 0 : _b3.config) == null ? void 0 : _c2.embeddingDims) || void 0;
           if ((userConf == null ? void 0 : userConf.client) && typeof userConf.client === "object") {
             return {
               client: userConf.client,
@@ -4992,7 +4994,7 @@ var ConfigManager = class {
       llm: {
         provider: ((_c = userConfig.llm) == null ? void 0 : _c.provider) || DEFAULT_MEMORY_CONFIG.llm.provider,
         config: (() => {
-          var _a3, _b2, _c2, _d2;
+          var _a3, _b3, _c2, _d2;
           const defaultConf = DEFAULT_MEMORY_CONFIG.llm.config;
           const userConf = (_a3 = userConfig.llm) == null ? void 0 : _a3.config;
           let finalModel = defaultConf.model;
@@ -5001,7 +5003,7 @@ var ConfigManager = class {
           } else if ((userConf == null ? void 0 : userConf.model) && typeof userConf.model === "string") {
             finalModel = userConf.model;
           }
-          const llmBaseURL = (_d2 = (_c2 = (_b2 = userConf == null ? void 0 : userConf.baseURL) != null ? _b2 : userConf == null ? void 0 : userConf.lmstudio_base_url) != null ? _c2 : userConf == null ? void 0 : userConf.url) != null ? _d2 : defaultConf.baseURL;
+          const llmBaseURL = (_d2 = (_c2 = (_b3 = userConf == null ? void 0 : userConf.baseURL) != null ? _b3 : userConf == null ? void 0 : userConf.lmstudio_base_url) != null ? _c2 : userConf == null ? void 0 : userConf.url) != null ? _d2 : defaultConf.baseURL;
           return {
             baseURL: llmBaseURL,
             url: userConf == null ? void 0 : userConf.url,
@@ -5014,7 +5016,7 @@ var ConfigManager = class {
       historyDbPath: userConfig.historyDbPath || ((_e = (_d = userConfig.historyStore) == null ? void 0 : _d.config) == null ? void 0 : _e.historyDbPath) || ((_g = (_f = DEFAULT_MEMORY_CONFIG.historyStore) == null ? void 0 : _f.config) == null ? void 0 : _g.historyDbPath),
       customInstructions: userConfig.customInstructions,
       historyStore: (() => {
-        var _a3, _b2;
+        var _a3, _b3;
         const defaultHistoryStore = DEFAULT_MEMORY_CONFIG.historyStore;
         const historyProvider = ((_a3 = userConfig.historyStore) == null ? void 0 : _a3.provider) || defaultHistoryStore.provider;
         const isSqlite = historyProvider.toLowerCase() === "sqlite";
@@ -5025,7 +5027,7 @@ var ConfigManager = class {
           config: {
             ...isSqlite ? defaultHistoryStore.config : {},
             ...isSqlite && userConfig.historyDbPath ? { historyDbPath: userConfig.historyDbPath } : {},
-            ...(_b2 = userConfig.historyStore) == null ? void 0 : _b2.config
+            ...(_b3 = userConfig.historyStore) == null ? void 0 : _b3.config
           }
         };
       })(),
@@ -5073,15 +5075,16 @@ var parse_vision_messages = async (messages) => {
 };
 
 // src/oss/src/utils/telemetry.ts
-var version = true ? "3.0.6" : "dev";
+var version = true ? "3.0.8" : "dev";
 var MEM0_TELEMETRY = true;
-var _a;
+var _a, _b;
 try {
-  MEM0_TELEMETRY = ((_a = process == null ? void 0 : process.env) == null ? void 0 : _a.MEM0_TELEMETRY) === "false" ? false : true;
+  MEM0_TELEMETRY = ((_b = (_a = process == null ? void 0 : process.env) == null ? void 0 : _a.MEM0_TELEMETRY) == null ? void 0 : _b.toLowerCase()) === "false" ? false : true;
 } catch (error) {
 }
 var POSTHOG_API_KEY = "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX";
 var POSTHOG_HOST = "https://us.i.posthog.com/i/v0/e/";
+var NOTICE_EVENT_NAME = "mem0.notice_displayed";
 var DEFAULT_SAMPLE_RATE = 0.1;
 var MEM0_TELEMETRY_SAMPLE_RATE = (() => {
   var _a2;
@@ -5097,7 +5100,11 @@ var MEM0_TELEMETRY_SAMPLE_RATE = (() => {
   }
   return DEFAULT_SAMPLE_RATE;
 })();
-var LIFECYCLE_EVENTS = /* @__PURE__ */ new Set(["init", "reset"]);
+var ALWAYS_SEND_EVENTS = /* @__PURE__ */ new Set([
+  "init",
+  "reset",
+  "notice_displayed"
+]);
 var UnifiedTelemetry = class {
   constructor(projectApiKey, host) {
     this.apiKey = projectApiKey;
@@ -5137,13 +5144,16 @@ var UnifiedTelemetry = class {
   }
 };
 var telemetry = new UnifiedTelemetry(POSTHOG_API_KEY, POSTHOG_HOST);
+function isTelemetryEnabled() {
+  return MEM0_TELEMETRY;
+}
 async function captureClientEvent(eventName, instance, additionalData = {}) {
   if (!instance.telemetryId) {
     console.warn("No telemetry ID found for instance");
     return;
   }
-  const isLifecycle = LIFECYCLE_EVENTS.has(eventName);
-  if (!isLifecycle && Math.random() >= MEM0_TELEMETRY_SAMPLE_RATE) {
+  const alwaysSend = ALWAYS_SEND_EVENTS.has(eventName);
+  if (!alwaysSend && Math.random() >= MEM0_TELEMETRY_SAMPLE_RATE) {
     return;
   }
   const eventData = {
@@ -5155,7 +5165,7 @@ async function captureClientEvent(eventName, instance, additionalData = {}) {
     client_source: "nodejs",
     ...additionalData,
     // sample_rate set AFTER the spread so callers can never override it
-    sample_rate: isLifecycle ? 1 : MEM0_TELEMETRY_SAMPLE_RATE
+    sample_rate: alwaysSend ? 1 : MEM0_TELEMETRY_SAMPLE_RATE
   };
   await telemetry.captureEvent(
     instance.telemetryId,
@@ -5163,6 +5173,1038 @@ async function captureClientEvent(eventName, instance, additionalData = {}) {
     eventData
   );
 }
+async function captureNoticeEvent(instance, properties = {}) {
+  if (!instance.telemetryId) return;
+  const eventData = {
+    function: `${instance.constructor.name}`,
+    method: "notice_displayed",
+    api_host: instance.host,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    client_version: version,
+    client_source: "nodejs",
+    ...properties,
+    sample_rate: 1
+  };
+  await telemetry.captureEvent(
+    instance.telemetryId,
+    NOTICE_EVENT_NAME,
+    eventData
+  );
+}
+
+// src/oss/src/utils/notices.ts
+import * as fs4 from "fs";
+import * as os2 from "os";
+import * as path3 from "path";
+var NOTICE_FLAG_KEY = "mem0-oss-notices";
+var NOTICE_STATE_SECTION = "notice_state";
+var FIRST_RUN_NOTICE_ID = "first_run";
+var TEMPORAL_FEATURE_NOTICE_ID = "temporal_stub";
+var TEMPORAL_USAGE_NOTICE_ID = "temporal_usage";
+var DECAY_FEATURE_NOTICE_ID = "decay_stub";
+var DECAY_USAGE_NOTICE_ID = "decay_usage";
+var SCALE_THRESHOLD_NOTICE_ID = "scale_threshold";
+var PERFORMANCE_SLOW_QUERY_NOTICE_ID = "performance_slow_query";
+var NOTICE_CAP_LIMIT = 10;
+var NOTICE_CAP_WINDOW_MS = 7 * 24 * 60 * 60 * 1e3;
+var NOTICE_FLAG_TIMEOUT_MS = 500;
+var POSTHOG_FLAGS_URL = "https://us.i.posthog.com/flags?v=2";
+var DISPLAYED_VARIANT = "displayed";
+var HOLDOUT_VARIANT = "holdout";
+var LOG_LINE_NOTICE_TYPE = "log_line";
+var ERROR_NOTICE_TYPE = "error";
+var TEMPORAL_TIMESTAMP_PLAIN_ERROR = "The timestamp parameter is not supported by the OSS Memory SDK.";
+var TEMPORAL_REFERENCE_DATE_PLAIN_ERROR = "The referenceDate parameter is not supported by the OSS Memory SDK.";
+var DECAY_FEATURE_PLAIN_ERROR = "The decay parameter is not supported by the OSS Memory SDK.";
+var DECAY_USAGE_DELETE_THRESHOLD = 5;
+var SCALE_MEMORY_COUNT_THRESHOLD = 2e3;
+var SCALE_MEMORY_COUNT_CHECK_INTERVAL = 100;
+var SCALE_TOP_K_THRESHOLD = 50;
+var PERFORMANCE_SLOW_QUERY_THRESHOLD_MS = 2e3;
+var MAX_TEMPORAL_DETECTION_DEPTH = 32;
+var ISO_DATE_RE = /\b\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)?\b/;
+var RELATIVE_TIME_RE = /\b(today|yesterday|tomorrow|last\s+(?:night|week|month|year)|this\s+(?:week|month|year)|next\s+(?:week|month|year)|(?:past|last)\s+\d+\s+(?:day|days|week|weeks|month|months|year|years)|(?:since|before|after|until)\s+(?:today|yesterday|tomorrow|\d{4}-\d{2}-\d{2}|last\s+(?:week|month|year)))\b/i;
+var RANGE_OPERATORS = /* @__PURE__ */ new Set(["gt", "gte", "lt", "lte"]);
+var firstRunConsumedInProcess = false;
+var firstRunClaimInProgress = false;
+var decayUsageSuccessfulDeleteCount = 0;
+var noticeCapacityReachedInProcess = /* @__PURE__ */ new Set();
+var scaleMemoryCountAddsSinceCheck = 0;
+var scaleMemoryCountCheckedInProcess = false;
+var scaleMemoryCountThresholdEvaluatedInProcess = false;
+function getMem0Dir() {
+  return process.env.MEM0_DIR || path3.join(os2.homedir(), ".mem0");
+}
+function getMem0ConfigPath() {
+  return path3.join(getMem0Dir(), "config.json");
+}
+function loadMem0Config() {
+  try {
+    const configPath = getMem0ConfigPath();
+    if (!fs4.existsSync(configPath)) return {};
+    const parsed = JSON.parse(fs4.readFileSync(configPath, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch (e) {
+    return {};
+  }
+}
+function writeMem0ConfigAtomic(config) {
+  const configPath = getMem0ConfigPath();
+  const dir = path3.dirname(configPath);
+  const tempPath = path3.join(
+    dir,
+    `.config.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`
+  );
+  try {
+    fs4.mkdirSync(dir, { recursive: true });
+    fs4.writeFileSync(tempPath, JSON.stringify(config, null, 4));
+    fs4.renameSync(tempPath, configPath);
+    return true;
+  } catch (e) {
+    try {
+      if (fs4.existsSync(tempPath)) fs4.unlinkSync(tempPath);
+    } catch (e2) {
+    }
+    return false;
+  }
+}
+function getNoticeState(config, noticeId) {
+  const stateSection = config[NOTICE_STATE_SECTION] && typeof config[NOTICE_STATE_SECTION] === "object" && !Array.isArray(config[NOTICE_STATE_SECTION]) ? config[NOTICE_STATE_SECTION] : {};
+  const noticeState = stateSection[noticeId];
+  return noticeState && typeof noticeState === "object" && !Array.isArray(noticeState) ? noticeState : {};
+}
+function setNoticeState(config, noticeId, state) {
+  const stateSection = config[NOTICE_STATE_SECTION] && typeof config[NOTICE_STATE_SECTION] === "object" && !Array.isArray(config[NOTICE_STATE_SECTION]) ? { ...config[NOTICE_STATE_SECTION] } : {};
+  return {
+    ...config,
+    [NOTICE_STATE_SECTION]: {
+      ...stateSection,
+      [noticeId]: state
+    }
+  };
+}
+function parsePayload(payload) {
+  try {
+    if (typeof payload === "string") {
+      const parsed = JSON.parse(payload);
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+    }
+    return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function getNoticeConfigFromPayload(payload, noticeId) {
+  const parsedPayload = parsePayload(payload);
+  const notices = parsedPayload == null ? void 0 : parsedPayload.notices;
+  if (!notices || typeof notices !== "object" || Array.isArray(notices)) {
+    return { found: false, payload: parsedPayload };
+  }
+  const noticeConfig = notices[noticeId];
+  if (!noticeConfig || typeof noticeConfig !== "object" || Array.isArray(noticeConfig)) {
+    return { found: false, payload: parsedPayload };
+  }
+  return {
+    found: true,
+    config: noticeConfig,
+    payload: parsedPayload
+  };
+}
+async function evaluateNoticeFlag(distinctId, options = {}) {
+  var _a2, _b2, _c, _d;
+  if (!isTelemetryEnabled()) return null;
+  const timeoutMs = (_a2 = options.timeoutMs) != null ? _a2 : NOTICE_FLAG_TIMEOUT_MS;
+  const fetchImpl = (_b2 = options.fetchImpl) != null ? _b2 : fetch;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(POSTHOG_FLAGS_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        api_key: POSTHOG_API_KEY,
+        distinct_id: distinctId
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    const flag = (_c = data == null ? void 0 : data.flags) == null ? void 0 : _c[NOTICE_FLAG_KEY];
+    if (!flag || flag.enabled === false) return null;
+    const variant = typeof flag.variant === "string" ? flag.variant : null;
+    if (!variant) return null;
+    return {
+      variant,
+      payload: parsePayload((_d = flag.metadata) == null ? void 0 : _d.payload),
+      flag
+    };
+  } catch (e) {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function eventsInWindow(events, now, windowMs) {
+  if (!Array.isArray(events)) return [];
+  const cutoff = now.getTime() - windowMs;
+  return events.filter((event) => {
+    if (!event || typeof event !== "object" || Array.isArray(event)) {
+      return false;
+    }
+    const evaluatedAt = event.evaluated_at;
+    if (typeof evaluatedAt !== "string") return false;
+    const timestamp = Date.parse(evaluatedAt);
+    return Number.isFinite(timestamp) && timestamp >= cutoff;
+  });
+}
+function hasNoticeCapRoom(state, options = {}) {
+  var _a2, _b2, _c;
+  const now = (_a2 = options.now) != null ? _a2 : /* @__PURE__ */ new Date();
+  const limit = (_b2 = options.limit) != null ? _b2 : NOTICE_CAP_LIMIT;
+  const windowMs = (_c = options.windowMs) != null ? _c : NOTICE_CAP_WINDOW_MS;
+  return eventsInWindow(state.events, now, windowMs).length < limit;
+}
+function isNoticeCapacityReachedInProcess(noticeId) {
+  return noticeCapacityReachedInProcess.has(noticeId);
+}
+function markNoticeCapacityReachedInProcess(noticeId) {
+  noticeCapacityReachedInProcess.add(noticeId);
+}
+function hasNoticeCapRoomForNotice(noticeId, state, options = {}) {
+  const hasRoom = hasNoticeCapRoom(state, options);
+  if (!hasRoom) markNoticeCapacityReachedInProcess(noticeId);
+  return hasRoom;
+}
+function appendNoticeCapEvent(state, event, options = {}) {
+  var _a2, _b2, _c;
+  const now = (_a2 = options.now) != null ? _a2 : /* @__PURE__ */ new Date();
+  const limit = (_b2 = options.limit) != null ? _b2 : NOTICE_CAP_LIMIT;
+  const windowMs = (_c = options.windowMs) != null ? _c : NOTICE_CAP_WINDOW_MS;
+  const events = eventsInWindow(state.events, now, windowMs);
+  if (events.length >= limit) return null;
+  return {
+    ...state,
+    events: [
+      ...events,
+      {
+        evaluated_at: now.toISOString(),
+        ...event
+      }
+    ]
+  };
+}
+function recordNoticeOpportunity(noticeId, event, options = {}) {
+  if (!isTelemetryEnabled()) return false;
+  if (isNoticeCapacityReachedInProcess(noticeId)) return false;
+  const config = loadMem0Config();
+  const state = getNoticeState(config, noticeId);
+  const nextState = appendNoticeCapEvent(state, event, options);
+  if (!nextState) {
+    markNoticeCapacityReachedInProcess(noticeId);
+    return false;
+  }
+  const written = writeMem0ConfigAtomic(
+    setNoticeState(config, noticeId, nextState)
+  );
+  if (written && !hasNoticeCapRoom(nextState, options)) {
+    markNoticeCapacityReachedInProcess(noticeId);
+  }
+  return written;
+}
+function isFirstRunConsumed(config) {
+  return getNoticeState(config, FIRST_RUN_NOTICE_ID).consumed === true;
+}
+function markFirstRunConsumed(triggerFunction, variant) {
+  const config = loadMem0Config();
+  const state = getNoticeState(config, FIRST_RUN_NOTICE_ID);
+  const nextState = {
+    ...state,
+    consumed: true,
+    consumed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    trigger_function: triggerFunction,
+    variant
+  };
+  return writeMem0ConfigAtomic(
+    setNoticeState(config, FIRST_RUN_NOTICE_ID, nextState)
+  );
+}
+function getDisplayDecision(noticeId, expectedNoticeType, variant, payload) {
+  var _a2;
+  const parsed = getNoticeConfigFromPayload(payload, noticeId);
+  const copy = typeof ((_a2 = parsed.config) == null ? void 0 : _a2.copy) === "string" ? parsed.config.copy : void 0;
+  if (!parsed.found || !parsed.config) {
+    return {
+      displayed: false,
+      noticeConfigFound: false,
+      bypassReason: "missing_notice_config"
+    };
+  }
+  const noticeConfig = parsed.config;
+  if (noticeConfig.enabled === false) {
+    return {
+      displayed: false,
+      noticeConfigFound: true,
+      copy,
+      bypassReason: "payload_disabled",
+      disabledReason: "payload_disabled"
+    };
+  }
+  if (noticeConfig.notice_type !== expectedNoticeType) {
+    return {
+      displayed: false,
+      noticeConfigFound: true,
+      copy,
+      bypassReason: "invalid_notice_type"
+    };
+  }
+  if (!copy || copy.trim() === "") {
+    return {
+      displayed: false,
+      noticeConfigFound: true,
+      bypassReason: "missing_copy"
+    };
+  }
+  if (variant !== DISPLAYED_VARIANT) {
+    return {
+      displayed: false,
+      noticeConfigFound: true,
+      copy,
+      bypassReason: "holdout"
+    };
+  }
+  return {
+    displayed: true,
+    noticeConfigFound: true,
+    copy
+  };
+}
+function renderScaleCopy(template, trigger) {
+  var _a2, _b2, _c;
+  if (typeof template !== "string" || template.trim() === "") return void 0;
+  return template.replace(/\{top_k\}/g, String((_a2 = trigger.topK) != null ? _a2 : "")).replace(/\{topK\}/g, String((_b2 = trigger.topK) != null ? _b2 : "")).replace(/\{memory_count\}/g, String((_c = trigger.memoryCount) != null ? _c : ""));
+}
+function getScaleDisplayDecision(variant, payload, trigger) {
+  var _a2;
+  const parsed = getNoticeConfigFromPayload(payload, SCALE_THRESHOLD_NOTICE_ID);
+  const copies = ((_a2 = parsed.config) == null ? void 0 : _a2.copies) && typeof parsed.config.copies === "object" && !Array.isArray(parsed.config.copies) ? parsed.config.copies : {};
+  const copyKey = trigger.triggerSource === "memory_count" ? "memory_count" : "top_k";
+  const copy = renderScaleCopy(copies[copyKey], trigger);
+  if (!parsed.found || !parsed.config) {
+    return {
+      displayed: false,
+      noticeConfigFound: false,
+      bypassReason: "missing_notice_config"
+    };
+  }
+  const noticeConfig = parsed.config;
+  if (noticeConfig.enabled === false) {
+    return {
+      displayed: false,
+      noticeConfigFound: true,
+      copy,
+      bypassReason: "payload_disabled",
+      disabledReason: "payload_disabled"
+    };
+  }
+  if (noticeConfig.notice_type !== LOG_LINE_NOTICE_TYPE) {
+    return {
+      displayed: false,
+      noticeConfigFound: true,
+      copy,
+      bypassReason: "invalid_notice_type"
+    };
+  }
+  if (!copy || copy.trim() === "") {
+    return {
+      displayed: false,
+      noticeConfigFound: true,
+      bypassReason: "missing_copy"
+    };
+  }
+  if (variant !== DISPLAYED_VARIANT) {
+    return {
+      displayed: false,
+      noticeConfigFound: true,
+      copy,
+      bypassReason: "holdout"
+    };
+  }
+  return {
+    displayed: true,
+    noticeConfigFound: true,
+    copy
+  };
+}
+function getFeatureErrorDecision(noticeId, expectedNoticeType, variant, payload) {
+  var _a2;
+  const parsed = getNoticeConfigFromPayload(payload, noticeId);
+  const copy = typeof ((_a2 = parsed.config) == null ? void 0 : _a2.copy) === "string" ? parsed.config.copy : void 0;
+  if (!parsed.found || !parsed.config) {
+    return {
+      displayed: false,
+      noticeConfigFound: false,
+      bypassReason: "missing_notice_config"
+    };
+  }
+  const noticeConfig = parsed.config;
+  if (noticeConfig.enabled === false) {
+    return {
+      displayed: false,
+      noticeConfigFound: true,
+      copy,
+      bypassReason: "payload_disabled",
+      disabledReason: "payload_disabled"
+    };
+  }
+  if (noticeConfig.notice_type !== expectedNoticeType) {
+    return {
+      displayed: false,
+      noticeConfigFound: true,
+      copy,
+      bypassReason: "invalid_notice_type"
+    };
+  }
+  if (!copy || copy.trim() === "") {
+    return {
+      displayed: false,
+      noticeConfigFound: true,
+      bypassReason: "missing_copy"
+    };
+  }
+  if (variant !== DISPLAYED_VARIANT && variant !== HOLDOUT_VARIANT) {
+    return {
+      displayed: false,
+      noticeConfigFound: true,
+      copy,
+      bypassReason: "not_displayed"
+    };
+  }
+  return {
+    displayed: true,
+    noticeConfigFound: true,
+    copy
+  };
+}
+async function getDecayFeatureErrorMessage(instance) {
+  if (!isTelemetryEnabled()) return DECAY_FEATURE_PLAIN_ERROR;
+  try {
+    const flagEvaluation = await evaluateNoticeFlag(instance.telemetryId);
+    if (!flagEvaluation) return DECAY_FEATURE_PLAIN_ERROR;
+    const decision = getFeatureErrorDecision(
+      DECAY_FEATURE_NOTICE_ID,
+      ERROR_NOTICE_TYPE,
+      flagEvaluation.variant,
+      flagEvaluation.payload
+    );
+    await emitNoticeDisplayed(instance, {
+      notice_id: DECAY_FEATURE_NOTICE_ID,
+      notice_type: ERROR_NOTICE_TYPE,
+      flag_key: NOTICE_FLAG_KEY,
+      variant: flagEvaluation.variant,
+      displayed: decision.displayed,
+      payload: decision.copy,
+      bypass_reason: decision.bypassReason,
+      disabled_reason: decision.disabledReason,
+      notice_config_found: decision.noticeConfigFound,
+      sync_type: "async",
+      trigger_function: "update_project",
+      trigger_parameter: "decay"
+    });
+    if (decision.displayed && decision.copy) {
+      return decision.copy;
+    }
+  } catch (e) {
+  }
+  return DECAY_FEATURE_PLAIN_ERROR;
+}
+async function getTemporalFeatureErrorMessage(instance, trigger) {
+  const plainError = trigger.triggerParameter === "timestamp" ? TEMPORAL_TIMESTAMP_PLAIN_ERROR : TEMPORAL_REFERENCE_DATE_PLAIN_ERROR;
+  if (!isTelemetryEnabled()) return plainError;
+  try {
+    const flagEvaluation = await evaluateNoticeFlag(instance.telemetryId);
+    if (!flagEvaluation) return plainError;
+    const decision = getFeatureErrorDecision(
+      TEMPORAL_FEATURE_NOTICE_ID,
+      ERROR_NOTICE_TYPE,
+      flagEvaluation.variant,
+      flagEvaluation.payload
+    );
+    await emitNoticeDisplayed(instance, {
+      notice_id: TEMPORAL_FEATURE_NOTICE_ID,
+      notice_type: ERROR_NOTICE_TYPE,
+      flag_key: NOTICE_FLAG_KEY,
+      variant: flagEvaluation.variant,
+      displayed: decision.displayed,
+      payload: decision.copy,
+      bypass_reason: decision.bypassReason,
+      disabled_reason: decision.disabledReason,
+      notice_config_found: decision.noticeConfigFound,
+      sync_type: "async",
+      trigger_function: trigger.triggerFunction,
+      trigger_parameter: trigger.triggerParameter
+    });
+    if (decision.displayed && decision.copy) {
+      return decision.copy;
+    }
+  } catch (e) {
+  }
+  return plainError;
+}
+function getDecayUsageDeleteCountAfterSuccess() {
+  if (!isTelemetryEnabled()) return 0;
+  decayUsageSuccessfulDeleteCount += 1;
+  return decayUsageSuccessfulDeleteCount;
+}
+function isDecayUsageDeleteEligible(deleteCount) {
+  return deleteCount >= DECAY_USAGE_DELETE_THRESHOLD;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+}
+function isTemporalKey(key) {
+  const keyText = String(key).toLowerCase();
+  return [
+    "date",
+    "time",
+    "timestamp",
+    "datetime",
+    "event_date",
+    "reference_date",
+    "referencedate",
+    "created_at",
+    "createdat",
+    "updated_at",
+    "updatedat",
+    "started_at",
+    "startedat",
+    "ended_at",
+    "endedat",
+    "expires_at",
+    "expiresat"
+  ].includes(keyText) || keyText.endsWith("_date") || keyText.endsWith("_time") || keyText.endsWith("_at") || keyText.includes("timestamp");
+}
+function looksTemporalValue(value, allowEpoch) {
+  if (value instanceof Date) return !Number.isNaN(value.getTime());
+  if (typeof value === "string") {
+    return ISO_DATE_RE.test(value) || RELATIVE_TIME_RE.test(value);
+  }
+  if (allowEpoch && typeof value === "number" && Number.isFinite(value)) {
+    return value >= 946684800 && value <= 4102444800 || value >= 9466848e5 && value <= 41024448e5;
+  }
+  return false;
+}
+function detectTemporalUsageFromMetadata(metadata) {
+  try {
+    if (!isRecord(metadata)) return null;
+    const visited = /* @__PURE__ */ new WeakSet();
+    const stack = [{ value: metadata, depth: 0 }];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (current.depth > MAX_TEMPORAL_DETECTION_DEPTH) continue;
+      if (Array.isArray(current.value)) {
+        for (const child of current.value) {
+          if (looksTemporalValue(child, false)) {
+            return {
+              triggerSource: "metadata",
+              triggerReason: "date_like_metadata"
+            };
+          }
+          stack.push({
+            value: child,
+            parentKey: current.parentKey,
+            depth: current.depth + 1
+          });
+        }
+        continue;
+      }
+      if (!isRecord(current.value)) continue;
+      if (visited.has(current.value)) continue;
+      visited.add(current.value);
+      for (const [key, value] of Object.entries(current.value)) {
+        const temporalKey = isTemporalKey(key);
+        if (temporalKey && looksTemporalValue(value, true) || looksTemporalValue(value, false)) {
+          return {
+            triggerSource: "metadata",
+            triggerReason: "date_like_metadata"
+          };
+        }
+        if (isRecord(value) || Array.isArray(value)) {
+          stack.push({ value, parentKey: key, depth: current.depth + 1 });
+        }
+      }
+    }
+  } catch (e) {
+  }
+  return null;
+}
+function hasTemporalFilter(filters) {
+  try {
+    if (!isRecord(filters)) return false;
+    const visited = /* @__PURE__ */ new WeakSet();
+    const stack = [
+      { value: filters, depth: 0 }
+    ];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (current.depth > MAX_TEMPORAL_DETECTION_DEPTH) continue;
+      if (Array.isArray(current.value)) {
+        for (const child of current.value) {
+          stack.push({ value: child, depth: current.depth + 1 });
+        }
+        continue;
+      }
+      if (!isRecord(current.value)) continue;
+      if (visited.has(current.value)) continue;
+      visited.add(current.value);
+      for (const [key, value] of Object.entries(current.value)) {
+        if (["AND", "OR", "NOT", "$and", "$or", "$not"].includes(key)) {
+          if (isRecord(value) || Array.isArray(value)) {
+            stack.push({ value, depth: current.depth + 1 });
+          }
+          continue;
+        }
+        const temporalKey = isTemporalKey(key);
+        if (isRecord(value)) {
+          const rangeValues = Object.entries(value).filter(([operator]) => RANGE_OPERATORS.has(operator)).map(([, rangeValue]) => rangeValue);
+          if (rangeValues.length > 0 && (temporalKey || rangeValues.some(
+            (rangeValue) => looksTemporalValue(rangeValue, temporalKey)
+          ))) {
+            return true;
+          }
+          stack.push({ value, depth: current.depth + 1 });
+        } else if (temporalKey && looksTemporalValue(value, true)) {
+          return true;
+        }
+      }
+    }
+  } catch (e) {
+  }
+  return false;
+}
+function detectTemporalUsageFromSearch(query, filters) {
+  try {
+    if (typeof query === "string") {
+      if (RELATIVE_TIME_RE.test(query)) {
+        return { triggerSource: "query", triggerReason: "relative_phrase" };
+      }
+      if (ISO_DATE_RE.test(query)) {
+        return { triggerSource: "query", triggerReason: "date_like_query" };
+      }
+    }
+    if (hasTemporalFilter(filters)) {
+      return { triggerSource: "filter", triggerReason: "date_range_filter" };
+    }
+  } catch (e) {
+  }
+  return null;
+}
+function coerceNonnegativeInteger(value) {
+  if (typeof value === "boolean") return null;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed < 0) {
+    return null;
+  }
+  return parsed;
+}
+function countAddedMemories(addResult) {
+  const results = isRecord(addResult) && Array.isArray(addResult.results) ? addResult.results : addResult;
+  if (!Array.isArray(results)) return 0;
+  return results.filter((item) => {
+    if (!isRecord(item)) return false;
+    const metadata = item.metadata;
+    return isRecord(metadata) && metadata.event === "ADD";
+  }).length;
+}
+function extractProviderCount(info) {
+  if (!info) return null;
+  if (typeof info === "number") return coerceNonnegativeInteger(info);
+  if (isRecord(info)) {
+    for (const key of [
+      "count",
+      "points_count",
+      "vectors_count",
+      "indexed_vectors_count"
+    ]) {
+      const value = coerceNonnegativeInteger(info[key]);
+      if (value !== null) return value;
+    }
+    const result = extractProviderCount(info.result);
+    if (result !== null) return result;
+  }
+  return null;
+}
+async function getProviderMemoryCount(memoryInstance) {
+  try {
+    const vectorStore = memoryInstance == null ? void 0 : memoryInstance.vectorStore;
+    if (!vectorStore) return null;
+    if (typeof vectorStore.count === "function") {
+      const value = extractProviderCount(await vectorStore.count());
+      if (value !== null) return value;
+    }
+    const collectionName = vectorStore.collectionName;
+    const client = vectorStore.client;
+    if (client && collectionName && typeof client.count === "function") {
+      const value = extractProviderCount(
+        await client.count(collectionName, { exact: true })
+      );
+      if (value !== null) return value;
+    }
+    if (client && collectionName && typeof client.getCollection === "function") {
+      const value = extractProviderCount(
+        await client.getCollection(collectionName)
+      );
+      if (value !== null) return value;
+    }
+  } catch (e) {
+  }
+  return null;
+}
+function markScaleMemoryCountThresholdEvaluated() {
+  try {
+    const config = loadMem0Config();
+    const state = getNoticeState(config, SCALE_THRESHOLD_NOTICE_ID);
+    if (state.memory_count_threshold_evaluated === true) {
+      scaleMemoryCountThresholdEvaluatedInProcess = true;
+      return false;
+    }
+    const nextState = {
+      ...state,
+      memory_count_threshold_evaluated: true
+    };
+    const written = writeMem0ConfigAtomic(
+      setNoticeState(config, SCALE_THRESHOLD_NOTICE_ID, nextState)
+    );
+    if (written) scaleMemoryCountThresholdEvaluatedInProcess = true;
+    return written;
+  } catch (e) {
+    return false;
+  }
+}
+function detectScaleThresholdFromTopK(topK) {
+  const topKValue = coerceNonnegativeInteger(topK);
+  if (topKValue === null || topKValue < SCALE_TOP_K_THRESHOLD) return null;
+  return {
+    triggerSource: "top_k",
+    triggerReason: "high_top_k",
+    topK: topKValue,
+    threshold: SCALE_TOP_K_THRESHOLD
+  };
+}
+async function detectScaleThresholdFromAddResult(memoryInstance, addResult) {
+  if (!isTelemetryEnabled()) return null;
+  const addedCount = countAddedMemories(addResult);
+  if (addedCount === 0) return null;
+  try {
+    if (scaleMemoryCountThresholdEvaluatedInProcess) return null;
+    scaleMemoryCountAddsSinceCheck += addedCount;
+    const shouldCheck = !scaleMemoryCountCheckedInProcess || scaleMemoryCountAddsSinceCheck >= SCALE_MEMORY_COUNT_CHECK_INTERVAL;
+    if (!shouldCheck) return null;
+    scaleMemoryCountCheckedInProcess = true;
+    scaleMemoryCountAddsSinceCheck = 0;
+    const config = loadMem0Config();
+    const state = getNoticeState(config, SCALE_THRESHOLD_NOTICE_ID);
+    if (state.memory_count_threshold_evaluated === true) {
+      scaleMemoryCountThresholdEvaluatedInProcess = true;
+      return null;
+    }
+    if (!hasNoticeCapRoom(state)) return null;
+  } catch (e) {
+    return null;
+  }
+  const providerCount = await getProviderMemoryCount(memoryInstance);
+  if (providerCount === null || providerCount < SCALE_MEMORY_COUNT_THRESHOLD) {
+    return null;
+  }
+  if (!markScaleMemoryCountThresholdEvaluated()) return null;
+  return {
+    triggerSource: "memory_count",
+    triggerReason: "memory_count_threshold",
+    memoryCount: providerCount,
+    threshold: SCALE_MEMORY_COUNT_THRESHOLD
+  };
+}
+function detectPerformanceSlowQuery(elapsedMs, topK, resultCount) {
+  const elapsedMsValue = coerceNonnegativeInteger(
+    Math.round(Number(elapsedMs))
+  );
+  const topKValue = coerceNonnegativeInteger(topK);
+  const resultCountValue = coerceNonnegativeInteger(resultCount);
+  if (elapsedMsValue === null || topKValue === null || resultCountValue === null || elapsedMsValue <= PERFORMANCE_SLOW_QUERY_THRESHOLD_MS) {
+    return null;
+  }
+  return {
+    elapsedMs: elapsedMsValue,
+    thresholdMs: PERFORMANCE_SLOW_QUERY_THRESHOLD_MS,
+    topK: topKValue,
+    resultCount: resultCountValue
+  };
+}
+async function displayScaleThresholdNotice(instance, trigger) {
+  if (!isTelemetryEnabled()) return;
+  if (isNoticeCapacityReachedInProcess(SCALE_THRESHOLD_NOTICE_ID)) return;
+  try {
+    const config = loadMem0Config();
+    const state = getNoticeState(config, SCALE_THRESHOLD_NOTICE_ID);
+    if (!hasNoticeCapRoomForNotice(SCALE_THRESHOLD_NOTICE_ID, state)) return;
+    const flagEvaluation = await evaluateNoticeFlag(instance.telemetryId);
+    if (!flagEvaluation) return;
+    const decision = getScaleDisplayDecision(
+      flagEvaluation.variant,
+      flagEvaluation.payload,
+      trigger
+    );
+    const opportunity = {
+      variant: flagEvaluation.variant,
+      sync_type: "async",
+      trigger_function: trigger.triggerFunction,
+      trigger_source: trigger.triggerSource,
+      trigger_reason: trigger.triggerReason,
+      ...trigger.topK !== void 0 && { top_k: trigger.topK },
+      ...trigger.memoryCount !== void 0 && {
+        memory_count: trigger.memoryCount
+      },
+      threshold: trigger.threshold
+    };
+    if (!recordNoticeOpportunity(SCALE_THRESHOLD_NOTICE_ID, opportunity)) {
+      return;
+    }
+    await emitNoticeDisplayed(instance, {
+      notice_id: SCALE_THRESHOLD_NOTICE_ID,
+      notice_type: LOG_LINE_NOTICE_TYPE,
+      flag_key: NOTICE_FLAG_KEY,
+      variant: flagEvaluation.variant,
+      displayed: decision.displayed,
+      payload: decision.copy,
+      bypass_reason: decision.bypassReason,
+      disabled_reason: decision.disabledReason,
+      notice_config_found: decision.noticeConfigFound,
+      sync_type: "async",
+      trigger_function: trigger.triggerFunction,
+      trigger_source: trigger.triggerSource,
+      trigger_reason: trigger.triggerReason,
+      top_k: trigger.topK,
+      memory_count: trigger.memoryCount,
+      threshold: trigger.threshold
+    });
+    if (decision.displayed && decision.copy) {
+      process.stderr.write(`${decision.copy}
+`);
+    }
+  } catch (e) {
+  }
+}
+async function displayPerformanceSlowQueryNotice(instance, trigger) {
+  if (!isTelemetryEnabled()) return;
+  if (isNoticeCapacityReachedInProcess(PERFORMANCE_SLOW_QUERY_NOTICE_ID)) {
+    return;
+  }
+  try {
+    const config = loadMem0Config();
+    const state = getNoticeState(config, PERFORMANCE_SLOW_QUERY_NOTICE_ID);
+    if (!hasNoticeCapRoomForNotice(PERFORMANCE_SLOW_QUERY_NOTICE_ID, state)) {
+      return;
+    }
+    const flagEvaluation = await evaluateNoticeFlag(instance.telemetryId);
+    if (!flagEvaluation) return;
+    const decision = getDisplayDecision(
+      PERFORMANCE_SLOW_QUERY_NOTICE_ID,
+      LOG_LINE_NOTICE_TYPE,
+      flagEvaluation.variant,
+      flagEvaluation.payload
+    );
+    const opportunity = {
+      variant: flagEvaluation.variant,
+      sync_type: "async",
+      trigger_function: trigger.triggerFunction,
+      trigger_reason: trigger.triggerReason
+    };
+    if (!recordNoticeOpportunity(PERFORMANCE_SLOW_QUERY_NOTICE_ID, opportunity)) {
+      return;
+    }
+    await emitNoticeDisplayed(instance, {
+      notice_id: PERFORMANCE_SLOW_QUERY_NOTICE_ID,
+      notice_type: LOG_LINE_NOTICE_TYPE,
+      flag_key: NOTICE_FLAG_KEY,
+      variant: flagEvaluation.variant,
+      displayed: decision.displayed,
+      payload: decision.copy,
+      bypass_reason: decision.bypassReason,
+      disabled_reason: decision.disabledReason,
+      notice_config_found: decision.noticeConfigFound,
+      sync_type: "async",
+      trigger_function: trigger.triggerFunction,
+      trigger_reason: trigger.triggerReason,
+      elapsed_ms: trigger.elapsedMs,
+      threshold_ms: trigger.thresholdMs,
+      top_k: trigger.topK,
+      result_count: trigger.resultCount
+    });
+    if (decision.displayed && decision.copy) {
+      process.stderr.write(`${decision.copy}
+`);
+    }
+  } catch (e) {
+  }
+}
+async function displayTemporalUsageNotice(instance, trigger) {
+  if (!isTelemetryEnabled()) return;
+  if (isNoticeCapacityReachedInProcess(TEMPORAL_USAGE_NOTICE_ID)) return;
+  try {
+    const config = loadMem0Config();
+    const state = getNoticeState(config, TEMPORAL_USAGE_NOTICE_ID);
+    if (!hasNoticeCapRoomForNotice(TEMPORAL_USAGE_NOTICE_ID, state)) return;
+    const flagEvaluation = await evaluateNoticeFlag(instance.telemetryId);
+    if (!flagEvaluation) return;
+    const decision = getDisplayDecision(
+      TEMPORAL_USAGE_NOTICE_ID,
+      LOG_LINE_NOTICE_TYPE,
+      flagEvaluation.variant,
+      flagEvaluation.payload
+    );
+    const opportunity = {
+      variant: flagEvaluation.variant,
+      sync_type: "async",
+      trigger_function: trigger.triggerFunction,
+      trigger_source: trigger.triggerSource,
+      trigger_reason: trigger.triggerReason
+    };
+    if (!recordNoticeOpportunity(TEMPORAL_USAGE_NOTICE_ID, opportunity)) {
+      return;
+    }
+    await emitNoticeDisplayed(instance, {
+      notice_id: TEMPORAL_USAGE_NOTICE_ID,
+      notice_type: LOG_LINE_NOTICE_TYPE,
+      flag_key: NOTICE_FLAG_KEY,
+      variant: flagEvaluation.variant,
+      displayed: decision.displayed,
+      payload: decision.copy,
+      bypass_reason: decision.bypassReason,
+      disabled_reason: decision.disabledReason,
+      notice_config_found: decision.noticeConfigFound,
+      sync_type: "async",
+      trigger_function: trigger.triggerFunction,
+      trigger_source: trigger.triggerSource,
+      trigger_reason: trigger.triggerReason
+    });
+    if (decision.displayed && decision.copy) {
+      process.stderr.write(`${decision.copy}
+`);
+    }
+  } catch (e) {
+  }
+}
+async function displayDecayUsageNotice(instance, trigger) {
+  if (!isTelemetryEnabled()) return;
+  if (isNoticeCapacityReachedInProcess(DECAY_USAGE_NOTICE_ID)) return;
+  try {
+    const config = loadMem0Config();
+    const state = getNoticeState(config, DECAY_USAGE_NOTICE_ID);
+    if (!hasNoticeCapRoomForNotice(DECAY_USAGE_NOTICE_ID, state)) return;
+    const flagEvaluation = await evaluateNoticeFlag(instance.telemetryId);
+    if (!flagEvaluation) return;
+    const decision = getDisplayDecision(
+      DECAY_USAGE_NOTICE_ID,
+      LOG_LINE_NOTICE_TYPE,
+      flagEvaluation.variant,
+      flagEvaluation.payload
+    );
+    const opportunity = {
+      variant: flagEvaluation.variant,
+      sync_type: "async",
+      trigger_function: trigger.triggerFunction,
+      trigger_source: trigger.triggerSource,
+      trigger_reason: trigger.triggerReason,
+      ...trigger.deleteCount !== void 0 && {
+        delete_count: trigger.deleteCount
+      },
+      ...trigger.deletedCount !== void 0 && {
+        deleted_count: trigger.deletedCount
+      }
+    };
+    if (!recordNoticeOpportunity(DECAY_USAGE_NOTICE_ID, opportunity)) {
+      return;
+    }
+    await emitNoticeDisplayed(instance, {
+      notice_id: DECAY_USAGE_NOTICE_ID,
+      notice_type: LOG_LINE_NOTICE_TYPE,
+      flag_key: NOTICE_FLAG_KEY,
+      variant: flagEvaluation.variant,
+      displayed: decision.displayed,
+      payload: decision.copy,
+      bypass_reason: decision.bypassReason,
+      disabled_reason: decision.disabledReason,
+      notice_config_found: decision.noticeConfigFound,
+      sync_type: "async",
+      trigger_function: trigger.triggerFunction,
+      trigger_source: trigger.triggerSource,
+      trigger_reason: trigger.triggerReason,
+      ...trigger.deleteCount !== void 0 && {
+        delete_count: trigger.deleteCount
+      },
+      ...trigger.deletedCount !== void 0 && {
+        deleted_count: trigger.deletedCount
+      }
+    });
+    if (decision.displayed && decision.copy) {
+      process.stderr.write(`${decision.copy}
+`);
+    }
+  } catch (e) {
+  }
+}
+async function displayFirstRunNotice(instance, triggerFunction) {
+  if (!isTelemetryEnabled()) return;
+  if (firstRunConsumedInProcess || firstRunClaimInProgress) return;
+  const config = loadMem0Config();
+  if (isFirstRunConsumed(config)) {
+    firstRunConsumedInProcess = true;
+    return;
+  }
+  firstRunClaimInProgress = true;
+  try {
+    const flagEvaluation = await evaluateNoticeFlag(instance.telemetryId);
+    if (!flagEvaluation) {
+      firstRunClaimInProgress = false;
+      return;
+    }
+    const decision = getDisplayDecision(
+      FIRST_RUN_NOTICE_ID,
+      LOG_LINE_NOTICE_TYPE,
+      flagEvaluation.variant,
+      flagEvaluation.payload
+    );
+    firstRunConsumedInProcess = true;
+    markFirstRunConsumed(triggerFunction, flagEvaluation.variant);
+    await emitNoticeDisplayed(instance, {
+      notice_id: FIRST_RUN_NOTICE_ID,
+      notice_type: LOG_LINE_NOTICE_TYPE,
+      flag_key: NOTICE_FLAG_KEY,
+      variant: flagEvaluation.variant,
+      displayed: decision.displayed,
+      payload: decision.copy,
+      bypass_reason: decision.bypassReason,
+      disabled_reason: decision.disabledReason,
+      notice_config_found: decision.noticeConfigFound,
+      sync_type: "async",
+      trigger_function: triggerFunction
+    });
+    if (decision.displayed && decision.copy) {
+      process.stderr.write(`${decision.copy}
+`);
+    }
+  } catch (e) {
+    if (!firstRunConsumedInProcess) firstRunClaimInProgress = false;
+  } finally {
+    if (firstRunConsumedInProcess) firstRunClaimInProgress = false;
+  }
+}
+async function emitNoticeDisplayed(instance, properties) {
+  if (!isTelemetryEnabled()) return;
+  try {
+    await captureNoticeEvent(instance, properties);
+  } catch (e) {
+  }
+}
 
 // src/oss/src/utils/lemmatization.ts
 var STOP_WORDS = /* @__PURE__ */ new Set([
@@ -5860,7 +6902,7 @@ function extractCompoundsRegex(text) {
   return entities;
 }
 function extractEntities(text) {
-  var _a2, _b;
+  var _a2, _b2;
   const raw = [];
   raw.push(...extractQuoted(text));
   raw.push(...extractProper(text));
@@ -5903,7 +6945,7 @@ function extractEntities(text) {
   for (const entity of cleaned) {
     const key = entity.text.toLowerCase();
     const existing = best.get(key);
-    if (!existing || ((_a2 = typePriority[entity.type]) != null ? _a2 : 99) < ((_b = typePriority[existing.type]) != null ? _b : 99)) {
+    if (!existing || ((_a2 = typePriority[entity.type]) != null ? _a2 : 99) < ((_b2 = typePriority[existing.type]) != null ? _b2 : 99)) {
       best.set(key, entity);
     }
   }
@@ -5939,8 +6981,8 @@ function getBm25Params(query, lemmatized) {
 function normalizeBm25(rawScore, midpoint, steepness) {
   return 1 / (1 + Math.exp(-steepness * (rawScore - midpoint)));
 }
-function scoreAndRank(semanticResults, bm25Scores, entityBoosts, threshold, topK) {
-  var _a2, _b, _c;
+function scoreAndRank(semanticResults, bm25Scores, entityBoosts, threshold, topK, explain = false) {
+  var _a2, _b2, _c;
   const hasBm25 = Object.keys(bm25Scores).length > 0;
   const hasEntity = Object.keys(entityBoosts).length > 0;
   let maxPossible = 1;
@@ -5961,15 +7003,27 @@ function scoreAndRank(semanticResults, bm25Scores, entityBoosts, threshold, topK
       continue;
     }
     const memIdStr = String(memId);
-    const bm25Score = (_b = bm25Scores[memIdStr]) != null ? _b : 0;
+    const bm25Score = (_b2 = bm25Scores[memIdStr]) != null ? _b2 : 0;
     const entityBoost = (_c = entityBoosts[memIdStr]) != null ? _c : 0;
     const rawCombined = semanticScore + bm25Score + entityBoost;
     const combined = Math.min(rawCombined / maxPossible, 1);
-    scored.push({
+    const entry = {
       id: memIdStr,
       score: combined,
       payload: result.payload
-    });
+    };
+    if (explain) {
+      entry.scoreDetails = {
+        semanticScore,
+        bm25Score,
+        entityBoost,
+        rawScore: rawCombined,
+        maxPossibleScore: maxPossible,
+        finalScore: combined,
+        threshold
+      };
+    }
+    scored.push(entry);
   }
   scored.sort((a, b) => b.score - a.score);
   return scored.slice(0, topK);
@@ -5977,18 +7031,18 @@ function scoreAndRank(semanticResults, bm25Scores, entityBoosts, threshold, topK
 
 // src/client/config.ts
 async function getNodeFs() {
-  var _a2, _b, _c, _d, _e;
+  var _a2, _b2, _c, _d, _e;
   if (typeof process === "undefined" || !((_a2 = process.versions) == null ? void 0 : _a2.node)) return null;
   try {
-    const [fs4, path3, os2, crypto] = await Promise.all([
+    const [fs5, path4, os3, crypto] = await Promise.all([
       import("fs"),
       import("path"),
       import("os"),
       import("crypto")
     ]);
-    const fsMod = (_b = fs4.default) != null ? _b : fs4;
-    const pathMod = (_c = path3.default) != null ? _c : path3;
-    const osMod = (_d = os2.default) != null ? _d : os2;
+    const fsMod = (_b2 = fs5.default) != null ? _b2 : fs5;
+    const pathMod = (_c = path4.default) != null ? _c : path4;
+    const osMod = (_d = os3.default) != null ? _d : os3;
     const cryptoMod = (_e = crypto.default) != null ? _e : crypto;
     const dir = process.env.MEM0_DIR || pathMod.join(osMod.homedir(), ".mem0");
     return {
@@ -6368,6 +7422,52 @@ var Memory = class _Memory {
       console.error(`Failed to capture ${methodName} event:`, error);
     }
   }
+  async _displayFirstRunNotice(triggerFunction) {
+    try {
+      await this._getTelemetryId();
+      await displayFirstRunNotice(this, triggerFunction);
+    } catch (e) {
+    }
+  }
+  async _displayDecayUsageNotice(trigger) {
+    try {
+      await this._getTelemetryId();
+      await displayDecayUsageNotice(this, trigger);
+    } catch (e) {
+    }
+  }
+  async _displayTemporalUsageNotice(trigger) {
+    try {
+      await this._getTelemetryId();
+      await displayTemporalUsageNotice(this, trigger);
+    } catch (e) {
+    }
+  }
+  async _displayScaleThresholdNotice(trigger) {
+    try {
+      await this._getTelemetryId();
+      await displayScaleThresholdNotice(this, trigger);
+    } catch (e) {
+    }
+  }
+  async _displayPerformanceSlowQueryNotice(trigger) {
+    try {
+      await this._getTelemetryId();
+      await displayPerformanceSlowQueryNotice(this, trigger);
+    } catch (e) {
+    }
+  }
+  async _getNoticeTelemetryId() {
+    try {
+      if (!this.telemetryId || this.telemetryId === "anonymous" || this.telemetryId === "anonymous-supabase") {
+        this.telemetryId = await getOrCreateMem0UserId() || "anonymous";
+      }
+      return this.telemetryId;
+    } catch (e) {
+      this.telemetryId = "anonymous";
+      return this.telemetryId;
+    }
+  }
   static fromConfig(configDict) {
     try {
       const config = MemoryConfigSchema.parse(configDict);
@@ -6377,12 +7477,31 @@ var Memory = class _Memory {
       throw e;
     }
   }
+  async updateProject(options = {}) {
+    if ((options == null ? void 0 : options.decay) === true) {
+      await this._getNoticeTelemetryId();
+      throw new Error(await getDecayFeatureErrorMessage(this));
+    }
+    throw new Error("Project updates are not supported by the OSS Memory SDK.");
+  }
   async add(messages, config) {
+    if ((config == null ? void 0 : config.timestamp) !== void 0) {
+      await this._getNoticeTelemetryId();
+      throw new Error(
+        await getTemporalFeatureErrorMessage(this, {
+          triggerFunction: "add",
+          triggerParameter: "timestamp"
+        })
+      );
+    }
     if (messages === void 0 || messages === null) {
       throw new Error(
         "messages is required and cannot be undefined or null. Provide a string or array of messages."
       );
     }
+    const temporalUsageNotice = detectTemporalUsageFromMetadata(
+      config == null ? void 0 : config.metadata
+    );
     await this._ensureInitialized();
     await this._captureEvent("add", {
       message_count: Array.isArray(messages) ? messages.length : 1,
@@ -6410,12 +7529,32 @@ var Memory = class _Memory {
       filters,
       infer
     );
+    if (temporalUsageNotice) {
+      await this._displayTemporalUsageNotice({
+        triggerFunction: "add",
+        triggerSource: temporalUsageNotice.triggerSource,
+        triggerReason: temporalUsageNotice.triggerReason
+      });
+    } else {
+      const scaleThresholdNotice = await detectScaleThresholdFromAddResult(
+        this,
+        vectorStoreResult
+      );
+      if (scaleThresholdNotice) {
+        await this._displayScaleThresholdNotice({
+          triggerFunction: "add",
+          ...scaleThresholdNotice
+        });
+      } else {
+        await this._displayFirstRunNotice("add");
+      }
+    }
     return {
       results: vectorStoreResult
     };
   }
   async addToVectorStore(messages, metadata, filters, infer) {
-    var _a2, _b, _c, _d, _e, _f, _g;
+    var _a2, _b2, _c, _d, _e, _f, _g;
     if (!infer) {
       const returnedMemories = [];
       for (const message of messages) {
@@ -6457,7 +7596,7 @@ var Memory = class _Memory {
       uuidMapping[String(idx)] = mem.id;
       existingMemories.push({
         id: String(idx),
-        text: (_b = (_a2 = mem.payload) == null ? void 0 : _a2.data) != null ? _b : ""
+        text: (_b2 = (_a2 = mem.payload) == null ? void 0 : _a2.data) != null ? _b2 : ""
       });
     }
     const isAgentScoped = !!filters.agent_id && !filters.user_id;
@@ -6769,7 +7908,10 @@ var Memory = class _Memory {
   async get(memoryId) {
     await this._ensureInitialized();
     const memory = await this.vectorStore.get(memoryId);
-    if (!memory) return null;
+    if (!memory) {
+      await this._displayFirstRunNotice("get");
+      return null;
+    }
     const filters = {
       ...memory.payload.user_id && { user_id: memory.payload.user_id },
       ...memory.payload.agent_id && { agent_id: memory.payload.agent_id },
@@ -6799,10 +7941,25 @@ var Memory = class _Memory {
         memoryItem.metadata[key] = value;
       }
     }
-    return { ...memoryItem, ...filters };
+    const result = { ...memoryItem, ...filters };
+    await this._displayFirstRunNotice("get");
+    return result;
   }
   async search(query, config) {
-    var _a2, _b, _c, _d, _e;
+    var _a2, _b2, _c, _d, _e;
+    if ((config == null ? void 0 : config.referenceDate) !== void 0) {
+      await this._getNoticeTelemetryId();
+      throw new Error(
+        await getTemporalFeatureErrorMessage(this, {
+          triggerFunction: "search",
+          triggerParameter: "referenceDate"
+        })
+      );
+    }
+    const temporalUsageNotice = detectTemporalUsageFromSearch(
+      query,
+      config == null ? void 0 : config.filters
+    );
     rejectTopLevelEntityParams(config, "search");
     validateSearchParams(config.threshold, config.topK);
     const normalizedFilters = config.filters ? Object.fromEntries(
@@ -6817,7 +7974,7 @@ var Memory = class _Memory {
       }).filter(([, v]) => v !== void 0)
     ) : {};
     await this._ensureInitialized();
-    const { topK = 20, threshold = 0.1 } = config;
+    const { topK = 20, threshold = 0.1, explain = false } = config;
     await this._captureEvent("search", {
       query_length: query.length,
       topK,
@@ -6841,6 +7998,7 @@ var Memory = class _Memory {
         "filters must contain at least one of: user_id, agent_id, run_id. Example: filters: { user_id: 'u1' }"
       );
     }
+    const searchStartMs = Date.now();
     const queryLemmatized = lemmatizeForBm25(query);
     const queryEntities = extractEntities(query);
     const queryEmbedding = await this.embedder.embed(query);
@@ -6867,7 +8025,7 @@ var Memory = class _Memory {
       const [midpoint, steepness] = getBm25Params(query, queryLemmatized);
       for (const mem of keywordResults) {
         const memId = String(mem.id);
-        const rawScore = (_b = mem.score) != null ? _b : 0;
+        const rawScore = (_b2 = mem.score) != null ? _b2 : 0;
         if (rawScore > 0) {
           bm25Scores[memId] = normalizeBm25(rawScore, midpoint, steepness);
         }
@@ -6887,15 +8045,32 @@ var Memory = class _Memory {
         }
         if (deduped.length > 0) {
           const entityStore = await this.getEntityStore();
-          for (const entity of deduped) {
-            try {
-              const entityEmbedding = await this.embedder.embed(entity.text);
-              const matches = await entityStore.search(
-                entityEmbedding,
-                500,
-                effectiveFilters
-              );
-              for (const match of matches) {
+          const entitySearchFilters = {};
+          for (const k of ["user_id", "agent_id", "run_id"]) {
+            if (effectiveFilters[k])
+              entitySearchFilters[k] = effectiveFilters[k];
+          }
+          const entityTexts = deduped.map((e) => e.text);
+          const embeddings = await this.embedder.embedBatch(entityTexts);
+          if (embeddings.length !== entityTexts.length) {
+            console.warn(
+              `embedBatch returned ${embeddings.length} vectors for ${entityTexts.length} texts \u2014 skipping entity boost`
+            );
+          } else {
+            const searchResults = await Promise.allSettled(
+              deduped.map(
+                (_, i) => entityStore.search(embeddings[i], 500, entitySearchFilters)
+              )
+            );
+            for (const result2 of searchResults) {
+              if (result2.status === "rejected") {
+                console.warn(
+                  "Entity boost search failed for one entity:",
+                  result2.reason
+                );
+                continue;
+              }
+              for (const match of result2.value) {
                 const similarity = (_c = match.score) != null ? _c : 0;
                 if (similarity < 0.5) continue;
                 const payload = match.payload || {};
@@ -6914,7 +8089,6 @@ var Memory = class _Memory {
                   }
                 }
               }
-            } catch (e) {
             }
           }
         }
@@ -6935,7 +8109,8 @@ var Memory = class _Memory {
       bm25Scores,
       entityBoosts,
       threshold != null ? threshold : 0.1,
-      topK
+      topK,
+      explain
     );
     const excludedKeys = /* @__PURE__ */ new Set([
       "user_id",
@@ -6963,25 +8138,72 @@ var Memory = class _Memory {
         metadata: Object.entries(payload).filter(([key]) => !excludedKeys.has(key)).reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {}),
         ...payload.user_id && { user_id: payload.user_id },
         ...payload.agent_id && { agent_id: payload.agent_id },
-        ...payload.run_id && { run_id: payload.run_id }
+        ...payload.run_id && { run_id: payload.run_id },
+        ...scored.scoreDetails && { score_details: scored.scoreDetails }
       };
     });
-    return {
+    const result = {
       results
     };
+    const searchElapsedMs = Date.now() - searchStartMs;
+    if (temporalUsageNotice) {
+      await this._displayTemporalUsageNotice({
+        triggerFunction: "search",
+        triggerSource: temporalUsageNotice.triggerSource,
+        triggerReason: temporalUsageNotice.triggerReason
+      });
+    } else {
+      const scaleThresholdNotice = detectScaleThresholdFromTopK(topK);
+      if (scaleThresholdNotice) {
+        await this._displayScaleThresholdNotice({
+          triggerFunction: "search",
+          ...scaleThresholdNotice
+        });
+      } else {
+        const performanceSlowQueryNotice = detectPerformanceSlowQuery(
+          searchElapsedMs,
+          topK,
+          results.length
+        );
+        if (performanceSlowQueryNotice) {
+          await this._displayPerformanceSlowQueryNotice({
+            triggerFunction: "search",
+            triggerReason: "slow_query",
+            ...performanceSlowQueryNotice
+          });
+        } else {
+          await this._displayFirstRunNotice("search");
+        }
+      }
+    }
+    return result;
   }
   async update(memoryId, data) {
     await this._ensureInitialized();
     await this._captureEvent("update", { memory_id: memoryId });
     const embedding = await this.embedder.embed(data);
     await this.updateMemory(memoryId, data, { [data]: embedding });
-    return { message: "Memory updated successfully!" };
+    const result = { message: "Memory updated successfully!" };
+    await this._displayFirstRunNotice("update");
+    return result;
   }
   async delete(memoryId) {
     await this._ensureInitialized();
     await this._captureEvent("delete", { memory_id: memoryId });
     await this.deleteMemory(memoryId);
-    return { message: "Memory deleted successfully!" };
+    const result = { message: "Memory deleted successfully!" };
+    const deleteCount = getDecayUsageDeleteCountAfterSuccess();
+    if (isDecayUsageDeleteEligible(deleteCount)) {
+      await this._displayDecayUsageNotice({
+        triggerFunction: "delete",
+        triggerSource: "delete_count",
+        triggerReason: "repeated_deletes",
+        deleteCount
+      });
+    } else {
+      await this._displayFirstRunNotice("delete");
+    }
+    return result;
   }
   async deleteAll(config) {
     await this._ensureInitialized();
@@ -7004,11 +8226,24 @@ var Memory = class _Memory {
     for (const memory of memories) {
       await this.deleteMemory(memory.id);
     }
-    return { message: "Memories deleted successfully!" };
+    const result = { message: "Memories deleted successfully!" };
+    if (memories.length > 0) {
+      await this._displayDecayUsageNotice({
+        triggerFunction: "delete_all",
+        triggerSource: "delete_all",
+        triggerReason: "bulk_delete",
+        deletedCount: memories.length
+      });
+    } else {
+      await this._displayFirstRunNotice("delete_all");
+    }
+    return result;
   }
   async history(memoryId) {
     await this._ensureInitialized();
-    return this.db.getHistory(memoryId);
+    const result = await this.db.getHistory(memoryId);
+    await this._displayFirstRunNotice("history");
+    return result;
   }
   async reset() {
     await this._ensureInitialized();
@@ -7049,9 +8284,10 @@ var Memory = class _Memory {
       console.error(this._initError);
     });
     await this._initPromise;
+    await this._displayFirstRunNotice("reset");
   }
   async getAll(config) {
-    var _a2, _b, _c;
+    var _a2, _b2, _c;
     rejectTopLevelEntityParams(config, "getAll");
     validateSearchParams(void 0, config.topK);
     await this._ensureInitialized();
@@ -7060,7 +8296,7 @@ var Memory = class _Memory {
       Object.entries({
         ...config.filters || {},
         user_id: validateAndTrimEntityId((_a2 = config.filters) == null ? void 0 : _a2.user_id, "user_id"),
-        agent_id: validateAndTrimEntityId((_b = config.filters) == null ? void 0 : _b.agent_id, "agent_id"),
+        agent_id: validateAndTrimEntityId((_b2 = config.filters) == null ? void 0 : _b2.agent_id, "agent_id"),
         run_id: validateAndTrimEntityId((_c = config.filters) == null ? void 0 : _c.run_id, "run_id")
       }).filter(([, v]) => v !== void 0)
     );
@@ -7098,7 +8334,17 @@ var Memory = class _Memory {
       ...mem.payload.agent_id && { agent_id: mem.payload.agent_id },
       ...mem.payload.run_id && { run_id: mem.payload.run_id }
     }));
-    return { results };
+    const result = { results };
+    const scaleThresholdNotice = detectScaleThresholdFromTopK(topK);
+    if (scaleThresholdNotice) {
+      await this._displayScaleThresholdNotice({
+        triggerFunction: "get_all",
+        ...scaleThresholdNotice
+      });
+    } else {
+      await this._displayFirstRunNotice("get_all");
+    }
+    return result;
   }
   async createMemory(data, existingEmbeddings, metadata) {
     const memoryId = uuidv43();