@mastra/memory 1.6.0 → 1.6.1

package/dist/docs/references/reference-vectors-upstash.md

@@ -4,9 +4,9 @@ The UpstashVector class provides vector search using [Upstash Vector](https://up
 
 ## Constructor Options
 
-**url:** (`string`): Upstash Vector database URL
+**url** (`string`): Upstash Vector database URL
 
-**token:** (`string`): Upstash Vector API token
+**token** (`string`): Upstash Vector API token
 
 ## Methods
 
@@ -14,41 +14,41 @@ The UpstashVector class provides vector search using [Upstash Vector](https://up
 
 Note: This method is a no-op for Upstash as indexes are created automatically.
 
-**indexName:** (`string`): Name of the index to create
+**indexName** (`string`): Name of the index to create
 
-**dimension:** (`number`): Vector dimension (must match your embedding model)
+**dimension** (`number`): Vector dimension (must match your embedding model)
 
-**metric?:** (`'cosine' | 'euclidean' | 'dotproduct'`): Distance metric for similarity search (Default: `cosine`)
+**metric** (`'cosine' | 'euclidean' | 'dotproduct'`): Distance metric for similarity search (Default: `cosine`)
 
 ### upsert()
 
-**indexName:** (`string`): Name of the index to upsert into
+**indexName** (`string`): Name of the index to upsert into
 
-**vectors:** (`number[][]`): Array of embedding vectors
+**vectors** (`number[][]`): Array of embedding vectors
 
-**sparseVectors?:** (`{ indices: number[], values: number[] }[]`): Array of sparse vectors for hybrid search. Each sparse vector must have matching indices and values arrays.
+**sparseVectors** (`{ indices: number[], values: number[] }[]`): Array of sparse vectors for hybrid search. Each sparse vector must have matching indices and values arrays.
 
-**metadata?:** (`Record<string, any>[]`): Metadata for each vector
+**metadata** (`Record<string, any>[]`): Metadata for each vector
 
-**ids?:** (`string[]`): Optional vector IDs (auto-generated if not provided)
+**ids** (`string[]`): Optional vector IDs (auto-generated if not provided)
 
 ### query()
 
-**indexName:** (`string`): Name of the index to query
+**indexName** (`string`): Name of the index to query
 
-**queryVector:** (`number[]`): Query vector to find similar vectors
+**queryVector** (`number[]`): Query vector to find similar vectors
 
-**sparseVector?:** (`{ indices: number[], values: number[] }`): Optional sparse vector for hybrid search. Must have matching indices and values arrays.
+**sparseVector** (`{ indices: number[], values: number[] }`): Optional sparse vector for hybrid search. Must have matching indices and values arrays.
 
-**topK?:** (`number`): Number of results to return (Default: `10`)
+**topK** (`number`): Number of results to return (Default: `10`)
 
-**filter?:** (`Record<string, any>`): Metadata filters for the query
+**filter** (`Record<string, any>`): Metadata filters for the query
 
-**includeVector?:** (`boolean`): Whether to include vectors in the results (Default: `false`)
+**includeVector** (`boolean`): Whether to include vectors in the results (Default: `false`)
 
-**fusionAlgorithm?:** (`FusionAlgorithm`): Algorithm used to combine dense and sparse search results in hybrid search (e.g., RRF - Reciprocal Rank Fusion)
+**fusionAlgorithm** (`FusionAlgorithm`): Algorithm used to combine dense and sparse search results in hybrid search (e.g., RRF - Reciprocal Rank Fusion)
 
-**queryMode?:** (`QueryMode`): Search mode: 'DENSE' for dense-only, 'SPARSE' for sparse-only, or 'HYBRID' for combined search
+**queryMode** (`QueryMode`): Search mode: 'DENSE' for dense-only, 'SPARSE' for sparse-only, or 'HYBRID' for combined search
 
 ### listIndexes()
 
@@ -56,7 +56,7 @@ Returns an array of index names (namespaces) as strings.
 
 ### describeIndex()
 
-**indexName:** (`string`): Name of the index to describe
+**indexName** (`string`): Name of the index to describe
 
 Returns:
 
@@ -70,15 +70,15 @@ interface IndexStats {
 
 ### deleteIndex()
 
-**indexName:** (`string`): Name of the index (namespace) to delete
+**indexName** (`string`): Name of the index (namespace) to delete
 
 ### updateVector()
 
-**indexName:** (`string`): Name of the index to update
+**indexName** (`string`): Name of the index to update
 
-**id:** (`string`): ID of the item to update
+**id** (`string`): ID of the item to update
 
-**update:** (`object`): Update object containing vector, sparse vector, and/or metadata
+**update** (`object`): Update object containing vector, sparse vector, and/or metadata
 
 The `update` object can have the following properties:
 
@@ -88,9 +88,9 @@ The `update` object can have the following properties:
 
 ### deleteVector()
 
-**indexName:** (`string`): Name of the index from which to delete the item
+**indexName** (`string`): Name of the index from which to delete the item
 
-**id:** (`string`): ID of the item to delete
+**id** (`string`): ID of the item to delete
 
 Attempts to delete an item by its ID from the specified index. Logs an error message if the deletion fails.
 

package/dist/index.cjs

@@ -9587,7 +9587,7 @@ function withUserAgentSuffix2(headers, ...userAgentSuffixParts) {
   );
   return Object.fromEntries(normalizedHeaders.entries());
 }
-var VERSION4 = "4.0.15";
+var VERSION4 = "4.0.19";
 var getOriginalFetch3 = () => globalThis.fetch;
 var getFromApi2 = async ({
   url,
@@ -9672,8 +9672,8 @@ function loadOptionalSetting2({
   }
   return settingValue;
 }
-var suspectProtoRx2 = /"__proto__"\s*:/;
-var suspectConstructorRx2 = /"constructor"\s*:/;
+var suspectProtoRx2 = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+var suspectConstructorRx2 = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
 function _parse2(text4) {
   const obj = JSON.parse(text4);
   if (obj === null || typeof obj !== "object") {
@@ -9693,7 +9693,7 @@ function filter2(obj) {
       if (Object.prototype.hasOwnProperty.call(node, "__proto__")) {
         throw new SyntaxError("Object contains forbidden prototype property");
       }
-      if (Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
+      if (Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor === "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
         throw new SyntaxError("Object contains forbidden prototype property");
       }
       for (const key in node) {
@@ -12257,16 +12257,14 @@ var GatewayVideoModel = class {
     var _a932;
     const resolvedHeaders = await resolve2(this.config.headers());
     try {
-      const {
-        responseHeaders,
-        value: responseBody
-      } = await postJsonToApi2({
+      const { responseHeaders, value: responseBody } = await postJsonToApi2({
         url: this.getUrl(),
         headers: combineHeaders2(
           resolvedHeaders,
           headers != null ? headers : {},
           this.getModelConfigHeaders(),
-          await resolve2(this.config.o11yHeaders)
+          await resolve2(this.config.o11yHeaders),
+          { accept: "text/event-stream" }
         ),
         body: {
           prompt,
@@ -12279,9 +12277,70 @@ var GatewayVideoModel = class {
           ...providerOptions && { providerOptions },
           ...image && { image: maybeEncodeVideoFile(image) }
         },
-        successfulResponseHandler: createJsonResponseHandler2(
-          gatewayVideoResponseSchema
-        ),
+        successfulResponseHandler: async ({
+          response,
+          url,
+          requestBodyValues
+        }) => {
+          if (response.body == null) {
+            throw new APICallError3({
+              message: "SSE response body is empty",
+              url,
+              requestBodyValues,
+              statusCode: response.status
+            });
+          }
+          const eventStream = parseJsonEventStream2({
+            stream: response.body,
+            schema: gatewayVideoEventSchema
+          });
+          const reader = eventStream.getReader();
+          const { done, value: parseResult } = await reader.read();
+          reader.releaseLock();
+          if (done || !parseResult) {
+            throw new APICallError3({
+              message: "SSE stream ended without a data event",
+              url,
+              requestBodyValues,
+              statusCode: response.status
+            });
+          }
+          if (!parseResult.success) {
+            throw new APICallError3({
+              message: "Failed to parse video SSE event",
+              cause: parseResult.error,
+              url,
+              requestBodyValues,
+              statusCode: response.status
+            });
+          }
+          const event = parseResult.value;
+          if (event.type === "error") {
+            throw new APICallError3({
+              message: event.message,
+              statusCode: event.statusCode,
+              url,
+              requestBodyValues,
+              responseHeaders: Object.fromEntries([...response.headers]),
+              responseBody: JSON.stringify(event),
+              data: {
+                error: {
+                  message: event.message,
+                  type: event.errorType,
+                  param: event.param
+                }
+              }
+            });
+          }
+          return {
+            value: {
+              videos: event.videos,
+              warnings: event.warnings,
+              providerMetadata: event.providerMetadata
+            },
+            responseHeaders: Object.fromEntries([...response.headers])
+          };
+        },
         failedResponseHandler: createJsonErrorResponseHandler2({
           errorSchema: z4.z.any(),
           errorToMessage: (data) => data
@@ -12353,11 +12412,21 @@ var gatewayVideoWarningSchema = z4.z.discriminatedUnion("type", [
     message: z4.z.string()
   })
 ]);
-var gatewayVideoResponseSchema = z4.z.object({
-  videos: z4.z.array(gatewayVideoDataSchema),
-  warnings: z4.z.array(gatewayVideoWarningSchema).optional(),
-  providerMetadata: z4.z.record(z4.z.string(), providerMetadataEntrySchema22).optional()
-});
+var gatewayVideoEventSchema = z4.z.discriminatedUnion("type", [
+  z4.z.object({
+    type: z4.z.literal("result"),
+    videos: z4.z.array(gatewayVideoDataSchema),
+    warnings: z4.z.array(gatewayVideoWarningSchema).optional(),
+    providerMetadata: z4.z.record(z4.z.string(), providerMetadataEntrySchema22).optional()
+  }),
+  z4.z.object({
+    type: z4.z.literal("error"),
+    message: z4.z.string(),
+    errorType: z4.z.string(),
+    statusCode: z4.z.number(),
+    param: z4.z.unknown().nullable()
+  })
+]);
 var parallelSearchInputSchema = lazySchema(
   () => zodSchema3(
     zod.z.object({
@@ -12534,7 +12603,7 @@ async function getVercelRequestId2() {
   var _a932;
   return (_a932 = (0, import_oidc3.getContext)().headers) == null ? void 0 : _a932["x-vercel-id"];
 }
-var VERSION5 = "3.0.52";
+var VERSION5 = "3.0.66";
 var AI_GATEWAY_PROTOCOL_VERSION2 = "0.0.1";
 function createGatewayProvider2(options = {}) {
   var _a932, _b92;
@@ -12577,13 +12646,18 @@ function createGatewayProvider2(options = {}) {
       settingValue: void 0,
       environmentVariableName: "VERCEL_REGION"
     });
+    const projectId = loadOptionalSetting2({
+      settingValue: void 0,
+      environmentVariableName: "VERCEL_PROJECT_ID"
+    });
     return async () => {
       const requestId = await getVercelRequestId2();
       return {
         ...deploymentId && { "ai-o11y-deployment-id": deploymentId },
         ...environment && { "ai-o11y-environment": environment },
         ...region && { "ai-o11y-region": region },
-        ...requestId && { "ai-o11y-request-id": requestId }
+        ...requestId && { "ai-o11y-request-id": requestId },
+        ...projectId && { "ai-o11y-project-id": projectId }
       };
     };
   };
@@ -13602,7 +13676,7 @@ function getTotalTimeoutMs(timeout) {
   }
   return timeout.totalMs;
 }
-var VERSION33 = "6.0.94";
+var VERSION33 = "6.0.116";
 var dataContentSchema3 = z4.z.union([
   z4.z.string(),
   z4.z.instanceof(Uint8Array),
@@ -15152,6 +15226,25 @@ var updateWorkingMemoryTool = (memoryConfig) => {
         workingMemory = JSON.stringify(mergedData);
       } else {
         workingMemory = typeof inputData.memory === "string" ? inputData.memory : JSON.stringify(inputData.memory);
+        const existingRaw = await memory.getWorkingMemory({
+          threadId,
+          resourceId,
+          memoryConfig
+        });
+        if (existingRaw) {
+          const template = await memory.getWorkingMemoryTemplate({ memoryConfig });
+          if (template?.content) {
+            const normalizedNew = workingMemory.replace(/\s+/g, " ").trim();
+            const normalizedTemplate = template.content.replace(/\s+/g, " ").trim();
+            const normalizedExisting = existingRaw.replace(/\s+/g, " ").trim();
+            if (normalizedNew === normalizedTemplate && normalizedExisting !== normalizedTemplate) {
+              return {
+                success: false,
+                message: "Attempted to replace existing working memory with empty template. Update skipped to prevent data loss."
+              };
+            }
+          }
+        }
       }
       await memory.updateWorkingMemory({
         threadId,
@@ -15242,6 +15335,7 @@ function normalizeObservationalMemoryConfig(config) {
 var CHARS_PER_TOKEN = 4;
 var DEFAULT_MESSAGE_RANGE = { before: 1, after: 1 };
 var DEFAULT_TOP_K = 4;
+var VECTOR_DELETE_BATCH_SIZE = 100;
 var isZodObject = (v) => v instanceof zod.ZodObject;
 var Memory = class extends memory.MastraMemory {
   constructor(config = {}) {
@@ -15431,6 +15525,45 @@ var Memory = class extends memory.MastraMemory {
   async deleteThread(threadId) {
     const memoryStore = await this.getMemoryStore();
     await memoryStore.deleteThread({ threadId });
+    if (this.vector) {
+      void this.deleteThreadVectors(threadId);
+    }
+  }
+  /**
+   * Lists all vector indexes that match the memory messages prefix.
+   * Handles separator differences across vector store backends (e.g. '_' vs '-').
+   */
+  async getMemoryVectorIndexes() {
+    if (!this.vector) return [];
+    const separator = this.vector.indexSeparator ?? "_";
+    const prefix = `memory${separator}messages`;
+    const indexes = await this.vector.listIndexes();
+    return indexes.filter((name21) => name21.startsWith(prefix));
+  }
+  /**
+   * Deletes all vector embeddings associated with a thread.
+   * This is called internally by deleteThread to clean up orphaned vectors.
+   *
+   * @param threadId - The ID of the thread whose vectors should be deleted
+   */
+  async deleteThreadVectors(threadId) {
+    try {
+      const memoryIndexes = await this.getMemoryVectorIndexes();
+      await Promise.all(
+        memoryIndexes.map(async (indexName) => {
+          try {
+            await this.vector.deleteVectors({
+              indexName,
+              filter: { thread_id: threadId }
+            });
+          } catch {
+            this.logger.debug(`Failed to delete vectors for thread ${threadId} in ${indexName}, skipping`);
+          }
+        })
+      );
+    } catch {
+      this.logger.debug(`Failed to clean up vectors for thread ${threadId}`);
+    }
   }
   async updateWorkingMemory({
     threadId,
@@ -15448,25 +15581,33 @@ var Memory = class extends memory.MastraMemory {
         `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 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 mutexKey = scope === "resource" ? `resource-${resourceId}` : `thread-${threadId}`;
+    const mutex = this.updateWorkingMemoryMutexes.has(mutexKey) ? this.updateWorkingMemoryMutexes.get(mutexKey) : new asyncMutex.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();
     }
   }
   updateWorkingMemoryMutexes = /* @__PURE__ */ new Map();
@@ -15492,16 +15633,26 @@ var Memory = class extends memory.MastraMemory {
       const existingWorkingMemory = await this.getWorkingMemory({ threadId, resourceId, memoryConfig }) || "";
       const template = await this.getWorkingMemoryTemplate({ memoryConfig });
       let reason = "";
+      const normalizeForComparison = (str) => str.replace(/\s+/g, " ").trim();
+      const normalizedNewMemory = normalizeForComparison(workingMemory);
+      const normalizedTemplate = template?.content ? normalizeForComparison(template.content) : "";
       if (existingWorkingMemory) {
         if (searchString && existingWorkingMemory?.includes(searchString)) {
           workingMemory = existingWorkingMemory.replace(searchString, workingMemory);
           reason = `found and replaced searchString with newMemory`;
-        } else if (existingWorkingMemory.includes(workingMemory) || template?.content?.trim() === workingMemory.trim()) {
+        } else if (existingWorkingMemory.includes(workingMemory) || template?.content?.trim() === workingMemory.trim() || // Also check normalized versions to catch template variations with different whitespace
+        normalizedNewMemory === normalizedTemplate) {
           return {
             success: false,
             reason: `attempted to insert duplicate data into working memory. this entry was skipped`
           };
         } else {
+          if (normalizedNewMemory === normalizedTemplate) {
+            return {
+              success: false,
+              reason: `attempted to append empty template to working memory. this entry was skipped`
+            };
+          }
           if (searchString) {
             reason = `attempted to replace working memory string that doesn't exist. Appending to working memory instead.`;
           } else {
@@ -15510,7 +15661,7 @@ var Memory = class extends memory.MastraMemory {
           workingMemory = existingWorkingMemory + `
 ${workingMemory}`;
         }
-      } else if (workingMemory === template?.content) {
+      } else if (workingMemory === template?.content || normalizedNewMemory === normalizedTemplate) {
         return {
           success: false,
           reason: `try again when you have data to add. newMemory was equal to the working memory template`
@@ -15518,7 +15669,13 @@ ${workingMemory}`;
       } else {
         reason = `started new working memory`;
       }
-      workingMemory = template?.content ? workingMemory.replaceAll(template?.content, "") : workingMemory;
+      if (template?.content) {
+        workingMemory = workingMemory.replaceAll(template.content, "");
+        const templateWithUnixLineEndings = template.content.replace(/\r\n/g, "\n");
+        const templateWithWindowsLineEndings = template.content.replace(/\n/g, "\r\n");
+        workingMemory = workingMemory.replaceAll(templateWithUnixLineEndings, "");
+        workingMemory = workingMemory.replaceAll(templateWithWindowsLineEndings, "");
+      }
       const scope = config.workingMemory.scope || "resource";
       if (scope === "resource" && !resourceId) {
         throw new Error(
@@ -15994,24 +16151,25 @@ Notes:
         const messageIdsNeedingDeletion = /* @__PURE__ */ new Set([...messageIdsWithClearedContent, ...messageIdsWithNewEmbeddings]);
         if (messageIdsNeedingDeletion.size > 0) {
           try {
-            const indexes = await this.vector.listIndexes();
-            const memoryIndexes = indexes.filter((name21) => name21.startsWith("memory_messages"));
-            for (const indexName of memoryIndexes) {
-              for (const messageId of messageIdsNeedingDeletion) {
-                try {
-                  await this.vector.deleteVectors({
-                    indexName,
-                    filter: { message_id: messageId }
-                  });
-                } catch {
-                  this.logger.debug(
-                    `No existing vectors found for message ${messageId} in ${indexName}, skipping delete`
-                  );
+            const memoryIndexes = await this.getMemoryVectorIndexes();
+            const idsToDelete = [...messageIdsNeedingDeletion];
+            await Promise.all(
+              memoryIndexes.map(async (indexName) => {
+                for (let i = 0; i < idsToDelete.length; i += VECTOR_DELETE_BATCH_SIZE) {
+                  const batch = idsToDelete.slice(i, i + VECTOR_DELETE_BATCH_SIZE);
+                  try {
+                    await this.vector.deleteVectors({
+                      indexName,
+                      filter: { message_id: { $in: batch } }
+                    });
+                  } catch {
+                    this.logger.debug(`Failed to delete vector batch in ${indexName} (batch offset ${i}), skipping`);
+                  }
                 }
-              }
-            }
+              })
+            );
           } catch {
-            this.logger.debug(`No memory indexes found to delete from`);
+            this.logger.debug(`Failed to clean up old vectors during message update`);
           }
         }
         if (embeddingData.length > 0 && dimension !== void 0) {
@@ -16062,6 +16220,37 @@ Notes:
     }
     const memoryStore = await this.getMemoryStore();
     await memoryStore.deleteMessages(messageIds);
+    if (this.vector) {
+      void this.deleteMessageVectors(messageIds);
+    }
+  }
+  /**
+   * Deletes vector embeddings for specific messages.
+   * This is called internally by deleteMessages to clean up orphaned vectors.
+   *
+   * @param messageIds - The IDs of the messages whose vectors should be deleted
+   */
+  async deleteMessageVectors(messageIds) {
+    try {
+      const memoryIndexes = await this.getMemoryVectorIndexes();
+      await Promise.all(
+        memoryIndexes.map(async (indexName) => {
+          for (let i = 0; i < messageIds.length; i += VECTOR_DELETE_BATCH_SIZE) {
+            const batch = messageIds.slice(i, i + VECTOR_DELETE_BATCH_SIZE);
+            try {
+              await this.vector.deleteVectors({
+                indexName,
+                filter: { message_id: { $in: batch } }
+              });
+            } catch {
+              this.logger.debug(`Failed to delete vector batch in ${indexName} (batch offset ${i}), skipping`);
+            }
+          }
+        })
+      );
+    } catch {
+      this.logger.debug(`Failed to clean up vectors for deleted messages`);
+    }
   }
   /**
    * Clone a thread and its messages to create a new independent thread.
@@ -16476,7 +16665,7 @@ Notes:
         "Observational memory async buffering is enabled by default but the installed version of @mastra/core does not support it. Either upgrade @mastra/core, @mastra/memory, and your storage adapter (@mastra/libsql, @mastra/pg, or @mastra/mongodb) to the latest version, or explicitly disable async buffering by setting `observation: { bufferTokens: false }` in your observationalMemory config."
       );
     }
-    const { ObservationalMemory } = await import('./observational-memory-MXI54VC7.cjs');
+    const { ObservationalMemory } = await import('./observational-memory-AHVELJX4.cjs');
     return new ObservationalMemory({
       storage: memoryStore,
       scope: omConfig.scope,