@mastra/server 1.9.0 → 1.10.0

package/dist/{chunk-TXC7QU6O.cjs → chunk-E5I4COAV.cjs}

@@ -22496,7 +22496,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,
@@ -22581,8 +22581,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(text42) {
   const obj = JSON.parse(text42);
   if (obj === null || typeof obj !== "object") {
@@ -22602,7 +22602,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) {
@@ -25166,16 +25166,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,
@@ -25188,9 +25186,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: z42.z.any(),
           errorToMessage: (data) => data
@@ -25262,11 +25321,21 @@ var gatewayVideoWarningSchema = z42.z.discriminatedUnion("type", [
     message: z42.z.string()
   })
 ]);
-var gatewayVideoResponseSchema = z42.z.object({
-  videos: z42.z.array(gatewayVideoDataSchema),
-  warnings: z42.z.array(gatewayVideoWarningSchema).optional(),
-  providerMetadata: z42.z.record(z42.z.string(), providerMetadataEntrySchema22).optional()
-});
+var gatewayVideoEventSchema = z42.z.discriminatedUnion("type", [
+  z42.z.object({
+    type: z42.z.literal("result"),
+    videos: z42.z.array(gatewayVideoDataSchema),
+    warnings: z42.z.array(gatewayVideoWarningSchema).optional(),
+    providerMetadata: z42.z.record(z42.z.string(), providerMetadataEntrySchema22).optional()
+  }),
+  z42.z.object({
+    type: z42.z.literal("error"),
+    message: z42.z.string(),
+    errorType: z42.z.string(),
+    statusCode: z42.z.number(),
+    param: z42.z.unknown().nullable()
+  })
+]);
 var parallelSearchInputSchema = lazySchema(
   () => zodSchema3(
     z18.z.object({
@@ -25443,7 +25512,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;
@@ -25486,13 +25555,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 }
       };
     };
   };
@@ -26511,7 +26585,7 @@ function getTotalTimeoutMs(timeout) {
   }
   return timeout.totalMs;
 }
-var VERSION33 = "6.0.94";
+var VERSION33 = "6.0.116";
 var dataContentSchema3 = z42.z.union([
   z42.z.string(),
   z42.z.instanceof(Uint8Array),
@@ -28061,6 +28135,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,
@@ -28151,6 +28244,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 z18.ZodObject;
 var Memory = class extends memory.MastraMemory {
   constructor(config = {}) {
@@ -28340,6 +28434,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,
@@ -28357,25 +28490,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 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();
@@ -28401,16 +28542,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 {
@@ -28419,7 +28570,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`
@@ -28427,7 +28578,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(
@@ -28903,24 +29060,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) {
@@ -28971,6 +29129,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.
@@ -29385,7 +29574,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-SR6G4HN5-G66HNVG4.cjs');
+    const { ObservationalMemory } = await import('./observational-memory-QFQUF5EY-5VPKVXKI.cjs');
     return new ObservationalMemory({
       storage: memoryStore,
       scope: omConfig.scope,
@@ -40303,5 +40492,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-TXC7QU6O.cjs.map
-//# sourceMappingURL=chunk-TXC7QU6O.cjs.map
+//# sourceMappingURL=chunk-E5I4COAV.cjs.map
+//# sourceMappingURL=chunk-E5I4COAV.cjs.map