@mastra/core 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/{chunk-JV2KH24V.js → chunk-SXNQRJQD.js}

@@ -173,7 +173,7 @@ function convertImageFilePart(part, downloadedAssets) {
   const { data: convertedData, mediaType: convertedMediaType } = convertToDataContent(originalData);
   let mediaType = convertedMediaType ?? part.mediaType;
   let data = convertedData;
-  if (data instanceof URL) {
+  if (data instanceof URL && downloadedAssets) {
     const downloadedFile = downloadedAssets[data.toString()];
     if (downloadedFile) {
       data = downloadedFile.data;
@@ -208,14 +208,137 @@ function convertImageFilePart(part, downloadedAssets) {
     }
   }
 }
+z.union([
+  z.string(),
+  z.instanceof(Uint8Array),
+  z.instanceof(ArrayBuffer),
+  z.custom(
+    // Buffer might not be available in some environments such as CloudFlare:
+    (value) => globalThis.Buffer?.isBuffer(value) ?? false,
+    { message: "Must be a Buffer" }
+  )
+]);
+function convertDataContentToBase64String(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content instanceof ArrayBuffer) {
+    return convertUint8ArrayToBase64$1(new Uint8Array(content));
+  }
+  return convertUint8ArrayToBase64$1(content);
+}
+
+// src/agent/message-list/prompt/image-utils.ts
+function parseDataUri(dataUri) {
+  if (!dataUri.startsWith("data:")) {
+    return {
+      isDataUri: false,
+      base64Content: dataUri
+    };
+  }
+  const base64Index = dataUri.indexOf(",");
+  if (base64Index === -1) {
+    return {
+      isDataUri: true,
+      base64Content: dataUri
+    };
+  }
+  const header = dataUri.substring(5, base64Index);
+  const base64Content = dataUri.substring(base64Index + 1);
+  const semicolonIndex = header.indexOf(";");
+  const mimeType = semicolonIndex !== -1 ? header.substring(0, semicolonIndex) : header;
+  return {
+    isDataUri: true,
+    mimeType: mimeType || void 0,
+    base64Content
+  };
+}
+function createDataUri(base64Content, mimeType = "application/octet-stream") {
+  if (base64Content.startsWith("data:")) {
+    return base64Content;
+  }
+  return `data:${mimeType};base64,${base64Content}`;
+}
+function imageContentToString(image, fallbackMimeType) {
+  if (typeof image === "string") {
+    return image;
+  }
+  if (image instanceof URL) {
+    return image.toString();
+  }
+  if (image instanceof Uint8Array || image instanceof ArrayBuffer || globalThis.Buffer && Buffer.isBuffer(image)) {
+    const base64 = convertDataContentToBase64String(image);
+    return base64;
+  }
+  return String(image);
+}
+function getImageCacheKey(image) {
+  if (image instanceof URL) {
+    return image.toString();
+  }
+  if (typeof image === "string") {
+    return image.length;
+  }
+  if (image instanceof Uint8Array) {
+    return image.byteLength;
+  }
+  if (image instanceof ArrayBuffer) {
+    return image.byteLength;
+  }
+  return image;
+}
+function isValidUrl(str) {
+  try {
+    new URL(str);
+    return true;
+  } catch {
+    if (str.startsWith("//")) {
+      try {
+        new URL(`https:${str}`);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+}
+function categorizeFileData(data, fallbackMimeType) {
+  const parsed = parseDataUri(data);
+  const mimeType = parsed.isDataUri && parsed.mimeType ? parsed.mimeType : fallbackMimeType;
+  if (parsed.isDataUri) {
+    return {
+      type: "dataUri",
+      mimeType,
+      data
+    };
+  }
+  if (isValidUrl(data)) {
+    return {
+      type: "url",
+      mimeType,
+      data
+    };
+  }
+  return {
+    type: "raw",
+    mimeType,
+    data
+  };
+}
 
 // src/agent/message-list/prompt/attachments-to-parts.ts
 function attachmentsToParts(attachments) {
   const parts = [];
   for (const attachment of attachments) {
+    const categorized = categorizeFileData(attachment.url, attachment.contentType);
+    let urlString = attachment.url;
+    if (categorized.type === "raw") {
+      urlString = createDataUri(attachment.url, attachment.contentType || "application/octet-stream");
+    }
     let url;
     try {
-      url = new URL(attachment.url);
+      url = new URL(urlString);
     } catch {
       throw new Error(`Invalid URL: ${attachment.url}`);
     }
@@ -240,13 +363,13 @@ function attachmentsToParts(attachments) {
         if (attachment.contentType?.startsWith("image/")) {
           parts.push({
             type: "image",
-            image: attachment.url,
+            image: urlString,
             mimeType: attachment.contentType
           });
         } else if (attachment.contentType?.startsWith("text/")) {
           parts.push({
             type: "file",
-            data: attachment.url,
+            data: urlString,
             mimeType: attachment.contentType
           });
         } else {
@@ -255,7 +378,7 @@ function attachmentsToParts(attachments) {
           }
           parts.push({
             type: "file",
-            data: attachment.url,
+            data: urlString,
             mimeType: attachment.contentType
           });
         }
@@ -566,25 +689,6 @@ function convertToV1Messages(messages) {
   }
   return v1Messages;
 }
-z.union([
-  z.string(),
-  z.instanceof(Uint8Array),
-  z.instanceof(ArrayBuffer),
-  z.custom(
-    // Buffer might not be available in some environments such as CloudFlare:
-    (value) => globalThis.Buffer?.isBuffer(value) ?? false,
-    { message: "Must be a Buffer" }
-  )
-]);
-function convertDataContentToBase64String(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (content instanceof ArrayBuffer) {
-    return convertUint8ArrayToBase64$1(new Uint8Array(content));
-  }
-  return convertUint8ArrayToBase64$1(content);
-}
 
 // src/utils/fetchWithRetry.ts
 async function fetchWithRetry(url, options = {}, maxRetries = 3) {
@@ -675,18 +779,20 @@ async function downloadAssetsFromMessages({
       }
     }
     return { mediaType, data };
-  }).filter((part) => part.data instanceof URL).map((part) => ({
-    url: part.data,
-    isUrlSupportedByModel: part.mediaType != null && isUrlSupported({
-      url: part.data.toString(),
-      mediaType: part.mediaType,
-      supportedUrls: supportedUrls ?? {}
-    })
-  }));
+  }).filter((part) => part.data instanceof URL).map((part) => {
+    return {
+      url: part.data,
+      isUrlSupportedByModel: part.mediaType != null && isUrlSupported({
+        url: part.data.toString(),
+        mediaType: part.mediaType,
+        supportedUrls: supportedUrls ?? {}
+      })
+    };
+  });
   const downloadedFiles = await pMap(
     filesToDownload,
     async (fileItem) => {
-      if (!fileItem.isUrlSupportedByModel) {
+      if (fileItem.isUrlSupportedByModel) {
         return null;
       }
       return {
@@ -704,105 +810,6 @@ async function downloadAssetsFromMessages({
   return Object.fromEntries(downloadFileList);
 }
 
-// src/agent/message-list/prompt/image-utils.ts
-function parseDataUri(dataUri) {
-  if (!dataUri.startsWith("data:")) {
-    return {
-      isDataUri: false,
-      base64Content: dataUri
-    };
-  }
-  const base64Index = dataUri.indexOf(",");
-  if (base64Index === -1) {
-    return {
-      isDataUri: true,
-      base64Content: dataUri
-    };
-  }
-  const header = dataUri.substring(5, base64Index);
-  const base64Content = dataUri.substring(base64Index + 1);
-  const semicolonIndex = header.indexOf(";");
-  const mimeType = semicolonIndex !== -1 ? header.substring(0, semicolonIndex) : header;
-  return {
-    isDataUri: true,
-    mimeType: mimeType || void 0,
-    base64Content
-  };
-}
-function createDataUri(base64Content, mimeType = "application/octet-stream") {
-  if (base64Content.startsWith("data:")) {
-    return base64Content;
-  }
-  return `data:${mimeType};base64,${base64Content}`;
-}
-function imageContentToString(image, fallbackMimeType) {
-  if (typeof image === "string") {
-    return image;
-  }
-  if (image instanceof URL) {
-    return image.toString();
-  }
-  if (image instanceof Uint8Array || image instanceof ArrayBuffer || globalThis.Buffer && Buffer.isBuffer(image)) {
-    const base64 = convertDataContentToBase64String(image);
-    return base64;
-  }
-  return String(image);
-}
-function getImageCacheKey(image) {
-  if (image instanceof URL) {
-    return image.toString();
-  }
-  if (typeof image === "string") {
-    return image.length;
-  }
-  if (image instanceof Uint8Array) {
-    return image.byteLength;
-  }
-  if (image instanceof ArrayBuffer) {
-    return image.byteLength;
-  }
-  return image;
-}
-function isValidUrl(str) {
-  try {
-    new URL(str);
-    return true;
-  } catch {
-    if (str.startsWith("//")) {
-      try {
-        new URL(`https:${str}`);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    return false;
-  }
-}
-function categorizeFileData(data, fallbackMimeType) {
-  const parsed = parseDataUri(data);
-  const mimeType = parsed.isDataUri && parsed.mimeType ? parsed.mimeType : fallbackMimeType;
-  if (parsed.isDataUri) {
-    return {
-      type: "dataUri",
-      mimeType,
-      data
-    };
-  }
-  if (isValidUrl(data)) {
-    return {
-      type: "url",
-      mimeType,
-      data
-    };
-  }
-  return {
-    type: "raw",
-    mimeType,
-    data
-  };
-}
-
 // src/agent/message-list/utils/ai-v5/gemini-compatibility.ts
 function ensureGeminiCompatibleMessages(messages) {
   const result = [...messages];
@@ -870,6 +877,9 @@ function convertMessages(messages) {
 }
 
 // src/agent/message-list/index.ts
+function filterDataParts(parts) {
+  return parts.filter((part) => !part.type.startsWith("data-"));
+}
 var MessageList = class _MessageList {
   messages = [];
   // passed in by dev in input or context
@@ -888,6 +898,9 @@ var MessageList = class _MessageList {
   userContextMessagesPersisted = /* @__PURE__ */ new Set();
   generateMessageId;
   _agentNetworkAppend = false;
+  // Event recording for observability
+  isRecording = false;
+  recordedEvents = [];
   constructor({
     threadId,
     resourceId,
@@ -901,10 +914,34 @@ var MessageList = class _MessageList {
     this.generateMessageId = generateMessageId;
     this._agentNetworkAppend = _agentNetworkAppend || false;
   }
+  /**
+   * Start recording mutations to the MessageList for observability/tracing
+   */
+  startRecording() {
+    this.isRecording = true;
+    this.recordedEvents = [];
+  }
+  /**
+   * Stop recording and return the list of recorded events
+   */
+  stopRecording() {
+    this.isRecording = false;
+    const events = [...this.recordedEvents];
+    this.recordedEvents = [];
+    return events;
+  }
   add(messages, messageSource) {
     if (messageSource === `user`) messageSource = `input`;
     if (!messages) return this;
-    for (const message of Array.isArray(messages) ? messages : [messages]) {
+    const messageArray = Array.isArray(messages) ? messages : [messages];
+    if (this.isRecording) {
+      this.recordedEvents.push({
+        type: "add",
+        source: messageSource,
+        count: messageArray.length
+      });
+    }
+    for (const message of messageArray) {
       this.addOne(
         typeof message === `string` ? {
           role: "user",
@@ -966,6 +1003,24 @@ var MessageList = class _MessageList {
     this.userContextMessagesPersisted = this.deserializeSet(state.userContextMessagesPersisted);
     return this;
   }
+  makeMessageSourceChecker() {
+    const sources = {
+      memory: new Set(Array.from(this.memoryMessages.values()).map((m) => m.id)),
+      output: new Set(Array.from(this.newResponseMessages.values()).map((m) => m.id)),
+      input: new Set(Array.from(this.newUserMessages.values()).map((m) => m.id)),
+      context: new Set(Array.from(this.userContextMessages.values()).map((m) => m.id))
+    };
+    return {
+      ...sources,
+      getSource: (msg) => {
+        if (sources.memory.has(msg.id)) return "memory";
+        if (sources.input.has(msg.id)) return "input";
+        if (sources.output.has(msg.id)) return "response";
+        if (sources.context.has(msg.id)) return "context";
+        return null;
+      }
+    };
+  }
   getLatestUserContent() {
     const currentUserMessages = this.all.core().filter((m) => m.role === "user");
     const content = currentUserMessages.at(-1)?.content;
@@ -990,11 +1045,34 @@ var MessageList = class _MessageList {
   }
   get clear() {
     return {
+      all: {
+        db: () => {
+          const allMessages = [...this.messages];
+          this.messages = [];
+          this.newUserMessages.clear();
+          this.newResponseMessages.clear();
+          this.userContextMessages.clear();
+          if (this.isRecording && allMessages.length > 0) {
+            this.recordedEvents.push({
+              type: "clear",
+              count: allMessages.length
+            });
+          }
+          return allMessages;
+        }
+      },
       input: {
         db: () => {
           const userMessages = Array.from(this.newUserMessages);
           this.messages = this.messages.filter((m) => !this.newUserMessages.has(m));
           this.newUserMessages.clear();
+          if (this.isRecording && userMessages.length > 0) {
+            this.recordedEvents.push({
+              type: "clear",
+              source: "input",
+              count: userMessages.length
+            });
+          }
           return userMessages;
         }
       },
@@ -1003,11 +1081,46 @@ var MessageList = class _MessageList {
           const responseMessages = Array.from(this.newResponseMessages);
           this.messages = this.messages.filter((m) => !this.newResponseMessages.has(m));
           this.newResponseMessages.clear();
+          if (this.isRecording && responseMessages.length > 0) {
+            this.recordedEvents.push({
+              type: "clear",
+              source: "response",
+              count: responseMessages.length
+            });
+          }
           return responseMessages;
         }
       }
     };
   }
+  /**
+   * Remove messages by ID
+   * @param ids - Array of message IDs to remove
+   * @returns Array of removed messages
+   */
+  removeByIds(ids) {
+    const idsSet = new Set(ids);
+    const removed = [];
+    this.messages = this.messages.filter((m) => {
+      if (idsSet.has(m.id)) {
+        removed.push(m);
+        this.memoryMessages.delete(m);
+        this.newUserMessages.delete(m);
+        this.newResponseMessages.delete(m);
+        this.userContextMessages.delete(m);
+        return false;
+      }
+      return true;
+    });
+    if (this.isRecording && removed.length > 0) {
+      this.recordedEvents.push({
+        type: "removeByIds",
+        ids,
+        count: removed.length
+      });
+    }
+    return removed;
+  }
   all = {
     db: () => this.messages,
     v1: () => convertToV1Messages(this.all.db()),
@@ -1041,7 +1154,10 @@ var MessageList = class _MessageList {
           supportedUrls: options?.supportedUrls
         });
         let messages = [...systemMessages, ...modelMessages];
-        if (Object.keys(downloadedAssets || {}).length > 0) {
+        const hasImageOrFileContent = modelMessages.some(
+          (message) => message.role === "user" && typeof message.content !== "string" && message.content.some((part) => part.type === "image" || part.type === "file")
+        );
+        if (hasImageOrFileContent) {
           messages = messages.map((message) => {
             if (message.role === "user") {
               if (typeof message.content === "string") {
@@ -1308,12 +1424,47 @@ var MessageList = class _MessageList {
     if (unsavedMessages.length === 0) return void 0;
     return Math.min(...unsavedMessages.map((m) => new Date(m.createdAt).getTime()));
   }
+  /**
+   * Check if a message is a new user or response message that should be saved.
+   * Checks by message ID to handle cases where the message object may be a copy.
+   */
+  isNewMessage(messageOrId) {
+    const id = typeof messageOrId === "string" ? messageOrId : messageOrId.id;
+    if (typeof messageOrId !== "string") {
+      if (this.newUserMessages.has(messageOrId) || this.newResponseMessages.has(messageOrId)) {
+        return true;
+      }
+    }
+    return Array.from(this.newUserMessages).some((m) => m.id === id) || Array.from(this.newResponseMessages).some((m) => m.id === id);
+  }
   getSystemMessages(tag) {
     if (tag) {
       return this.taggedSystemMessages[tag] || [];
     }
     return this.systemMessages;
   }
+  /**
+   * Get all system messages (both tagged and untagged)
+   * @returns Array of all system messages
+   */
+  getAllSystemMessages() {
+    return [...this.systemMessages, ...Object.values(this.taggedSystemMessages).flat()];
+  }
+  /**
+   * Replace all system messages with new ones
+   * This clears both tagged and untagged system messages and replaces them with the provided array
+   * @param messages - Array of system messages to set
+   */
+  replaceAllSystemMessages(messages) {
+    this.systemMessages = [];
+    this.taggedSystemMessages = {};
+    for (const message of messages) {
+      if (message.role === "system") {
+        this.systemMessages.push(message);
+      }
+    }
+    return this;
+  }
   addSystem(messages, tag) {
     if (!messages) return this;
     for (const message of Array.isArray(messages) ? messages : [messages]) {
@@ -1372,8 +1523,21 @@ var MessageList = class _MessageList {
     if (tag && !this.isDuplicateSystem(coreMessage, tag)) {
       this.taggedSystemMessages[tag] ||= [];
       this.taggedSystemMessages[tag].push(coreMessage);
+      if (this.isRecording) {
+        this.recordedEvents.push({
+          type: "addSystem",
+          tag,
+          message: coreMessage
+        });
+      }
     } else if (!tag && !this.isDuplicateSystem(coreMessage)) {
       this.systemMessages.push(coreMessage);
+      if (this.isRecording) {
+        this.recordedEvents.push({
+          type: "addSystem",
+          message: coreMessage
+        });
+      }
     }
   }
   isDuplicateSystem(message, tag) {
@@ -1399,9 +1563,20 @@ var MessageList = class _MessageList {
     if (m.content.parts.length) {
       for (const part of m.content.parts) {
         if (part.type === `file`) {
+          let normalizedUrl;
+          if (typeof part.data === "string") {
+            const categorized = categorizeFileData(part.data, part.mimeType);
+            if (categorized.type === "raw") {
+              normalizedUrl = createDataUri(part.data, part.mimeType || "application/octet-stream");
+            } else {
+              normalizedUrl = part.data;
+            }
+          } else {
+            normalizedUrl = part.data;
+          }
           experimentalAttachments.push({
             contentType: part.mimeType,
-            url: part.data
+            url: normalizedUrl
           });
         } else if (part.type === "tool-invocation" && (part.toolInvocation.state === "call" || part.toolInvocation.state === "partial-call")) {
           continue;
@@ -1439,13 +1614,14 @@ var MessageList = class _MessageList {
     if (parts.length === 0 && experimentalAttachments.length > 0) {
       parts.push({ type: "text", text: "" });
     }
+    const v4Parts = filterDataParts(parts);
     if (m.role === `user`) {
       const uiMessage2 = {
         id: m.id,
         role: m.role,
         content: m.content.content || contentString,
         createdAt: m.createdAt,
-        parts,
+        parts: v4Parts,
         experimental_attachments: experimentalAttachments
       };
       if (m.content.metadata) {
@@ -1459,7 +1635,7 @@ var MessageList = class _MessageList {
         role: m.role,
         content: isSingleTextContentArray ? contentString : m.content.content || contentString,
         createdAt: m.createdAt,
-        parts,
+        parts: v4Parts,
         reasoning: void 0,
         toolInvocations: `toolInvocations` in m.content ? m.content.toolInvocations?.filter((t) => t.state === "result") : void 0
       };
@@ -1473,7 +1649,7 @@ var MessageList = class _MessageList {
       role: m.role,
       content: m.content.content || contentString,
       createdAt: m.createdAt,
-      parts,
+      parts: v4Parts,
       experimental_attachments: experimentalAttachments
     };
     if (m.content.metadata) {
@@ -1642,6 +1818,9 @@ var MessageList = class _MessageList {
     } else if (messageSource === `response`) {
       this.newResponseMessages.add(messageV2);
       this.newResponseMessagesPersisted.add(messageV2);
+      if (this.newUserMessages.has(messageV2)) {
+        this.newUserMessages.delete(messageV2);
+      }
     } else if (messageSource === `input`) {
       this.newUserMessages.add(messageV2);
       this.newUserMessagesPersisted.add(messageV2);
@@ -1666,13 +1845,11 @@ var MessageList = class _MessageList {
     insertAt
     // optional
   }) {
-    const partKey = _MessageList.cacheKeyFromAIV4Parts([part]);
+    const partKey = _MessageList.cacheKeyFromDBParts([part]);
     const latestPartCount = latestMessage.content.parts.filter(
-      (p) => _MessageList.cacheKeyFromAIV4Parts([p]) === partKey
-    ).length;
-    const newPartCount = newMessage.content.parts.filter(
-      (p) => _MessageList.cacheKeyFromAIV4Parts([p]) === partKey
+      (p) => _MessageList.cacheKeyFromDBParts([p]) === partKey
     ).length;
+    const newPartCount = newMessage.content.parts.filter((p) => _MessageList.cacheKeyFromDBParts([p]) === partKey).length;
     if (latestPartCount < newPartCount) {
       const partIndex = newMessage.content.parts.indexOf(part);
       const hasStepStartBefore = partIndex > 0 && newMessage.content.parts[partIndex - 1]?.type === "step-start";
@@ -1708,7 +1885,7 @@ var MessageList = class _MessageList {
     for (let i = 0; i < messageV2.content.parts.length; ++i) {
       const part = messageV2.content.parts[i];
       if (!part) continue;
-      const key = _MessageList.cacheKeyFromAIV4Parts([part]);
+      const key = _MessageList.cacheKeyFromDBParts([part]);
       const partToAdd = partsToAdd.get(i);
       if (!key || !partToAdd) continue;
       if (anchorMap.size > 0) {
@@ -1719,7 +1896,7 @@ var MessageList = class _MessageList {
         const offset = leftAnchorV2 === -1 ? i : i - leftAnchorV2;
         const insertAt = leftAnchorLatest + offset;
         const rightAnchorLatest = rightAnchorV2 !== -1 ? anchorMap.get(rightAnchorV2) : latestMessage.content.parts.length;
-        if (insertAt >= 0 && insertAt <= rightAnchorLatest && !latestMessage.content.parts.slice(insertAt, rightAnchorLatest).some((p) => _MessageList.cacheKeyFromAIV4Parts([p]) === _MessageList.cacheKeyFromAIV4Parts([part]))) {
+        if (insertAt >= 0 && insertAt <= rightAnchorLatest && !latestMessage.content.parts.slice(insertAt, rightAnchorLatest).some((p) => _MessageList.cacheKeyFromDBParts([p]) === _MessageList.cacheKeyFromDBParts([part]))) {
           this.pushNewMessagePart({
             latestMessage,
             newMessage: messageV2,
@@ -1770,8 +1947,10 @@ var MessageList = class _MessageList {
     }
     if (_MessageList.isAIV5CoreMessage(message)) {
       const dbMsg = _MessageList.aiV5ModelMessageToMastraDBMessage(message, messageSource);
+      const rawCreatedAt = "metadata" in message && message.metadata && typeof message.metadata === "object" && "createdAt" in message.metadata ? message.metadata.createdAt : void 0;
       const result = {
         ...dbMsg,
+        createdAt: this.generateCreatedAt(messageSource, rawCreatedAt),
         threadId: this.memoryInfo?.threadId,
         resourceId: this.memoryInfo?.resourceId
       };
@@ -1779,8 +1958,10 @@ var MessageList = class _MessageList {
     }
     if (_MessageList.isAIV5UIMessage(message)) {
       const dbMsg = _MessageList.aiV5UIMessageToMastraDBMessage(message);
+      const rawCreatedAt = "createdAt" in message ? message.createdAt : void 0;
       return {
         ...dbMsg,
+        createdAt: this.generateCreatedAt(messageSource, rawCreatedAt),
         threadId: this.memoryInfo?.threadId,
         resourceId: this.memoryInfo?.resourceId
       };
@@ -1790,16 +1971,16 @@ var MessageList = class _MessageList {
   lastCreatedAt;
   // this makes sure messages added in order will always have a date atleast 1ms apart.
   generateCreatedAt(messageSource, start) {
-    start = start instanceof Date ? start : start ? new Date(start) : void 0;
-    if (start && !this.lastCreatedAt) {
-      this.lastCreatedAt = start.getTime();
-      return start;
+    const startDate = start instanceof Date ? start : typeof start === "string" || typeof start === "number" ? new Date(start) : void 0;
+    if (startDate && !this.lastCreatedAt) {
+      this.lastCreatedAt = startDate.getTime();
+      return startDate;
     }
-    if (start && messageSource === `memory`) {
-      return start;
+    if (startDate && messageSource === `memory`) {
+      return startDate;
     }
     const now = /* @__PURE__ */ new Date();
-    const nowTime = start?.getTime() || now.getTime();
+    const nowTime = startDate?.getTime() || now.getTime();
     const lastTime = this.messages.reduce((p, m) => {
       if (m.createdAt.getTime() > p) return m.createdAt.getTime();
       return p;
@@ -1853,6 +2034,12 @@ var MessageList = class _MessageList {
         return ti;
       });
     }
+    if (!message.threadId && this.memoryInfo?.threadId) {
+      message.threadId = this.memoryInfo.threadId;
+      if (!message.resourceId && this.memoryInfo?.resourceId) {
+        message.resourceId = this.memoryInfo.resourceId;
+      }
+    }
     return message;
   }
   aiV4UIMessageToMastraDBMessage(message, messageSource) {
@@ -1890,137 +2077,180 @@ var MessageList = class _MessageList {
     if (typeof coreMessage.content === "string") {
       parts.push({
         type: "text",
-        text: coreMessage.content,
-        // Preserve providerOptions from CoreMessage (e.g., for system messages with cacheControl)
-        ..."providerOptions" in coreMessage && coreMessage.providerOptions ? { providerMetadata: coreMessage.providerOptions } : {}
+        text: coreMessage.content
       });
     } else if (Array.isArray(coreMessage.content)) {
-      for (const part of coreMessage.content) {
-        switch (part.type) {
-          case "text":
+      for (const aiV4Part of coreMessage.content) {
+        switch (aiV4Part.type) {
+          case "text": {
             const prevPart = parts.at(-1);
             if (coreMessage.role === "assistant" && prevPart && prevPart.type === "tool-invocation") {
               parts.push({ type: "step-start" });
             }
-            const mergedProviderMetadata = {
-              ..."providerOptions" in coreMessage && coreMessage.providerOptions ? coreMessage.providerOptions : {},
-              ..."providerOptions" in part && part.providerOptions ? part.providerOptions : {}
-            };
-            parts.push({
+            const part = {
               type: "text",
-              text: part.text,
-              ...Object.keys(mergedProviderMetadata).length > 0 ? { providerMetadata: mergedProviderMetadata } : {}
-            });
+              text: aiV4Part.text
+            };
+            if (aiV4Part.providerOptions) {
+              part.providerMetadata = aiV4Part.providerOptions;
+            }
+            parts.push(part);
             break;
-          case "tool-call":
-            parts.push({
+          }
+          case "tool-call": {
+            const part = {
               type: "tool-invocation",
               toolInvocation: {
                 state: "call",
-                toolCallId: part.toolCallId,
-                toolName: part.toolName,
-                args: part.args
+                toolCallId: aiV4Part.toolCallId,
+                toolName: aiV4Part.toolName,
+                args: aiV4Part.args
               }
-            });
+            };
+            if (aiV4Part.providerOptions) {
+              part.providerMetadata = aiV4Part.providerOptions;
+            }
+            parts.push(part);
             break;
+          }
           case "tool-result":
-            let toolArgs = {};
-            const toolCallInSameMsg = coreMessage.content.find(
-              (p) => p.type === "tool-call" && p.toolCallId === part.toolCallId
-            );
-            if (toolCallInSameMsg && toolCallInSameMsg.type === "tool-call") {
-              toolArgs = toolCallInSameMsg.args;
-            }
-            if (Object.keys(toolArgs).length === 0) {
-              for (let i = this.messages.length - 1; i >= 0; i--) {
-                const msg = this.messages[i];
-                if (msg && msg.role === "assistant" && msg.content.parts) {
-                  const toolCallPart = msg.content.parts.find(
-                    (p) => p.type === "tool-invocation" && p.toolInvocation.toolCallId === part.toolCallId && p.toolInvocation.state === "call"
-                  );
-                  if (toolCallPart && toolCallPart.type === "tool-invocation" && toolCallPart.toolInvocation.args) {
-                    toolArgs = toolCallPart.toolInvocation.args;
-                    break;
+            {
+              let toolArgs = {};
+              const toolCallInSameMsg = coreMessage.content.find(
+                (p) => p.type === "tool-call" && p.toolCallId === aiV4Part.toolCallId
+              );
+              if (toolCallInSameMsg && toolCallInSameMsg.type === "tool-call") {
+                toolArgs = toolCallInSameMsg.args;
+              }
+              if (Object.keys(toolArgs).length === 0) {
+                for (let i = this.messages.length - 1; i >= 0; i--) {
+                  const msg = this.messages[i];
+                  if (msg && msg.role === "assistant" && msg.content.parts) {
+                    const toolCallPart = msg.content.parts.find(
+                      (p) => p.type === "tool-invocation" && p.toolInvocation.toolCallId === aiV4Part.toolCallId && p.toolInvocation.state === "call"
+                    );
+                    if (toolCallPart && toolCallPart.type === "tool-invocation" && toolCallPart.toolInvocation.args) {
+                      toolArgs = toolCallPart.toolInvocation.args;
+                      break;
+                    }
                   }
                 }
               }
+              const invocation = {
+                state: "result",
+                toolCallId: aiV4Part.toolCallId,
+                toolName: aiV4Part.toolName,
+                result: aiV4Part.result ?? "",
+                // undefined will cause AI SDK to throw an error, but for client side tool calls this really could be undefined
+                args: toolArgs
+                // Use the args from the corresponding tool-call
+              };
+              const part = {
+                type: "tool-invocation",
+                toolInvocation: invocation
+              };
+              if (aiV4Part.providerOptions) {
+                part.providerMetadata = aiV4Part.providerOptions;
+              }
+              parts.push(part);
+              toolInvocations.push(invocation);
             }
-            const invocation = {
-              state: "result",
-              toolCallId: part.toolCallId,
-              toolName: part.toolName,
-              result: part.result ?? "",
-              // undefined will cause AI SDK to throw an error, but for client side tool calls this really could be undefined
-              args: toolArgs
-              // Use the args from the corresponding tool-call
-            };
-            parts.push({
-              type: "tool-invocation",
-              toolInvocation: invocation
-            });
-            toolInvocations.push(invocation);
             break;
           case "reasoning":
-            parts.push({
-              type: "reasoning",
-              reasoning: "",
-              // leave this blank so we aren't double storing it in the db along with details
-              details: [{ type: "text", text: part.text, signature: part.signature }]
-            });
+            {
+              const part = {
+                type: "reasoning",
+                reasoning: "",
+                // leave this blank so we aren't double storing it in the db along with details
+                details: [{ type: "text", text: aiV4Part.text, signature: aiV4Part.signature }]
+              };
+              if (aiV4Part.providerOptions) {
+                part.providerMetadata = aiV4Part.providerOptions;
+              }
+              parts.push(part);
+            }
             break;
           case "redacted-reasoning":
-            parts.push({
-              type: "reasoning",
-              reasoning: "",
-              // No text reasoning for redacted parts
-              details: [{ type: "redacted", data: part.data }]
-            });
+            {
+              const part = {
+                type: "reasoning",
+                reasoning: "",
+                // No text reasoning for redacted parts
+                details: [{ type: "redacted", data: aiV4Part.data }]
+              };
+              if (aiV4Part.providerOptions) {
+                part.providerMetadata = aiV4Part.providerOptions;
+              }
+              parts.push(part);
+            }
             break;
-          case "image":
-            parts.push({
+          case "image": {
+            const part = {
               type: "file",
-              data: imageContentToString(part.image),
-              mimeType: part.mimeType
-            });
+              data: imageContentToString(aiV4Part.image),
+              mimeType: aiV4Part.mimeType
+            };
+            if (aiV4Part.providerOptions) {
+              part.providerMetadata = aiV4Part.providerOptions;
+            }
+            parts.push(part);
             break;
-          case "file":
-            if (part.data instanceof URL) {
-              parts.push({
+          }
+          case "file": {
+            if (aiV4Part.data instanceof URL) {
+              const part = {
                 type: "file",
-                data: part.data.toString(),
-                mimeType: part.mimeType
-              });
-            } else if (typeof part.data === "string") {
-              const categorized = categorizeFileData(part.data, part.mimeType);
+                data: aiV4Part.data.toString(),
+                mimeType: aiV4Part.mimeType
+              };
+              if (aiV4Part.providerOptions) {
+                part.providerMetadata = aiV4Part.providerOptions;
+              }
+              parts.push(part);
+            } else if (typeof aiV4Part.data === "string") {
+              const categorized = categorizeFileData(aiV4Part.data, aiV4Part.mimeType);
               if (categorized.type === "url" || categorized.type === "dataUri") {
-                parts.push({
+                const part = {
                   type: "file",
-                  data: part.data,
+                  data: aiV4Part.data,
                   mimeType: categorized.mimeType || "image/png"
-                });
+                };
+                if (aiV4Part.providerOptions) {
+                  part.providerMetadata = aiV4Part.providerOptions;
+                }
+                parts.push(part);
               } else {
                 try {
-                  parts.push({
+                  const part = {
                     type: "file",
                     mimeType: categorized.mimeType || "image/png",
-                    data: convertDataContentToBase64String(part.data)
-                  });
+                    data: convertDataContentToBase64String(aiV4Part.data)
+                  };
+                  if (aiV4Part.providerOptions) {
+                    part.providerMetadata = aiV4Part.providerOptions;
+                  }
+                  parts.push(part);
                 } catch (error) {
                   console.error(`Failed to convert binary data to base64 in CoreMessage file part: ${error}`, error);
                 }
               }
             } else {
               try {
-                parts.push({
+                const part = {
                   type: "file",
-                  mimeType: part.mimeType,
-                  data: convertDataContentToBase64String(part.data)
-                });
+                  mimeType: aiV4Part.mimeType,
+                  data: convertDataContentToBase64String(aiV4Part.data)
+                };
+                if (aiV4Part.providerOptions) {
+                  part.providerMetadata = aiV4Part.providerOptions;
+                }
+                parts.push(part);
               } catch (error) {
                 console.error(`Failed to convert binary data to base64 in CoreMessage file part: ${error}`, error);
               }
             }
             break;
+          }
         }
       }
     }
@@ -2031,10 +2261,17 @@ var MessageList = class _MessageList {
     if (toolInvocations.length) content.toolInvocations = toolInvocations;
     if (typeof coreMessage.content === `string`) content.content = coreMessage.content;
     if (experimentalAttachments.length) content.experimental_attachments = experimentalAttachments;
+    if (coreMessage.providerOptions) {
+      content.providerMetadata = coreMessage.providerOptions;
+    }
+    if ("metadata" in coreMessage && coreMessage.metadata !== null && coreMessage.metadata !== void 0) {
+      content.metadata = coreMessage.metadata;
+    }
+    const rawCreatedAt = "metadata" in coreMessage && coreMessage.metadata && typeof coreMessage.metadata === "object" && "createdAt" in coreMessage.metadata ? coreMessage.metadata.createdAt : void 0;
     return {
       id,
       role: _MessageList.getRole(coreMessage),
-      createdAt: this.generateCreatedAt(messageSource),
+      createdAt: this.generateCreatedAt(messageSource, rawCreatedAt),
       threadId: this.memoryInfo?.threadId,
       resourceId: this.memoryInfo?.resourceId,
       content
@@ -2072,25 +2309,48 @@ var MessageList = class _MessageList {
     let key = ``;
     for (const part of parts) {
       key += part.type;
-      if (part.type === `text`) {
-        key += part.text;
-      }
-      if (part.type === `tool-invocation`) {
-        key += part.toolInvocation.toolCallId;
-        key += part.toolInvocation.state;
-      }
-      if (part.type === `reasoning`) {
-        key += part.reasoning;
-        key += part.details.reduce((prev, current) => {
-          if (current.type === `text`) {
-            return prev + current.text.length + (current.signature?.length || 0);
-          }
-          return prev;
-        }, 0);
+      key += _MessageList.cacheKeyFromAIV4Part(part);
+    }
+    return key;
+  }
+  static cacheKeyFromAIV4Part(part) {
+    let cacheKey = "";
+    if (part.type === `text`) {
+      cacheKey += part.text;
+    }
+    if (part.type === `tool-invocation`) {
+      cacheKey += part.toolInvocation.toolCallId;
+      cacheKey += part.toolInvocation.state;
+    }
+    if (part.type === `reasoning`) {
+      cacheKey += part.reasoning;
+      cacheKey += part.details.reduce((prev, current) => {
+        if (current.type === `text`) {
+          return prev + current.text.length + (current.signature?.length || 0);
+        }
+        return prev;
+      }, 0);
+      const partAny = part;
+      if (partAny && Object.hasOwn(partAny, "providerMetadata") && partAny.providerMetadata && Object.hasOwn(partAny.providerMetadata, "openai") && partAny.providerMetadata.openai && Object.hasOwn(partAny.providerMetadata.openai, "itemId")) {
+        const itemId = partAny.providerMetadata.openai.itemId;
+        cacheKey += `|${itemId}`;
       }
-      if (part.type === `file`) {
-        key += part.data;
-        key += part.mimeType;
+    }
+    if (part.type === `file`) {
+      cacheKey += part.data;
+      cacheKey += part.mimeType;
+    }
+    return cacheKey;
+  }
+  static cacheKeyFromDBParts(parts) {
+    let key = ``;
+    for (const part of parts) {
+      key += part.type;
+      if (part.type.startsWith("data-")) {
+        const data = part.data;
+        key += JSON.stringify(data);
+      } else {
+        key += _MessageList.cacheKeyFromAIV4Part(part);
       }
     }
     return key;
@@ -2160,7 +2420,7 @@ var MessageList = class _MessageList {
     const twoMM2 = _MessageList.isMastraDBMessage(two) && two;
     if (oneMM2 && !twoMM2) return false;
     if (oneMM2 && twoMM2) {
-      return oneMM2.id === twoMM2.id && _MessageList.cacheKeyFromAIV4Parts(oneMM2.content.parts) === _MessageList.cacheKeyFromAIV4Parts(twoMM2.content.parts);
+      return oneMM2.id === twoMM2.id && _MessageList.cacheKeyFromDBParts(oneMM2.content.parts) === _MessageList.cacheKeyFromDBParts(twoMM2.content.parts);
     }
     const oneUIV5 = _MessageList.isAIV5UIMessage(one) && one;
     const twoUIV5 = _MessageList.isAIV5UIMessage(two) && two;
@@ -2233,9 +2493,23 @@ var MessageList = class _MessageList {
           if (role === `tool` || role === `assistant`) {
             throw new Error(incompatibleMessage);
           }
+          let processedImage;
+          if (part.image instanceof URL || part.image instanceof Uint8Array) {
+            processedImage = part.image;
+          } else if (Buffer.isBuffer(part.image) || part.image instanceof ArrayBuffer) {
+            processedImage = new Uint8Array(part.image);
+          } else {
+            const categorized = categorizeFileData(part.image, part.mimeType);
+            if (categorized.type === "raw") {
+              const dataUri = createDataUri(part.image, part.mimeType || "image/png");
+              processedImage = new URL(dataUri);
+            } else {
+              processedImage = new URL(part.image);
+            }
+          }
           roleContent[role].push({
             ...part,
-            image: part.image instanceof URL || part.image instanceof Uint8Array ? part.image : Buffer.isBuffer(part.image) || part.image instanceof ArrayBuffer ? new Uint8Array(part.image) : new URL(part.image)
+            image: processedImage
           });
           break;
         }
@@ -2381,6 +2655,9 @@ var MessageList = class _MessageList {
     if (dbMsg.createdAt) metadata.createdAt = dbMsg.createdAt;
     if (dbMsg.threadId) metadata.threadId = dbMsg.threadId;
     if (dbMsg.resourceId) metadata.resourceId = dbMsg.resourceId;
+    if (dbMsg.content.providerMetadata) {
+      metadata.providerMetadata = dbMsg.content.providerMetadata;
+    }
     const hasToolInvocationParts = dbMsg.content.parts?.some((p) => p.type === "tool-invocation");
     if (dbMsg.content.toolInvocations && !hasToolInvocationParts) {
       for (const invocation of dbMsg.content.toolInvocations) {
@@ -2447,18 +2724,20 @@ var MessageList = class _MessageList {
           continue;
         }
         if (part.type === "reasoning") {
-          const reasoningPart = part;
-          const text = reasoningPart.text || reasoningPart.reasoning || (reasoningPart.details?.reduce((p, c) => {
+          const text = part.reasoning || (part.details?.reduce((p, c) => {
             if (c.type === `text` && c.text) return p + c.text;
             return p;
           }, "") ?? "");
-          if (text || reasoningPart.details?.length) {
-            parts.push({
+          if (text || part.details?.length) {
+            const v5UIPart = {
               type: "reasoning",
               text: text || "",
-              state: "done",
-              ...part.providerMetadata && { providerMetadata: part.providerMetadata }
-            });
+              state: "done"
+            };
+            if (part.providerMetadata) {
+              v5UIPart.providerMetadata = part.providerMetadata;
+            }
+            parts.push(v5UIPart);
           }
           continue;
         }
@@ -2471,12 +2750,15 @@ var MessageList = class _MessageList {
           }
           const categorized = typeof part.data === "string" ? categorizeFileData(part.data, part.mimeType) : { type: "raw", mimeType: part.mimeType};
           if (categorized.type === "url" && typeof part.data === "string") {
-            parts.push({
+            const v5UIPart = {
               type: "file",
               url: part.data,
-              mediaType: categorized.mimeType || "image/png",
-              providerMetadata: part.providerMetadata
-            });
+              mediaType: categorized.mimeType || "image/png"
+            };
+            if (part.providerMetadata) {
+              v5UIPart.providerMetadata = part.providerMetadata;
+            }
+            parts.push(v5UIPart);
           } else {
             let filePartData;
             let extractedMimeType = part.mimeType;
@@ -2500,27 +2782,37 @@ var MessageList = class _MessageList {
             } else {
               dataUri = createDataUri(filePartData, finalMimeType);
             }
-            parts.push({
+            const v5UIPart = {
               type: "file",
               url: dataUri,
               // Use url field with data URI
-              mediaType: finalMimeType,
-              providerMetadata: part.providerMetadata
-            });
+              mediaType: finalMimeType
+            };
+            if (part.providerMetadata) {
+              v5UIPart.providerMetadata = part.providerMetadata;
+            }
+            parts.push(v5UIPart);
           }
         } else if (part.type === "source") {
-          const sourcePart = part;
-          parts.push({
+          const v5UIPart = {
             type: "source-url",
-            url: sourcePart.source.url,
-            ...part.providerMetadata && { providerMetadata: part.providerMetadata }
-          });
+            url: part.source.url,
+            sourceId: part.source.id,
+            title: part.source.title
+          };
+          if (part.providerMetadata) {
+            v5UIPart.providerMetadata = part.providerMetadata;
+          }
+          parts.push(v5UIPart);
         } else if (part.type === "text") {
-          parts.push({
+          const v5UIPart = {
             type: "text",
-            text: part.text,
-            ...part.providerMetadata && { providerMetadata: part.providerMetadata }
-          });
+            text: part.text
+          };
+          if (part.providerMetadata) {
+            v5UIPart.providerMetadata = part.providerMetadata;
+          }
+          parts.push(v5UIPart);
           hasNonToolReasoningParts = true;
         } else {
           parts.push(part);
@@ -2684,32 +2976,69 @@ var MessageList = class _MessageList {
       }
     };
   }
+  /**
+   * Convert image or file to data URI or URL for V2 file part
+   */
+  static getDataStringFromAIV5DataPart = (part) => {
+    let mimeType;
+    let data;
+    if ("data" in part) {
+      mimeType = part.mediaType || "application/octet-stream";
+      data = part.data;
+    } else if ("image" in part) {
+      mimeType = part.mediaType || "image/jpeg";
+      data = part.image;
+    } else {
+      throw new MastraError({
+        id: "MASTRA_AIV5_DATA_PART_INVALID",
+        domain: "AGENT" /* AGENT */,
+        category: "USER" /* USER */,
+        text: "Invalid AIV5 data part in getDataStringFromAIV5DataPart",
+        details: {
+          part
+        }
+      });
+    }
+    if (data instanceof URL) {
+      return data.toString();
+    } else {
+      if (data instanceof Buffer) {
+        const base64 = data.toString("base64");
+        return `data:${mimeType};base64,${base64}`;
+      } else if (typeof data === "string") {
+        return data.startsWith("data:") || data.startsWith("http") ? data : `data:${mimeType};base64,${data}`;
+      } else if (data instanceof Uint8Array) {
+        const base64 = Buffer.from(data).toString("base64");
+        return `data:${mimeType};base64,${base64}`;
+      } else if (data instanceof ArrayBuffer) {
+        const base64 = Buffer.from(data).toString("base64");
+        return `data:${mimeType};base64,${base64}`;
+      } else {
+        return "";
+      }
+    }
+  };
   /**
    * Direct conversion from AIV5 ModelMessage to MastraDBMessage
    * Combines logic from aiV5ModelMessageToMastraMessageV3 + mastraMessageV3ToV2
    */
   static aiV5ModelMessageToMastraDBMessage(modelMsg, _messageSource) {
     const content = Array.isArray(modelMsg.content) ? modelMsg.content : [{ type: "text", text: modelMsg.content }];
-    const v2Parts = [];
+    const mastraDBParts = [];
     const toolInvocations = [];
     const reasoningParts = [];
     const experimental_attachments = [];
-    const textParts = [];
     let lastPartWasToolResult = false;
     for (const part of content) {
-      const providerMetadata = {
-        ...modelMsg.providerMetadata || {},
-        ...part.providerMetadata || {}
-      };
-      const hasProviderMetadata = Object.keys(providerMetadata).length > 0;
       if (part.type === "text") {
         const textPart = {
           type: "text",
-          text: part.text,
-          ...hasProviderMetadata && { experimental_providerMetadata: providerMetadata }
+          text: part.text
         };
-        v2Parts.push(textPart);
-        textParts.push({ text: part.text, providerMetadata: hasProviderMetadata ? providerMetadata : void 0 });
+        if (part.providerOptions) {
+          textPart.providerMetadata = part.providerOptions;
+        }
+        mastraDBParts.push(textPart);
         lastPartWasToolResult = false;
       } else if (part.type === "tool-call") {
         const toolCallPart = part;
@@ -2720,10 +3049,12 @@ var MessageList = class _MessageList {
             toolName: toolCallPart.toolName,
             args: toolCallPart.input,
             state: "call"
-          },
-          ...hasProviderMetadata && { providerMetadata }
+          }
         };
-        v2Parts.push(toolInvocationPart);
+        if (part.providerOptions) {
+          toolInvocationPart.providerMetadata = part.providerOptions;
+        }
+        mastraDBParts.push(toolInvocationPart);
         toolInvocations.push({
           toolCallId: toolCallPart.toolCallId,
           toolName: toolCallPart.toolName,
@@ -2734,78 +3065,67 @@ var MessageList = class _MessageList {
       } else if (part.type === "tool-result") {
         const toolResultPart = part;
         const matchingCall = toolInvocations.find((inv) => inv.toolCallId === toolResultPart.toolCallId);
-        const matchingV2Part = v2Parts.find(
+        const matchingV2Part = mastraDBParts.find(
           (p) => p.type === "tool-invocation" && "toolInvocation" in p && p.toolInvocation.toolCallId === toolResultPart.toolCallId
         );
+        const updateMatchingCallInvocationResult = (toolResultPart2, matchingCall2) => {
+          matchingCall2.state = "result";
+          matchingCall2.result = typeof toolResultPart2.output === "object" && toolResultPart2.output && "value" in toolResultPart2.output ? toolResultPart2.output.value : toolResultPart2.output;
+        };
         if (matchingCall) {
-          matchingCall.state = "result";
-          matchingCall.result = typeof toolResultPart.output === "object" && toolResultPart.output && "value" in toolResultPart.output ? toolResultPart.output.value : toolResultPart.output;
+          updateMatchingCallInvocationResult(toolResultPart, matchingCall);
         } else {
-          const resultPartWithName = toolResultPart;
-          toolInvocations.push({
+          const call = {
+            state: "call",
             toolCallId: toolResultPart.toolCallId,
-            toolName: resultPartWithName.toolName || "unknown",
-            args: {},
-            result: typeof toolResultPart.output === "object" && toolResultPart.output && "value" in toolResultPart.output ? toolResultPart.output.value : toolResultPart.output,
-            state: "result"
-          });
+            toolName: toolResultPart.toolName || "unknown",
+            args: {}
+          };
+          updateMatchingCallInvocationResult(toolResultPart, call);
+          toolInvocations.push(call);
         }
         if (matchingV2Part && matchingV2Part.type === "tool-invocation") {
-          matchingV2Part.toolInvocation.state = "result";
-          matchingV2Part.toolInvocation.result = typeof toolResultPart.output === "object" && toolResultPart.output && "value" in toolResultPart.output ? toolResultPart.output.value : toolResultPart.output;
-          if (hasProviderMetadata) {
-            matchingV2Part.providerMetadata = providerMetadata;
-          }
+          updateMatchingCallInvocationResult(toolResultPart, matchingV2Part.toolInvocation);
         } else {
-          const resultPartWithName = toolResultPart;
           const toolInvocationPart = {
             type: "tool-invocation",
             toolInvocation: {
               toolCallId: toolResultPart.toolCallId,
-              toolName: resultPartWithName.toolName || "unknown",
+              toolName: toolResultPart.toolName || "unknown",
               args: {},
-              result: typeof toolResultPart.output === "object" && toolResultPart.output && "value" in toolResultPart.output ? toolResultPart.output.value : toolResultPart.output,
-              state: "result"
-            },
-            ...hasProviderMetadata && { providerMetadata }
+              state: "call"
+            }
           };
-          v2Parts.push(toolInvocationPart);
+          updateMatchingCallInvocationResult(toolResultPart, toolInvocationPart.toolInvocation);
+          mastraDBParts.push(toolInvocationPart);
         }
         lastPartWasToolResult = true;
       } else if (part.type === "reasoning") {
-        const reasoningPart = part;
         const v2ReasoningPart = {
           type: "reasoning",
-          reasoning: reasoningPart.text,
-          details: [{ type: "text", text: reasoningPart.text }],
-          ...hasProviderMetadata && { providerMetadata }
+          reasoning: "",
+          // leave this blank so we aren't double storing it in the db along with details
+          details: [{ type: "text", text: part.text }]
         };
-        v2Parts.push(v2ReasoningPart);
-        reasoningParts.push(reasoningPart.text);
+        if (part.providerOptions) {
+          v2ReasoningPart.providerMetadata = part.providerOptions;
+        }
+        mastraDBParts.push(v2ReasoningPart);
+        reasoningParts.push(part.text);
         lastPartWasToolResult = false;
       } else if (part.type === "image") {
         const imagePart = part;
-        let imageData;
-        const mimeType = imagePart.mimeType || "image/jpeg";
-        if ("url" in imagePart && typeof imagePart.url === "string") {
-          imageData = imagePart.url;
-        } else if ("data" in imagePart) {
-          if (typeof imagePart.data === "string") {
-            imageData = imagePart.data.startsWith("data:") || imagePart.data.startsWith("http") ? imagePart.data : `data:${mimeType};base64,${imagePart.data}`;
-          } else {
-            const base64 = Buffer.from(imagePart.data).toString("base64");
-            imageData = `data:${mimeType};base64,${base64}`;
-          }
-        } else {
-          imageData = "";
-        }
+        const mimeType = imagePart.mediaType || "image/jpeg";
+        const imageData = this.getDataStringFromAIV5DataPart(imagePart);
         const imageFilePart = {
           type: "file",
           data: imageData,
-          mimeType,
-          ...hasProviderMetadata && { providerMetadata }
+          mimeType
         };
-        v2Parts.push(imageFilePart);
+        if (part.providerOptions) {
+          imageFilePart.providerMetadata = part.providerOptions;
+        }
+        mastraDBParts.push(imageFilePart);
         experimental_attachments.push({
           url: imageData,
           contentType: mimeType
@@ -2814,26 +3134,16 @@ var MessageList = class _MessageList {
       } else if (part.type === "file") {
         const filePart = part;
         const mimeType = filePart.mediaType || "application/octet-stream";
-        let fileData;
-        if ("url" in filePart && typeof filePart.url === "string") {
-          fileData = filePart.url;
-        } else if ("data" in filePart) {
-          if (typeof filePart.data === "string") {
-            fileData = filePart.data.startsWith("data:") || filePart.data.startsWith("http") ? filePart.data : `data:${mimeType};base64,${filePart.data}`;
-          } else {
-            const base64 = Buffer.from(filePart.data).toString("base64");
-            fileData = `data:${mimeType};base64,${base64}`;
-          }
-        } else {
-          fileData = "";
-        }
+        const fileData = this.getDataStringFromAIV5DataPart(filePart);
         const v2FilePart = {
           type: "file",
           data: fileData,
-          mimeType,
-          ...hasProviderMetadata && { providerMetadata }
+          mimeType
         };
-        v2Parts.push(v2FilePart);
+        if (part.providerOptions) {
+          v2FilePart.providerMetadata = part.providerOptions;
+        }
+        mastraDBParts.push(v2FilePart);
         experimental_attachments.push({
           url: fileData,
           contentType: mimeType
@@ -2841,34 +3151,34 @@ var MessageList = class _MessageList {
         lastPartWasToolResult = false;
       }
     }
-    if (modelMsg.role === "assistant" && lastPartWasToolResult && v2Parts.length > 0) {
-      const lastPart = v2Parts[v2Parts.length - 1];
+    if (modelMsg.role === "assistant" && lastPartWasToolResult && mastraDBParts.length > 0) {
+      const lastPart = mastraDBParts[mastraDBParts.length - 1];
       if (lastPart && lastPart.type !== "text") {
         const emptyTextPart = { type: "text", text: "" };
-        v2Parts.push(emptyTextPart);
-        textParts.push({ text: "" });
+        mastraDBParts.push(emptyTextPart);
       }
     }
-    let contentString = void 0;
-    if (textParts.length > 0) {
-      contentString = textParts.map((p) => p.text).join("\n");
-    }
-    const metadata = {};
+    const contentString = mastraDBParts.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+    const metadata = "metadata" in modelMsg && modelMsg.metadata !== null && modelMsg.metadata !== void 0 ? modelMsg.metadata : {};
     const id = `id` in modelMsg && typeof modelMsg.id === `string` ? modelMsg.id : `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    return {
+    const message = {
       id,
       role: _MessageList.getRole(modelMsg),
       createdAt: /* @__PURE__ */ new Date(),
       content: {
         format: 2,
-        parts: v2Parts,
+        parts: mastraDBParts,
         toolInvocations: toolInvocations.length > 0 ? toolInvocations : void 0,
         reasoning: reasoningParts.length > 0 ? reasoningParts.join("\n") : void 0,
         experimental_attachments: experimental_attachments.length > 0 ? experimental_attachments : void 0,
-        content: contentString,
-        metadata
+        content: contentString || void 0,
+        metadata: Object.keys(metadata).length > 0 ? metadata : void 0
       }
     };
+    if (modelMsg.providerOptions) {
+      message.content.providerMetadata = modelMsg.providerOptions;
+    }
+    return message;
   }
   aiV4CoreMessagesToAIV5ModelMessages(messages, source) {
     return this.aiV5UIMessagesToAIV5ModelMessages(
@@ -2879,14 +3189,24 @@ var MessageList = class _MessageList {
     const sanitized = this.sanitizeV5UIMessages(messages, filterIncompleteToolCalls);
     const preprocessed = this.addStartStepPartsForAIV5(sanitized);
     const result = AIV5.convertToModelMessages(preprocessed);
-    return result;
+    return result.map((modelMsg, index) => {
+      const uiMsg = preprocessed[index];
+      if (uiMsg?.metadata && typeof uiMsg.metadata === "object" && "providerMetadata" in uiMsg.metadata && uiMsg.metadata.providerMetadata) {
+        return {
+          ...modelMsg,
+          providerOptions: uiMsg.metadata.providerMetadata
+        };
+      }
+      return modelMsg;
+    });
   }
   addStartStepPartsForAIV5(messages) {
     for (const message of messages) {
       if (message.role !== `assistant`) continue;
       for (const [index, part] of message.parts.entries()) {
         if (!AIV5.isToolUIPart(part)) continue;
-        if (message.parts.at(index + 1)?.type !== `step-start`) {
+        const nextPart = message.parts.at(index + 1);
+        if (nextPart && nextPart.type !== `step-start` && !AIV5.isToolUIPart(nextPart)) {
           message.parts.splice(index + 1, 0, { type: "step-start" });
         }
       }
@@ -3012,5 +3332,5 @@ var MessageList = class _MessageList {
 };
 
 export { DefaultGeneratedFile, DefaultGeneratedFileWithType, MessageList, convertMessages };
-//# sourceMappingURL=chunk-JV2KH24V.js.map
-//# sourceMappingURL=chunk-JV2KH24V.js.map
+//# sourceMappingURL=chunk-SXNQRJQD.js.map
+//# sourceMappingURL=chunk-SXNQRJQD.js.map