@mastra/server 1.23.0-alpha.7 → 1.23.0-alpha.8

package/dist/{chunk-VMA5TY4H.cjs → chunk-2KF7EWOT.cjs}

@@ -3,7 +3,7 @@
 var chunk5N66PU3H_cjs = require('./chunk-5N66PU3H.cjs');
 var chunkEXKS4QPI_cjs = require('./chunk-EXKS4QPI.cjs');
 var chunkFPURK3UW_cjs = require('./chunk-FPURK3UW.cjs');
-var chunkPNCR2M6Y_cjs = require('./chunk-PNCR2M6Y.cjs');
+var chunkUHWF2UKO_cjs = require('./chunk-UHWF2UKO.cjs');
 var chunkR2ODPDKE_cjs = require('./chunk-R2ODPDKE.cjs');
 var chunkQKYHAQLX_cjs = require('./chunk-QKYHAQLX.cjs');
 var chunkDOHUOYZS_cjs = require('./chunk-DOHUOYZS.cjs');
@@ -22,6 +22,7 @@ var zod = require('zod');
 var z4 = require('zod/v4');
 var features = require('@mastra/core/features');
 var memory = require('@mastra/core/memory');
+var observability = require('@mastra/core/observability');
 var utils = require('@mastra/core/utils');
 var tools = require('@mastra/core/tools');
 var schema = require('@mastra/core/schema');
@@ -16392,8 +16393,8 @@ function formatTimestamp(date) {
   return date.toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "Z");
 }
 function truncateByTokens(text42, maxTokens, hint) {
-  if (chunkPNCR2M6Y_cjs.estimateTokenCount(text42) <= maxTokens) return { text: text42, wasTruncated: false };
-  const truncated = chunkPNCR2M6Y_cjs.truncateStringByTokens(text42, maxTokens);
+  if (chunkUHWF2UKO_cjs.estimateTokenCount(text42) <= maxTokens) return { text: text42, wasTruncated: false };
+  const truncated = chunkUHWF2UKO_cjs.truncateStringByTokens(text42, maxTokens);
   const suffix = hint ? ` [${hint} for more]` : "";
   return { text: truncated + suffix, wasTruncated: true };
 }
@@ -16426,11 +16427,11 @@ function formatMessageParts(msg, detail) {
       } else if (partType === "tool-invocation") {
         const inv = part.toolInvocation;
         if (inv.state === "result") {
-          const { value: resultValue } = chunkPNCR2M6Y_cjs.resolveToolResultValue(
+          const { value: resultValue } = chunkUHWF2UKO_cjs.resolveToolResultValue(
             part,
             inv.result
           );
-          const resultStr = chunkPNCR2M6Y_cjs.formatToolResultForObserver(resultValue, { maxTokens: HIGH_DETAIL_TOOL_RESULT_TOKENS });
+          const resultStr = chunkUHWF2UKO_cjs.formatToolResultForObserver(resultValue, { maxTokens: HIGH_DETAIL_TOOL_RESULT_TOKENS });
           const fullText = `[Tool Result: ${inv.toolName}]
 ${resultStr}`;
           parts.push(makePart(msg, i, "tool-result", fullText, detail));
@@ -16513,9 +16514,9 @@ function expandPriority(part) {
 }
 function renderFormattedParts(parts, timestamps, options) {
   const text42 = buildRenderedText(parts, timestamps);
-  let totalTokens = chunkPNCR2M6Y_cjs.estimateTokenCount(text42);
+  let totalTokens = chunkUHWF2UKO_cjs.estimateTokenCount(text42);
   if (totalTokens > options.maxTokens) {
-    const truncated = chunkPNCR2M6Y_cjs.truncateStringByTokens(text42, options.maxTokens);
+    const truncated = chunkUHWF2UKO_cjs.truncateStringByTokens(text42, options.maxTokens);
     return { text: truncated, truncated: true, tokenOffset: totalTokens - options.maxTokens };
   }
   const truncatedIndices = parts.map((p, i) => ({ part: p, index: i })).filter(({ part }) => part.text !== part.fullText).sort((a, b) => expandPriority(a.part) - expandPriority(b.part));
@@ -16526,8 +16527,8 @@ function renderFormattedParts(parts, timestamps, options) {
   for (const { part, index } of truncatedIndices) {
     if (remaining <= 0) break;
     const maxTokens = expandLimit(part);
-    const fullTokens = chunkPNCR2M6Y_cjs.estimateTokenCount(part.fullText);
-    const currentTokens = chunkPNCR2M6Y_cjs.estimateTokenCount(part.text);
+    const fullTokens = chunkUHWF2UKO_cjs.estimateTokenCount(part.fullText);
+    const currentTokens = chunkUHWF2UKO_cjs.estimateTokenCount(part.text);
     const targetTokens = Math.min(fullTokens, maxTokens);
     const delta = targetTokens - currentTokens;
     if (delta <= 0) continue;
@@ -16538,17 +16539,17 @@ function renderFormattedParts(parts, timestamps, options) {
       const expandedLimit = Math.min(currentTokens + remaining, maxTokens);
       const hint = `recall cursor="${part.messageId}" partIndex=${part.partIndex} detail="high"`;
       const { text: expanded2 } = truncateByTokens(part.fullText, expandedLimit, hint);
-      const expandedDelta = chunkPNCR2M6Y_cjs.estimateTokenCount(expanded2) - currentTokens;
+      const expandedDelta = chunkUHWF2UKO_cjs.estimateTokenCount(expanded2) - currentTokens;
       parts[index] = { ...part, text: expanded2 };
       remaining -= expandedDelta;
     }
   }
   const expanded = buildRenderedText(parts, timestamps);
-  const expandedTokens = chunkPNCR2M6Y_cjs.estimateTokenCount(expanded);
+  const expandedTokens = chunkUHWF2UKO_cjs.estimateTokenCount(expanded);
   if (expandedTokens <= options.maxTokens) {
     return { text: expanded, truncated: false, tokenOffset: 0 };
   }
-  const hardTruncated = chunkPNCR2M6Y_cjs.truncateStringByTokens(expanded, options.maxTokens);
+  const hardTruncated = chunkUHWF2UKO_cjs.truncateStringByTokens(expanded, options.maxTokens);
   return { text: hardTruncated, truncated: true, tokenOffset: expandedTokens - options.maxTokens };
 }
 async function recallPart({
@@ -16599,7 +16600,7 @@ async function recallPart({
 
 `;
           const fallbackText = `${fallbackNote}${firstNextPart.text}`;
-          const truncatedText2 = chunkPNCR2M6Y_cjs.truncateStringByTokens(fallbackText, maxTokens);
+          const truncatedText2 = chunkUHWF2UKO_cjs.truncateStringByTokens(fallbackText, maxTokens);
           const wasTruncated2 = truncatedText2 !== fallbackText;
           return {
             text: truncatedText2,
@@ -16614,7 +16615,7 @@ async function recallPart({
     }
     throw new Error(`Part index ${partIndex} not found in message ${cursor}. Available indices: ${availableIndices}`);
   }
-  const truncatedText = chunkPNCR2M6Y_cjs.truncateStringByTokens(target.text, maxTokens);
+  const truncatedText = chunkUHWF2UKO_cjs.truncateStringByTokens(target.text, maxTokens);
   const wasTruncated = truncatedText !== target.text;
   return {
     text: truncatedText,
@@ -17313,94 +17314,149 @@ var Memory = class extends memory.MastraMemory {
       );
     }
   }
+  createMemorySpan(operationType, observabilityContext, input, attributes) {
+    const currentSpan = observabilityContext?.tracingContext?.currentSpan;
+    if (!currentSpan) return void 0;
+    return currentSpan.createChildSpan({
+      type: observability.SpanType.MEMORY_OPERATION,
+      name: `memory: ${operationType}`,
+      entityType: observability.EntityType.MEMORY,
+      entityName: "Memory",
+      input,
+      attributes: { operationType, ...attributes }
+    });
+  }
   async recall(args) {
-    const { threadId, resourceId, perPage: perPageArg, page, orderBy, threadConfig, vectorSearchString, filter: filter32 } = args;
-    const config = this.getMergedThreadConfig(threadConfig || {});
-    if (resourceId) await this.validateThreadIsOwnedByResource(threadId, resourceId, config);
-    const perPage = perPageArg !== void 0 ? perPageArg : config.lastMessages;
-    const historyDisabledByConfig = config.lastMessages === false && perPageArg === void 0;
-    const shouldGetNewestAndReverse = !orderBy && perPage !== false;
-    const effectiveOrderBy = shouldGetNewestAndReverse ? { field: "createdAt", direction: "DESC" } : orderBy;
-    const vectorResults = [];
-    this.logger.debug("Memory recall", {
+    const {
       threadId,
-      perPage,
+      resourceId,
+      perPage: perPageArg,
       page,
-      orderBy: effectiveOrderBy,
-      hasWorkingMemorySchema: Boolean(config.workingMemory?.schema),
-      workingMemoryEnabled: config.workingMemory?.enabled,
-      semanticRecallEnabled: Boolean(config.semanticRecall),
-      historyDisabledByConfig
-    });
-    const defaultRange = DEFAULT_MESSAGE_RANGE;
-    const defaultTopK = DEFAULT_TOP_K;
-    const vectorConfig = typeof config?.semanticRecall === `boolean` ? {
-      topK: defaultTopK,
-      messageRange: defaultRange
-    } : {
-      topK: config?.semanticRecall?.topK ?? defaultTopK,
-      messageRange: config?.semanticRecall?.messageRange ?? defaultRange
-    };
-    const resourceScope = typeof config?.semanticRecall === "object" && config?.semanticRecall?.scope !== `thread` || config.semanticRecall === true;
-    if (resourceScope && !resourceId && config?.semanticRecall && vectorSearchString) {
-      throw new Error(
-        `Memory error: Resource-scoped semantic recall is enabled but no resourceId was provided. Either provide a resourceId or explicitly set semanticRecall.scope to 'thread'.`
-      );
-    }
-    let usage;
-    if (historyDisabledByConfig && (!config.semanticRecall || !vectorSearchString || !this.vector)) {
-      return { messages: [], usage: void 0, total: 0, page: page ?? 0, perPage: 0, hasMore: false };
-    }
-    if (config?.semanticRecall && vectorSearchString && this.vector) {
-      const result = await this.embedMessageContent(vectorSearchString);
-      usage = result.usage;
-      const { embeddings, dimension } = result;
-      const { indexName } = await this.createEmbeddingIndex(dimension, config);
-      await Promise.all(
-        embeddings.map(async (embedding) => {
-          if (typeof this.vector === `undefined`) {
-            throw new Error(
-              `Tried to query vector index ${indexName} but this Memory instance doesn't have an attached vector db.`
+      orderBy,
+      threadConfig,
+      vectorSearchString,
+      includeSystemReminders,
+      filter: filter32
+    } = args;
+    const config = this.getMergedThreadConfig(threadConfig || {});
+    const semanticRecallEnabled = Boolean(config.semanticRecall);
+    const span = this.createMemorySpan(
+      "recall",
+      args.observabilityContext,
+      { threadId, resourceId, vectorSearchString },
+      {
+        semanticRecallEnabled,
+        lastMessages: config.lastMessages
+      }
+    );
+    try {
+      if (resourceId) await this.validateThreadIsOwnedByResource(threadId, resourceId, config);
+      const perPage = perPageArg !== void 0 ? perPageArg : config.lastMessages;
+      const historyDisabledByConfig = config.lastMessages === false && perPageArg === void 0;
+      const shouldGetNewestAndReverse = !orderBy && perPage !== false;
+      const effectiveOrderBy = shouldGetNewestAndReverse ? { field: "createdAt", direction: "DESC" } : orderBy;
+      const vectorResults = [];
+      this.logger.debug("Memory recall", {
+        threadId,
+        perPage,
+        page,
+        orderBy: effectiveOrderBy,
+        hasWorkingMemorySchema: Boolean(config.workingMemory?.schema),
+        workingMemoryEnabled: config.workingMemory?.enabled,
+        semanticRecallEnabled,
+        historyDisabledByConfig
+      });
+      const defaultRange = DEFAULT_MESSAGE_RANGE;
+      const defaultTopK = DEFAULT_TOP_K;
+      const vectorConfig = typeof config?.semanticRecall === `boolean` ? {
+        topK: defaultTopK,
+        messageRange: defaultRange
+      } : {
+        topK: config?.semanticRecall?.topK ?? defaultTopK,
+        messageRange: config?.semanticRecall?.messageRange ?? defaultRange
+      };
+      const resourceScope = typeof config?.semanticRecall === "object" && config?.semanticRecall?.scope !== `thread` || config.semanticRecall === true;
+      if (resourceScope && !resourceId && config?.semanticRecall && vectorSearchString) {
+        throw new Error(
+          `Memory error: Resource-scoped semantic recall is enabled but no resourceId was provided. Either provide a resourceId or explicitly set semanticRecall.scope to 'thread'.`
+        );
+      }
+      let usage;
+      if (historyDisabledByConfig && (!config.semanticRecall || !vectorSearchString || !this.vector)) {
+        const result = {
+          messages: [],
+          usage: void 0,
+          total: 0,
+          page: page ?? 0,
+          perPage: 0,
+          hasMore: false
+        };
+        span?.end({ output: { success: true }, attributes: { messageCount: 0 } });
+        return result;
+      }
+      if (config?.semanticRecall && vectorSearchString && this.vector) {
+        const result = await this.embedMessageContent(vectorSearchString);
+        usage = result.usage;
+        const { embeddings, dimension } = result;
+        const { indexName } = await this.createEmbeddingIndex(dimension, config);
+        await Promise.all(
+          embeddings.map(async (embedding) => {
+            if (typeof this.vector === `undefined`) {
+              throw new Error(
+                `Tried to query vector index ${indexName} but this Memory instance doesn't have an attached vector db.`
+              );
+            }
+            vectorResults.push(
+              ...await this.vector.query({
+                indexName,
+                queryVector: embedding,
+                topK: vectorConfig.topK,
+                filter: resourceScope ? {
+                  resource_id: resourceId
+                } : {
+                  thread_id: threadId
+                }
+              })
             );
-          }
-          vectorResults.push(
-            ...await this.vector.query({
-              indexName,
-              queryVector: embedding,
-              topK: vectorConfig.topK,
-              filter: resourceScope ? {
-                resource_id: resourceId
-              } : {
-                thread_id: threadId
-              }
-            })
-          );
-        })
-      );
+          })
+        );
+      }
+      const memoryStore = await this.getMemoryStore();
+      const effectivePerPage = historyDisabledByConfig ? 0 : perPage;
+      const paginatedResult = await memoryStore.listMessages({
+        threadId,
+        resourceId,
+        perPage: effectivePerPage,
+        page,
+        orderBy: effectiveOrderBy,
+        filter: filter32,
+        ...vectorResults?.length ? {
+          include: vectorResults.map((r) => ({
+            id: r.metadata?.message_id,
+            threadId: r.metadata?.thread_id,
+            withNextMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.after,
+            withPreviousMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.before
+          }))
+        } : {}
+      });
+      const rawMessages = shouldGetNewestAndReverse ? paginatedResult.messages.reverse() : paginatedResult.messages;
+      const list = new agent.MessageList({ threadId, resourceId }).add(rawMessages, "memory");
+      const messages = memory.filterSystemReminderMessages(list.get.all.db(), includeSystemReminders);
+      const { total, page: resultPage, perPage: resultPerPage, hasMore } = paginatedResult;
+      const recallResult = { messages, usage, total, page: resultPage, perPage: resultPerPage, hasMore };
+      span?.end({
+        output: { success: true },
+        attributes: {
+          messageCount: messages.length,
+          embeddingTokens: usage?.tokens,
+          vectorResultCount: vectorResults.length
+        }
+      });
+      return recallResult;
+    } catch (error) {
+      span?.error({ error, endSpan: true });
+      throw error;
     }
-    const memoryStore = await this.getMemoryStore();
-    const effectivePerPage = historyDisabledByConfig ? 0 : perPage;
-    const paginatedResult = await memoryStore.listMessages({
-      threadId,
-      resourceId,
-      perPage: effectivePerPage,
-      page,
-      orderBy: effectiveOrderBy,
-      filter: filter32,
-      ...vectorResults?.length ? {
-        include: vectorResults.map((r) => ({
-          id: r.metadata?.message_id,
-          threadId: r.metadata?.thread_id,
-          withNextMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.after,
-          withPreviousMessages: typeof vectorConfig.messageRange === "number" ? vectorConfig.messageRange : vectorConfig.messageRange.before
-        }))
-      } : {}
-    });
-    const rawMessages = shouldGetNewestAndReverse ? paginatedResult.messages.reverse() : paginatedResult.messages;
-    const list = new agent.MessageList({ threadId, resourceId }).add(rawMessages, "memory");
-    const messages = list.get.all.db();
-    const { total, page: resultPage, perPage: resultPerPage, hasMore } = paginatedResult;
-    return { messages, usage, total, page: resultPage, perPage: resultPerPage, hasMore };
   }
   async getThreadById({ threadId }) {
     const memoryStore = await this.getMemoryStore();
@@ -17510,45 +17566,60 @@ var Memory = class extends memory.MastraMemory {
     threadId,
     resourceId,
     workingMemory,
-    memoryConfig
+    memoryConfig,
+    observabilityContext
   }) {
     const config = this.getMergedThreadConfig(memoryConfig || {});
     if (!config.workingMemory?.enabled) {
       throw new Error("Working memory is not enabled for this memory instance");
     }
-    const scope = config.workingMemory.scope || "resource";
-    if (scope === "resource" && !resourceId) {
-      throw new Error(
-        `Memory error: Resource-scoped working memory is enabled but no resourceId was provided. Either provide a resourceId or explicitly set workingMemory.scope to 'thread'.`
-      );
-    }
-    const mutexKey = scope === "resource" ? `resource-${resourceId}` : `thread-${threadId}`;
-    const mutex = this.updateWorkingMemoryMutexes.has(mutexKey) ? this.updateWorkingMemoryMutexes.get(mutexKey) : new Mutex();
-    this.updateWorkingMemoryMutexes.set(mutexKey, mutex);
-    const release = await mutex.acquire();
+    const span = this.createMemorySpan(
+      "update",
+      observabilityContext,
+      { threadId, resourceId },
+      {
+        workingMemoryEnabled: true
+      }
+    );
     try {
-      const memoryStore = await this.getMemoryStore();
-      if (scope === "resource" && resourceId) {
-        await memoryStore.updateResource({
-          resourceId,
-          workingMemory
-        });
-      } else {
-        const thread = await this.getThreadById({ threadId });
-        if (!thread) {
-          throw new Error(`Thread ${threadId} not found`);
-        }
-        await memoryStore.updateThread({
-          id: threadId,
-          title: thread.title || "",
-          metadata: {
-            ...thread.metadata,
+      const scope = config.workingMemory.scope || "resource";
+      if (scope === "resource" && !resourceId) {
+        throw new Error(
+          `Memory error: Resource-scoped working memory is enabled but no resourceId was provided. Either provide a resourceId or explicitly set workingMemory.scope to 'thread'.`
+        );
+      }
+      const mutexKey = scope === "resource" ? `resource-${resourceId}` : `thread-${threadId}`;
+      const mutex = this.updateWorkingMemoryMutexes.has(mutexKey) ? this.updateWorkingMemoryMutexes.get(mutexKey) : new Mutex();
+      this.updateWorkingMemoryMutexes.set(mutexKey, mutex);
+      const release = await mutex.acquire();
+      try {
+        const memoryStore = await this.getMemoryStore();
+        if (scope === "resource" && resourceId) {
+          await memoryStore.updateResource({
+            resourceId,
             workingMemory
+          });
+        } else {
+          const thread = await this.getThreadById({ threadId });
+          if (!thread) {
+            throw new Error(`Thread ${threadId} not found`);
           }
-        });
+          await memoryStore.updateThread({
+            id: threadId,
+            title: thread.title || "",
+            metadata: {
+              ...thread.metadata,
+              workingMemory
+            }
+          });
+        }
+      } finally {
+        release();
       }
-    } finally {
-      release();
+      span?.end({ output: { success: true } });
+    } catch (error) {
+      span?.error({ error, endSpan: true });
+      throw error;
     }
   }
   updateWorkingMemoryMutexes = /* @__PURE__ */ new Map();
@@ -17674,7 +17745,7 @@ ${workingMemory}`;
     }
     return chunks;
   }
-  hasher = chunkPNCR2M6Y_cjs.e();
+  hasher = chunkUHWF2UKO_cjs.e();
   // embedding is computationally expensive so cache content -> embeddings/chunks
   embeddingCache = /* @__PURE__ */ new Map();
   firstEmbed;
@@ -17726,67 +17797,85 @@ ${workingMemory}`;
   }
   async saveMessages({
     messages,
-    memoryConfig
+    memoryConfig,
+    observabilityContext
   }) {
-    const updatedMessages = messages.map((m) => {
-      return this.updateMessageToHideWorkingMemoryV2(m);
-    }).filter((m) => Boolean(m));
-    const config = this.getMergedThreadConfig(memoryConfig);
-    const dbMessages = new agent.MessageList({
-      generateMessageId: () => this.generateId()
-    }).add(updatedMessages, "memory").get.all.db();
-    const memoryStore = await this.getMemoryStore();
-    const result = await memoryStore.saveMessages({
-      messages: dbMessages
+    const span = this.createMemorySpan("save", observabilityContext, void 0, {
+      messageCount: messages.length
     });
-    let totalTokens = 0;
-    if (this.vector && config.semanticRecall) {
-      const embeddingData = [];
-      let dimension;
-      await Promise.all(
-        updatedMessages.map(async (message) => {
-          let textForEmbedding = null;
-          if (message.content.content && typeof message.content.content === "string" && message.content.content.trim() !== "") {
-            textForEmbedding = message.content.content;
-          } else if (message.content.parts && message.content.parts.length > 0) {
-            const joined = message.content.parts.filter((part) => part.type === "text").map((part) => part.text).join(" ").trim();
-            if (joined) textForEmbedding = joined;
+    try {
+      const updatedMessages = messages.map((m) => {
+        return this.updateMessageToHideWorkingMemoryV2(m);
+      }).filter((m) => Boolean(m));
+      const config = this.getMergedThreadConfig(memoryConfig);
+      const dbMessages = new agent.MessageList({
+        generateMessageId: () => this.generateId()
+      }).add(updatedMessages, "memory").get.all.db();
+      const memoryStore = await this.getMemoryStore();
+      const result = await memoryStore.saveMessages({
+        messages: dbMessages
+      });
+      let totalTokens = 0;
+      if (this.vector && config.semanticRecall) {
+        const embeddingData = [];
+        let dimension;
+        await Promise.all(
+          updatedMessages.map(async (message) => {
+            let textForEmbedding = null;
+            if (message.content.content && typeof message.content.content === "string" && message.content.content.trim() !== "") {
+              textForEmbedding = message.content.content;
+            } else if (message.content.parts && message.content.parts.length > 0) {
+              const joined = message.content.parts.filter((part) => part.type === "text").map((part) => part.text).join(" ").trim();
+              if (joined) textForEmbedding = joined;
+            }
+            if (!textForEmbedding) return;
+            const result2 = await this.embedMessageContent(textForEmbedding);
+            dimension = result2.dimension;
+            if (result2.usage?.tokens) {
+              totalTokens += result2.usage.tokens;
+            }
+            embeddingData.push({
+              embeddings: result2.embeddings,
+              metadata: result2.chunks.map(() => ({
+                message_id: message.id,
+                thread_id: message.threadId,
+                resource_id: message.resourceId
+              }))
+            });
+          })
+        );
+        if (embeddingData.length > 0 && dimension !== void 0) {
+          if (typeof this.vector === `undefined`) {
+            throw new Error(`Tried to upsert embeddings but this Memory instance doesn't have an attached vector db.`);
           }
-          if (!textForEmbedding) return;
-          const result2 = await this.embedMessageContent(textForEmbedding);
-          dimension = result2.dimension;
-          if (result2.usage?.tokens) {
-            totalTokens += result2.usage.tokens;
+          const { indexName } = await this.createEmbeddingIndex(dimension, config);
+          const allVectors = [];
+          const allMetadata = [];
+          for (const data of embeddingData) {
+            allVectors.push(...data.embeddings);
+            allMetadata.push(...data.metadata);
           }
-          embeddingData.push({
-            embeddings: result2.embeddings,
-            metadata: result2.chunks.map(() => ({
-              message_id: message.id,
-              thread_id: message.threadId,
-              resource_id: message.resourceId
-            }))
+          await this.vector.upsert({
+            indexName,
+            vectors: allVectors,
+            metadata: allMetadata
           });
-        })
-      );
-      if (embeddingData.length > 0 && dimension !== void 0) {
-        if (typeof this.vector === `undefined`) {
-          throw new Error(`Tried to upsert embeddings but this Memory instance doesn't have an attached vector db.`);
         }
-        const { indexName } = await this.createEmbeddingIndex(dimension, config);
-        const allVectors = [];
-        const allMetadata = [];
-        for (const data of embeddingData) {
-          allVectors.push(...data.embeddings);
-          allMetadata.push(...data.metadata);
-        }
-        await this.vector.upsert({
-          indexName,
-          vectors: allVectors,
-          metadata: allMetadata
-        });
       }
+      const saveResult = { ...result, usage: totalTokens > 0 ? { tokens: totalTokens } : void 0 };
+      span?.end({
+        output: { success: true },
+        attributes: {
+          messageCount: dbMessages.length,
+          embeddingTokens: saveResult.usage?.tokens,
+          semanticRecallEnabled: Boolean(config.semanticRecall)
+        }
+      });
+      return saveResult;
+    } catch (error) {
+      span?.error({ error, endSpan: true });
+      throw error;
     }
-    return { ...result, usage: totalTokens > 0 ? { tokens: totalTokens } : void 0 };
   }
   updateMessageToHideWorkingMemoryV2(message) {
     const newMessage = { ...message };
@@ -18058,7 +18147,7 @@ ${workingMemory}`;
         "Observational memory requires @mastra/core support for request-response-id-rotation. Please bump @mastra/core to a newer version."
       );
     }
-    const { ObservationalMemory: OMClass } = await import('./observational-memory-JQ34KLFS-CNLSTXO3.cjs');
+    const { ObservationalMemory: OMClass } = await import('./observational-memory-OVRHDQRG-OCHV6RZ7.cjs');
     const onIndexObservations = this.hasRetrievalSearch(omConfig.retrieval) ? async (observation) => {
       await this.indexObservation(observation);
     } : void 0;
@@ -18321,6 +18410,32 @@ Notes:
       }))
     });
   }
+  /**
+   * Update per-record observational memory config overrides for a thread.
+   * The provided config is deep-merged, so you only need to specify fields you want to change.
+   *
+   * @example
+   * ```ts
+   * await memory.updateObservationalMemoryConfig({
+   *   threadId: 'thread-1',
+   *   config: {
+   *     observation: { messageTokens: 2000 },
+   *     reflection: { observationTokens: 8000 },
+   *   },
+   * });
+   * ```
+   */
+  async updateObservationalMemoryConfig({
+    threadId,
+    resourceId,
+    config
+  }) {
+    const omEngine = await this.omEngine;
+    if (!omEngine) {
+      throw new Error("Observational memory is not enabled");
+    }
+    await omEngine.updateRecordConfig(threadId, resourceId, config);
+  }
   /**
    * Index a list of messages directly (without querying storage).
    * Used by observe-time indexing to vectorize newly-observed messages.
@@ -18494,7 +18609,7 @@ Notes:
    *   - Message objects with 'id' properties
    * @returns Promise that resolves when all messages are deleted
    */
-  async deleteMessages(input) {
+  async deleteMessages(input, observabilityContext) {
     let messageIds;
     if (!Array.isArray(input)) {
       throw new Error("Invalid input: must be an array of message IDs or message objects");
@@ -18515,10 +18630,19 @@ Notes:
     if (invalidIds.length > 0) {
       throw new Error("All message IDs must be non-empty strings");
     }
-    const memoryStore = await this.getMemoryStore();
-    await memoryStore.deleteMessages(messageIds);
-    if (this.vector) {
-      void this.deleteMessageVectors(messageIds);
+    const span = this.createMemorySpan("delete", observabilityContext, void 0, {
+      messageCount: messageIds.length
+    });
+    try {
+      const memoryStore = await this.getMemoryStore();
+      await memoryStore.deleteMessages(messageIds);
+      if (this.vector) {
+        void this.deleteMessageVectors(messageIds);
+      }
+      span?.end({ output: { success: true }, attributes: { messageCount: messageIds.length } });
+    } catch (error) {
+      span?.error({ error, endSpan: true });
+      throw error;
     }
   }
   /**
@@ -18946,7 +19070,7 @@ Notes:
     if (!effectiveConfig) return null;
     const engine = await this.omEngine;
     if (!engine) return null;
-    const { ObservationalMemoryProcessor } = await import('./observational-memory-JQ34KLFS-CNLSTXO3.cjs');
+    const { ObservationalMemoryProcessor } = await import('./observational-memory-OVRHDQRG-OCHV6RZ7.cjs');
     return new ObservationalMemoryProcessor(engine, this);
   }
 };
@@ -30166,5 +30290,5 @@ exports.START_ASYNC_AGENT_BUILDER_ACTION_ROUTE = START_ASYNC_AGENT_BUILDER_ACTIO
 exports.STREAM_AGENT_BUILDER_ACTION_ROUTE = STREAM_AGENT_BUILDER_ACTION_ROUTE;
 exports.STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE = STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE;
 exports.agent_builder_exports = agent_builder_exports;
-//# sourceMappingURL=chunk-VMA5TY4H.cjs.map
-//# sourceMappingURL=chunk-VMA5TY4H.cjs.map
+//# sourceMappingURL=chunk-2KF7EWOT.cjs.map
+//# sourceMappingURL=chunk-2KF7EWOT.cjs.map