@mastra/core 0.13.2 → 0.14.0-alpha.1

package/dist/{chunk-L6YBPFYF.js → chunk-OPT2L5AM.js}

@@ -1,10 +1,42 @@
-import { isUiMessage, isCoreMessage } from './chunk-N2KMAW6T.js';
 import { MastraError } from './chunk-4O4YNORN.js';
 import { randomUUID } from 'crypto';
-import { convertToCoreMessages } from 'ai';
-import { convertUint8ArrayToBase64 } from '@ai-sdk/provider-utils';
+import * as AIV4 from 'ai';
+import * as AIV5 from 'ai-v5';
+import { convertUint8ArrayToBase64, convertBase64ToUint8Array } from '@ai-sdk/provider-utils';
 import { z } from 'zod';
 
+var DefaultGeneratedFile = class {
+  base64Data;
+  uint8ArrayData;
+  mediaType;
+  constructor({ data, mediaType }) {
+    const isUint8Array = data instanceof Uint8Array;
+    this.base64Data = isUint8Array ? void 0 : data;
+    this.uint8ArrayData = isUint8Array ? data : void 0;
+    this.mediaType = mediaType;
+  }
+  // lazy conversion with caching to avoid unnecessary conversion overhead:
+  get base64() {
+    if (this.base64Data == null) {
+      this.base64Data = convertUint8ArrayToBase64(this.uint8ArrayData);
+    }
+    return this.base64Data;
+  }
+  // lazy conversion with caching to avoid unnecessary conversion overhead:
+  get uint8Array() {
+    if (this.uint8ArrayData == null) {
+      this.uint8ArrayData = convertBase64ToUint8Array(this.base64Data);
+    }
+    return this.uint8ArrayData;
+  }
+};
+var DefaultGeneratedFileWithType = class extends DefaultGeneratedFile {
+  type = "file";
+  constructor(options) {
+    super(options);
+  }
+};
+
 // src/agent/message-list/prompt/attachments-to-parts.ts
 function attachmentsToParts(attachments) {
   const parts = [];
@@ -383,6 +415,23 @@ function convertDataContentToBase64String(content) {
   return convertUint8ArrayToBase64(content);
 }
 
+// src/agent/message-list/utils/ai-v5/tool.ts
+function getToolName(type) {
+  if (typeof type === "object" && type && "type" in type) {
+    type = type.type;
+  }
+  if (typeof type !== "string") {
+    return "unknown";
+  }
+  if (type === "dynamic-tool") {
+    return "dynamic-tool";
+  }
+  if (type.startsWith("tool-")) {
+    return type.slice("tool-".length);
+  }
+  return type;
+}
+
 // src/agent/message-list/index.ts
 var MessageList = class _MessageList {
   messages = [];
@@ -416,6 +465,7 @@ var MessageList = class _MessageList {
     this._agentNetworkAppend = _agentNetworkAppend || false;
   }
   add(messages, messageSource) {
+    if (messageSource === `user`) messageSource = `input`;
     if (!messages) return this;
     for (const message of Array.isArray(messages) ? messages : [messages]) {
       this.addOne(
@@ -459,58 +509,216 @@ var MessageList = class _MessageList {
           this.newUserMessages.clear();
           return userMessages;
         }
+      },
+      response: {
+        v2: () => {
+          const responseMessages = Array.from(this.newResponseMessages);
+          this.messages = this.messages.filter((m) => !this.newResponseMessages.has(m));
+          this.newResponseMessages.clear();
+          return responseMessages;
+        }
       }
     };
   }
   all = {
+    v3: () => this.cleanV3Metadata(this.messages.map(this.mastraMessageV2ToMastraMessageV3)),
     v2: () => this.messages,
-    v1: () => convertToV1Messages(this.messages),
-    ui: () => this.messages.map(_MessageList.toUIMessage),
-    core: () => this.convertToCoreMessages(this.all.ui()),
-    prompt: () => {
-      const coreMessages = this.all.core();
-      const messages = [...this.systemMessages, ...Object.values(this.taggedSystemMessages).flat(), ...coreMessages];
-      const needsDefaultUserMessage = !messages.length || messages[0]?.role === "assistant";
-      if (needsDefaultUserMessage) {
-        const defaultMessage = {
-          role: "user",
-          content: "."
-        };
-        messages.unshift(defaultMessage);
+    v1: () => convertToV1Messages(this.all.v2()),
+    aiV5: {
+      model: () => this.aiV5UIMessagesToAIV5ModelMessages(this.all.aiV5.ui()),
+      ui: () => this.all.v3().map(_MessageList.mastraMessageV3ToAIV5UIMessage),
+      // Used when calling AI SDK streamText/generateText
+      prompt: () => {
+        const messages = [
+          ...this.aiV4CoreMessagesToAIV5ModelMessages(
+            [...this.systemMessages, ...Object.values(this.taggedSystemMessages).flat()],
+            `system`
+          ),
+          ...this.all.aiV5.model()
+        ];
+        const needsDefaultUserMessage = !messages.length || messages[0]?.role === "assistant";
+        if (needsDefaultUserMessage) {
+          const defaultMessage = {
+            role: "user",
+            content: " "
+          };
+          messages.unshift(defaultMessage);
+        }
+        return messages;
+      },
+      // Used for creating LLM prompt messages without AI SDK streamText/generateText
+      llmPrompt: () => {
+        const modelMessages = this.all.aiV5.model();
+        const systemMessages = this.aiV4CoreMessagesToAIV5ModelMessages(
+          [...this.systemMessages, ...Object.values(this.taggedSystemMessages).flat()],
+          `system`
+        );
+        const messages = [...systemMessages, ...modelMessages];
+        const needsDefaultUserMessage = !messages.length || messages[0]?.role === "assistant";
+        if (needsDefaultUserMessage) {
+          const defaultMessage = {
+            role: "user",
+            content: " "
+          };
+          messages.unshift(defaultMessage);
+        }
+        return messages.map(_MessageList.aiV5ModelMessageToV2PromptMessage);
+      }
+    },
+    /* @deprecated use list.get.all.aiV4.prompt() instead */
+    prompt: () => this.all.aiV4.prompt(),
+    /* @deprecated use list.get.all.aiV4.ui() */
+    ui: () => this.all.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+    /* @deprecated use list.get.all.aiV4.core() */
+    core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.all.aiV4.ui()),
+    aiV4: {
+      ui: () => this.all.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+      core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.all.aiV4.ui()),
+      // Used when calling AI SDK streamText/generateText
+      prompt: () => {
+        const coreMessages = this.all.aiV4.core();
+        const messages = [...this.systemMessages, ...Object.values(this.taggedSystemMessages).flat(), ...coreMessages];
+        const needsDefaultUserMessage = !messages.length || messages[0]?.role === "assistant";
+        if (needsDefaultUserMessage) {
+          const defaultMessage = {
+            role: "user",
+            content: " "
+          };
+          messages.unshift(defaultMessage);
+        }
+        return messages;
+      },
+      // Used for creating LLM prompt messages without AI SDK streamText/generateText
+      llmPrompt: () => {
+        const coreMessages = this.all.aiV4.core();
+        const systemMessages = [...this.systemMessages, ...Object.values(this.taggedSystemMessages).flat()];
+        const messages = [...systemMessages, ...coreMessages];
+        const needsDefaultUserMessage = !messages.length || messages[0]?.role === "assistant";
+        if (needsDefaultUserMessage) {
+          const defaultMessage = {
+            role: "user",
+            content: " "
+          };
+          messages.unshift(defaultMessage);
+        }
+        return messages.map(_MessageList.aiV4CoreMessageToV1PromptMessage);
       }
-      return messages;
     }
   };
   remembered = {
+    v3: () => this.remembered.v2().map(this.mastraMessageV2ToMastraMessageV3),
     v2: () => this.messages.filter((m) => this.memoryMessages.has(m)),
     v1: () => convertToV1Messages(this.remembered.v2()),
-    ui: () => this.remembered.v2().map(_MessageList.toUIMessage),
-    core: () => this.convertToCoreMessages(this.remembered.ui())
+    aiV5: {
+      model: () => this.aiV5UIMessagesToAIV5ModelMessages(this.remembered.aiV5.ui()),
+      ui: () => this.remembered.v3().map(_MessageList.mastraMessageV3ToAIV5UIMessage)
+    },
+    /* @deprecated use list.get.remembered.aiV4.ui() */
+    ui: () => this.remembered.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+    /* @deprecated use list.get.remembered.aiV4.core() */
+    core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.all.aiV4.ui()),
+    aiV4: {
+      ui: () => this.remembered.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+      core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.all.aiV4.ui())
+    }
   };
+  // TODO: need to update this for new .aiV4/5.x() pattern
   rememberedPersisted = {
-    v2: () => this.messages.filter((m) => this.memoryMessagesPersisted.has(m)),
+    v2: () => this.all.v2().filter((m) => this.memoryMessagesPersisted.has(m)),
     v1: () => convertToV1Messages(this.rememberedPersisted.v2()),
-    ui: () => this.rememberedPersisted.v2().map(_MessageList.toUIMessage),
-    core: () => this.convertToCoreMessages(this.rememberedPersisted.ui())
+    ui: () => this.rememberedPersisted.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+    core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.rememberedPersisted.ui())
   };
   input = {
+    v3: () => this.cleanV3Metadata(
+      this.messages.filter((m) => this.newUserMessages.has(m)).map(this.mastraMessageV2ToMastraMessageV3)
+    ),
     v2: () => this.messages.filter((m) => this.newUserMessages.has(m)),
     v1: () => convertToV1Messages(this.input.v2()),
-    ui: () => this.input.v2().map(_MessageList.toUIMessage),
-    core: () => this.convertToCoreMessages(this.input.ui())
+    aiV5: {
+      model: () => this.aiV5UIMessagesToAIV5ModelMessages(this.input.aiV5.ui()),
+      ui: () => this.input.v3().map(_MessageList.mastraMessageV3ToAIV5UIMessage)
+    },
+    /* @deprecated use list.get.input.aiV4.ui() instead */
+    ui: () => this.input.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+    /* @deprecated use list.get.core.aiV4.ui() instead */
+    core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.input.ui()),
+    aiV4: {
+      ui: () => this.input.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+      core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.input.aiV4.ui())
+    }
   };
+  // TODO: need to update this for new .aiV4/5.x() pattern
   inputPersisted = {
+    v3: () => this.cleanV3Metadata(
+      this.messages.filter((m) => this.newUserMessagesPersisted.has(m)).map(this.mastraMessageV2ToMastraMessageV3)
+    ),
     v2: () => this.messages.filter((m) => this.newUserMessagesPersisted.has(m)),
     v1: () => convertToV1Messages(this.inputPersisted.v2()),
-    ui: () => this.inputPersisted.v2().map(_MessageList.toUIMessage),
-    core: () => this.convertToCoreMessages(this.inputPersisted.ui())
+    ui: () => this.inputPersisted.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+    core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.inputPersisted.ui())
   };
   response = {
-    v2: () => this.messages.filter((m) => this.newResponseMessages.has(m))
+    v3: () => this.response.v2().map(this.mastraMessageV2ToMastraMessageV3),
+    v2: () => this.messages.filter((m) => this.newResponseMessages.has(m)),
+    v1: () => convertToV1Messages(this.response.v3().map(_MessageList.mastraMessageV3ToV2)),
+    aiV5: {
+      ui: () => this.response.v3().map(_MessageList.mastraMessageV3ToAIV5UIMessage),
+      model: () => this.aiV5UIMessagesToAIV5ModelMessages(this.response.aiV5.ui()).filter(
+        (m) => m.role === `tool` || m.role === `assistant`
+      ),
+      modelContent: () => {
+        return this.response.aiV5.model().map(this.response.aiV5.stepContent).flat();
+      },
+      stepContent: (message) => {
+        const latest = message ? message : this.response.aiV5.model().at(-1);
+        if (!latest) return [];
+        if (typeof latest.content === `string`) {
+          return [{ type: "text", text: latest.content }];
+        }
+        return latest.content.map((c) => {
+          if (c.type === `tool-result`)
+            return {
+              type: "tool-result",
+              input: {},
+              // TODO: we need to find the tool call here and add the input from it
+              output: c.output,
+              toolCallId: c.toolCallId,
+              toolName: c.toolName
+            };
+          if (c.type === `file`)
+            return {
+              type: "file",
+              file: new DefaultGeneratedFileWithType({
+                data: typeof c.data === `string` ? c.data : c.data instanceof URL ? c.data.toString() : convertDataContentToBase64String(c.data),
+                mediaType: c.mediaType
+              })
+            };
+          if (c.type === `image`) {
+            return {
+              type: "file",
+              file: new DefaultGeneratedFileWithType({
+                data: typeof c.image === `string` ? c.image : c.image instanceof URL ? c.image.toString() : convertDataContentToBase64String(c.image),
+                mediaType: c.mediaType || "unknown"
+              })
+            };
+          }
+          return c;
+        });
+      }
+    },
+    aiV4: {
+      ui: () => this.response.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+      core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.response.aiV4.ui())
+    }
   };
+  // TODO: need to update this for new .aiV4/5.x() pattern
   responsePersisted = {
+    v3: () => this.cleanV3Metadata(
+      this.messages.filter((m) => this.newResponseMessagesPersisted.has(m)).map(this.mastraMessageV2ToMastraMessageV3)
+    ),
     v2: () => this.messages.filter((m) => this.newResponseMessagesPersisted.has(m)),
-    ui: () => this.responsePersisted.v2().map(_MessageList.toUIMessage)
+    ui: () => this.responsePersisted.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage)
   };
   drainUnsavedMessages() {
     const messages = this.messages.filter((m) => this.newUserMessages.has(m) || this.newResponseMessages.has(m));
@@ -536,10 +744,10 @@ var MessageList = class _MessageList {
     }
     return this;
   }
-  convertToCoreMessages(messages) {
-    return convertToCoreMessages(this.sanitizeUIMessages(messages));
+  aiV4UIMessagesToAIV4CoreMessages(messages) {
+    return AIV4.convertToCoreMessages(this.sanitizeAIV4UIMessages(messages));
   }
-  sanitizeUIMessages(messages) {
+  sanitizeAIV4UIMessages(messages) {
     const msgs = messages.map((m) => {
       if (m.parts.length === 0) return false;
       const safeParts = m.parts.filter(
@@ -561,25 +769,31 @@ var MessageList = class _MessageList {
   }
   addOneSystem(message, tag) {
     if (typeof message === `string`) message = { role: "system", content: message };
-    if (tag && !this.isDuplicateSystem(message, tag)) {
+    const coreMessage = _MessageList.isAIV4CoreMessage(message) ? message : this.aiV5ModelMessagesToAIV4CoreMessages([message], `system`)[0];
+    if (coreMessage.role !== `system`) {
+      throw new Error(
+        `Expected role "system" but saw ${coreMessage.role} for message ${JSON.stringify(coreMessage, null, 2)}`
+      );
+    }
+    if (tag && !this.isDuplicateSystem(coreMessage, tag)) {
       this.taggedSystemMessages[tag] ||= [];
-      this.taggedSystemMessages[tag].push(message);
-    } else if (!this.isDuplicateSystem(message)) {
-      this.systemMessages.push(message);
+      this.taggedSystemMessages[tag].push(coreMessage);
+    } else if (!this.isDuplicateSystem(coreMessage)) {
+      this.systemMessages.push(coreMessage);
     }
   }
   isDuplicateSystem(message, tag) {
     if (tag) {
       if (!this.taggedSystemMessages[tag]) return false;
       return this.taggedSystemMessages[tag].some(
-        (m) => _MessageList.cacheKeyFromContent(m.content) === _MessageList.cacheKeyFromContent(message.content)
+        (m) => _MessageList.cacheKeyFromAIV4CoreMessageContent(m.content) === _MessageList.cacheKeyFromAIV4CoreMessageContent(message.content)
       );
     }
     return this.systemMessages.some(
-      (m) => _MessageList.cacheKeyFromContent(m.content) === _MessageList.cacheKeyFromContent(message.content)
+      (m) => _MessageList.cacheKeyFromAIV4CoreMessageContent(m.content) === _MessageList.cacheKeyFromAIV4CoreMessageContent(message.content)
     );
   }
-  static toUIMessage(m) {
+  static mastraMessageV2ToAIV4UIMessage(m) {
     const experimentalAttachments = m.content.experimental_attachments ? [...m.content.experimental_attachments] : [];
     const contentString = typeof m.content.content === `string` && m.content.content !== "" ? m.content.content : m.content.parts.reduce((prev, part) => {
       if (part.type === `text`) {
@@ -597,6 +811,32 @@ var MessageList = class _MessageList {
           });
         } else if (part.type === "tool-invocation" && (part.toolInvocation.state === "call" || part.toolInvocation.state === "partial-call")) {
           continue;
+        } else if (part.type === "tool-invocation") {
+          const toolInvocation = { ...part.toolInvocation };
+          let currentStep = -1;
+          let toolStep = -1;
+          for (const innerPart of m.content.parts) {
+            if (innerPart.type === `step-start`) currentStep++;
+            if (innerPart.type === `tool-invocation` && innerPart.toolInvocation.toolCallId === part.toolInvocation.toolCallId) {
+              toolStep = currentStep;
+              break;
+            }
+          }
+          if (toolStep >= 0) {
+            const preparedInvocation = {
+              step: toolStep,
+              ...toolInvocation
+            };
+            parts.push({
+              type: "tool-invocation",
+              toolInvocation: preparedInvocation
+            });
+          } else {
+            parts.push({
+              type: "tool-invocation",
+              toolInvocation
+            });
+          }
         } else {
           parts.push(part);
         }
@@ -678,8 +918,10 @@ var MessageList = class _MessageList {
         }
       });
     }
-    if (message.role === `system` && _MessageList.isVercelCoreMessage(message)) return this.addSystem(message);
     if (message.role === `system`) {
+      if (messageSource === `memory`) return null;
+      if (_MessageList.isAIV4CoreMessage(message) || _MessageList.isAIV5CoreMessage(message))
+        return this.addSystem(message);
       throw new MastraError({
         id: "INVALID_SYSTEM_MESSAGE_FORMAT",
         domain: "AGENT" /* AGENT */,
@@ -784,7 +1026,7 @@ var MessageList = class _MessageList {
     } else if (messageSource === `response`) {
       this.newResponseMessages.add(messageV2);
       this.newResponseMessagesPersisted.add(messageV2);
-    } else if (messageSource === `user`) {
+    } else if (messageSource === `input`) {
       this.newUserMessages.add(messageV2);
       this.newUserMessagesPersisted.add(messageV2);
     } else if (messageSource === `context`) {
@@ -808,11 +1050,13 @@ var MessageList = class _MessageList {
     insertAt
     // optional
   }) {
-    const partKey = _MessageList.cacheKeyFromParts([part]);
+    const partKey = _MessageList.cacheKeyFromAIV4Parts([part]);
     const latestPartCount = latestMessage.content.parts.filter(
-      (p) => _MessageList.cacheKeyFromParts([p]) === partKey
+      (p) => _MessageList.cacheKeyFromAIV4Parts([p]) === partKey
+    ).length;
+    const newPartCount = newMessage.content.parts.filter(
+      (p) => _MessageList.cacheKeyFromAIV4Parts([p]) === partKey
     ).length;
-    const newPartCount = newMessage.content.parts.filter((p) => _MessageList.cacheKeyFromParts([p]) === partKey).length;
     if (latestPartCount < newPartCount) {
       if (typeof insertAt === "number") {
         latestMessage.content.parts.splice(insertAt, 0, part);
@@ -837,7 +1081,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.cacheKeyFromParts([part]);
+      const key = _MessageList.cacheKeyFromAIV4Parts([part]);
       const partToAdd = partsToAdd.get(i);
       if (!key || !partToAdd) continue;
       if (anchorMap.size > 0) {
@@ -848,7 +1092,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.cacheKeyFromParts([p]) === _MessageList.cacheKeyFromParts([part]))) {
+        if (insertAt >= 0 && insertAt <= rightAnchorLatest && !latestMessage.content.parts.slice(insertAt, rightAnchorLatest).some((p) => _MessageList.cacheKeyFromAIV4Parts([p]) === _MessageList.cacheKeyFromAIV4Parts([part]))) {
           this.pushNewMessagePart({
             latestMessage,
             newMessage: messageV2,
@@ -891,11 +1135,20 @@ var MessageList = class _MessageList {
     if (_MessageList.isMastraMessageV2(message)) {
       return this.hydrateMastraMessageV2Fields(message);
     }
-    if (_MessageList.isVercelCoreMessage(message)) {
-      return this.vercelCoreMessageToMastraMessageV2(message, messageSource);
+    if (_MessageList.isAIV4CoreMessage(message)) {
+      return this.aiV4CoreMessageToMastraMessageV2(message, messageSource);
+    }
+    if (_MessageList.isAIV4UIMessage(message)) {
+      return this.aiV4UIMessageToMastraMessageV2(message, messageSource);
+    }
+    if (_MessageList.isAIV5CoreMessage(message)) {
+      return _MessageList.mastraMessageV3ToV2(this.aiV5ModelMessageToMastraMessageV3(message, messageSource));
     }
-    if (_MessageList.isVercelUIMessage(message)) {
-      return this.vercelUIMessageToMastraMessageV2(message, messageSource);
+    if (_MessageList.isAIV5UIMessage(message)) {
+      return _MessageList.mastraMessageV3ToV2(this.aiV5UIMessageToMastraMessageV3(message, messageSource));
+    }
+    if (_MessageList.isMastraMessageV3(message)) {
+      return _MessageList.mastraMessageV3ToV2(this.hydrateMastraMessageV3Fields(message));
     }
     throw new Error(`Found unhandled message ${JSON.stringify(message)}`);
   }
@@ -931,7 +1184,7 @@ var MessageList = class _MessageList {
     return randomUUID();
   }
   mastraMessageV1ToMastraMessageV2(message, messageSource) {
-    const coreV2 = this.vercelCoreMessageToMastraMessageV2(
+    const coreV2 = this.aiV4CoreMessageToMastraMessageV2(
       {
         content: message.content,
         role: message.role
@@ -947,6 +1200,10 @@ var MessageList = class _MessageList {
       content: coreV2.content
     };
   }
+  hydrateMastraMessageV3Fields(message) {
+    if (!(message.createdAt instanceof Date)) message.createdAt = new Date(message.createdAt);
+    return message;
+  }
   hydrateMastraMessageV2Fields(message) {
     if (!(message.createdAt instanceof Date)) message.createdAt = new Date(message.createdAt);
     if (message.content.toolInvocations && message.content.parts) {
@@ -964,7 +1221,7 @@ var MessageList = class _MessageList {
     }
     return message;
   }
-  vercelUIMessageToMastraMessageV2(message, messageSource) {
+  aiV4UIMessageToMastraMessageV2(message, messageSource) {
     const content = {
       format: 2,
       parts: message.parts
@@ -987,7 +1244,7 @@ var MessageList = class _MessageList {
       content
     };
   }
-  vercelCoreMessageToMastraMessageV2(coreMessage, messageSource) {
+  aiV4CoreMessageToMastraMessageV2(coreMessage, messageSource) {
     const id = `id` in coreMessage ? coreMessage.id : this.newMessageId();
     const parts = [];
     const experimentalAttachments = [];
@@ -1112,44 +1369,52 @@ var MessageList = class _MessageList {
       content
     };
   }
-  static isVercelUIMessage(msg) {
-    return !_MessageList.isMastraMessage(msg) && isUiMessage(msg);
+  static isAIV4UIMessage(msg) {
+    return !_MessageList.isMastraMessage(msg) && !_MessageList.isAIV4CoreMessage(msg) && `parts` in msg && !_MessageList.hasAIV5UIMessageCharacteristics(msg);
+  }
+  static isAIV5CoreMessage(msg) {
+    return !_MessageList.isMastraMessage(msg) && !(`parts` in msg) && `content` in msg && _MessageList.hasAIV5CoreMessageCharacteristics(msg);
   }
-  static isVercelCoreMessage(msg) {
-    return !_MessageList.isMastraMessage(msg) && isCoreMessage(msg);
+  static isAIV4CoreMessage(msg) {
+    return !_MessageList.isMastraMessage(msg) && !(`parts` in msg) && `content` in msg && !_MessageList.hasAIV5CoreMessageCharacteristics(msg);
   }
   static isMastraMessage(msg) {
-    return _MessageList.isMastraMessageV2(msg) || _MessageList.isMastraMessageV1(msg);
+    return _MessageList.isMastraMessageV3(msg) || _MessageList.isMastraMessageV2(msg) || _MessageList.isMastraMessageV1(msg);
   }
   static isMastraMessageV1(msg) {
-    return !_MessageList.isMastraMessageV2(msg) && (`threadId` in msg || `resourceId` in msg);
+    return !_MessageList.isMastraMessageV2(msg) && !_MessageList.isMastraMessageV3(msg) && (`threadId` in msg || `resourceId` in msg);
   }
   static isMastraMessageV2(msg) {
     return Boolean(
-      msg.content && !Array.isArray(msg.content) && typeof msg.content !== `string` && // any newly saved Mastra message v2 shape will have content: { format: 2 }
-      `format` in msg.content && msg.content.format === 2
+      `content` in msg && msg.content && !Array.isArray(msg.content) && typeof msg.content !== `string` && `format` in msg.content && msg.content.format === 2
+    );
+  }
+  static isMastraMessageV3(msg) {
+    return Boolean(
+      `content` in msg && msg.content && !Array.isArray(msg.content) && typeof msg.content !== `string` && `format` in msg.content && msg.content.format === 3
     );
   }
   static getRole(message) {
     if (message.role === `assistant` || message.role === `tool`) return `assistant`;
     if (message.role === `user`) return `user`;
+    if (message.role === `system`) return `system`;
     throw new Error(
       `BUG: add handling for message role ${message.role} in message ${JSON.stringify(message, null, 2)}`
     );
   }
-  static cacheKeyFromParts(parts) {
+  static cacheKeyFromAIV4Parts(parts) {
     let key = ``;
     for (const part of parts) {
       key += part.type;
       if (part.type === `text`) {
-        key += `${part.text.length}${part.text}`;
+        key += part.text;
       }
       if (part.type === `tool-invocation`) {
         key += part.toolInvocation.toolCallId;
         key += part.toolInvocation.state;
       }
       if (part.type === `reasoning`) {
-        key += part.reasoning.length;
+        key += part.reasoning;
         key += part.details.reduce((prev, current) => {
           if (current.type === `text`) {
             return prev + current.text.length + (current.signature?.length || 0);
@@ -1158,7 +1423,7 @@ var MessageList = class _MessageList {
         }, 0);
       }
       if (part.type === `file`) {
-        key += part.data.length;
+        key += part.data;
         key += part.mimeType;
       }
     }
@@ -1173,7 +1438,7 @@ var MessageList = class _MessageList {
       return p;
     }, "");
   }
-  static cacheKeyFromContent(content) {
+  static cacheKeyFromAIV4CoreMessageContent(content) {
     if (typeof content === `string`) return content;
     let key = ``;
     for (const part of content) {
@@ -1207,34 +1472,777 @@ var MessageList = class _MessageList {
     return key;
   }
   static messagesAreEqual(one, two) {
-    const oneUI = _MessageList.isVercelUIMessage(one) && one;
-    const twoUI = _MessageList.isVercelUIMessage(two) && two;
-    if (oneUI && !twoUI) return false;
-    if (oneUI && twoUI) {
-      return _MessageList.cacheKeyFromParts(one.parts) === _MessageList.cacheKeyFromParts(two.parts);
-    }
-    const oneCM = _MessageList.isVercelCoreMessage(one) && one;
-    const twoCM = _MessageList.isVercelCoreMessage(two) && two;
-    if (oneCM && !twoCM) return false;
-    if (oneCM && twoCM) {
-      return _MessageList.cacheKeyFromContent(oneCM.content) === _MessageList.cacheKeyFromContent(twoCM.content);
+    const oneUIV4 = _MessageList.isAIV4UIMessage(one) && one;
+    const twoUIV4 = _MessageList.isAIV4UIMessage(two) && two;
+    if (oneUIV4 && !twoUIV4) return false;
+    if (oneUIV4 && twoUIV4) {
+      return _MessageList.cacheKeyFromAIV4Parts(one.parts) === _MessageList.cacheKeyFromAIV4Parts(two.parts);
+    }
+    const oneCMV4 = _MessageList.isAIV4CoreMessage(one) && one;
+    const twoCMV4 = _MessageList.isAIV4CoreMessage(two) && two;
+    if (oneCMV4 && !twoCMV4) return false;
+    if (oneCMV4 && twoCMV4) {
+      return _MessageList.cacheKeyFromAIV4CoreMessageContent(oneCMV4.content) === _MessageList.cacheKeyFromAIV4CoreMessageContent(twoCMV4.content);
     }
     const oneMM1 = _MessageList.isMastraMessageV1(one) && one;
     const twoMM1 = _MessageList.isMastraMessageV1(two) && two;
     if (oneMM1 && !twoMM1) return false;
     if (oneMM1 && twoMM1) {
-      return oneMM1.id === twoMM1.id && _MessageList.cacheKeyFromContent(oneMM1.content) === _MessageList.cacheKeyFromContent(twoMM1.content);
+      return oneMM1.id === twoMM1.id && _MessageList.cacheKeyFromAIV4CoreMessageContent(oneMM1.content) === _MessageList.cacheKeyFromAIV4CoreMessageContent(twoMM1.content);
     }
     const oneMM2 = _MessageList.isMastraMessageV2(one) && one;
     const twoMM2 = _MessageList.isMastraMessageV2(two) && two;
     if (oneMM2 && !twoMM2) return false;
     if (oneMM2 && twoMM2) {
-      return oneMM2.id === twoMM2.id && _MessageList.cacheKeyFromParts(oneMM2.content.parts) === _MessageList.cacheKeyFromParts(twoMM2.content.parts);
+      return oneMM2.id === twoMM2.id && _MessageList.cacheKeyFromAIV4Parts(oneMM2.content.parts) === _MessageList.cacheKeyFromAIV4Parts(twoMM2.content.parts);
+    }
+    const oneMM3 = _MessageList.isMastraMessageV3(one) && one;
+    const twoMM3 = _MessageList.isMastraMessageV3(two) && two;
+    if (oneMM3 && !twoMM3) return false;
+    if (oneMM3 && twoMM3) {
+      return oneMM3.id === twoMM3.id && _MessageList.cacheKeyFromAIV5Parts(oneMM3.content.parts) === _MessageList.cacheKeyFromAIV5Parts(twoMM3.content.parts);
+    }
+    const oneUIV5 = _MessageList.isAIV5UIMessage(one) && one;
+    const twoUIV5 = _MessageList.isAIV5UIMessage(two) && two;
+    if (oneUIV5 && !twoUIV5) return false;
+    if (oneUIV5 && twoUIV5) {
+      return _MessageList.cacheKeyFromAIV5Parts(one.parts) === _MessageList.cacheKeyFromAIV5Parts(two.parts);
+    }
+    const oneCMV5 = _MessageList.isAIV5CoreMessage(one) && one;
+    const twoCMV5 = _MessageList.isAIV5CoreMessage(two) && two;
+    if (oneCMV5 && !twoCMV5) return false;
+    if (oneCMV5 && twoCMV5) {
+      return _MessageList.cacheKeyFromAIV5ModelMessageContent(oneCMV5.content) === _MessageList.cacheKeyFromAIV5ModelMessageContent(twoCMV5.content);
     }
     return true;
   }
+  cleanV3Metadata(messages) {
+    return messages.map((msg) => {
+      if (!msg.content.metadata || typeof msg.content.metadata !== "object") {
+        return msg;
+      }
+      const metadata = { ...msg.content.metadata };
+      const hasOriginalContent = "__originalContent" in metadata;
+      const hasOriginalAttachments = "__originalExperimentalAttachments" in metadata;
+      if (!hasOriginalContent && !hasOriginalAttachments) {
+        return msg;
+      }
+      const { __originalContent, __originalExperimentalAttachments, ...cleanMetadata } = metadata;
+      if (Object.keys(cleanMetadata).length === 0) {
+        const { metadata: metadata2, ...contentWithoutMetadata } = msg.content;
+        return { ...msg, content: contentWithoutMetadata };
+      }
+      return { ...msg, content: { ...msg.content, metadata: cleanMetadata } };
+    });
+  }
+  static aiV4CoreMessageToV1PromptMessage(coreMessage) {
+    if (coreMessage.role === `system`) {
+      return coreMessage;
+    }
+    if (typeof coreMessage.content === `string` && (coreMessage.role === `assistant` || coreMessage.role === `user`)) {
+      return {
+        ...coreMessage,
+        content: [{ type: "text", text: coreMessage.content }]
+      };
+    }
+    if (typeof coreMessage.content === `string`) {
+      throw new Error(
+        `Saw text content for input CoreMessage, but the role is ${coreMessage.role}. This is only allowed for "system", "assistant", and "user" roles.`
+      );
+    }
+    const roleContent = {
+      user: [],
+      assistant: [],
+      tool: []
+    };
+    const role = coreMessage.role;
+    for (const part of coreMessage.content) {
+      const incompatibleMessage = `Saw incompatible message content part type ${part.type} for message role ${role}`;
+      switch (part.type) {
+        case "text": {
+          if (role === `tool`) {
+            throw new Error(incompatibleMessage);
+          }
+          roleContent[role].push(part);
+          break;
+        }
+        case "redacted-reasoning":
+        case "reasoning": {
+          if (role !== `assistant`) {
+            throw new Error(incompatibleMessage);
+          }
+          roleContent[role].push(part);
+          break;
+        }
+        case "tool-call": {
+          if (role === `tool` || role === `user`) {
+            throw new Error(incompatibleMessage);
+          }
+          roleContent[role].push(part);
+          break;
+        }
+        case "tool-result": {
+          if (role === `assistant` || role === `user`) {
+            throw new Error(incompatibleMessage);
+          }
+          roleContent[role].push(part);
+          break;
+        }
+        case "image": {
+          if (role === `tool` || role === `assistant`) {
+            throw new Error(incompatibleMessage);
+          }
+          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)
+          });
+          break;
+        }
+        case "file": {
+          if (role === `tool`) {
+            throw new Error(incompatibleMessage);
+          }
+          roleContent[role].push({
+            ...part,
+            data: part.data instanceof URL ? part.data : typeof part.data === "string" ? part.data : convertDataContentToBase64String(part.data)
+          });
+          break;
+        }
+      }
+    }
+    if (role === `tool`) {
+      return {
+        ...coreMessage,
+        content: roleContent[role]
+      };
+    }
+    if (role === `user`) {
+      return {
+        ...coreMessage,
+        content: roleContent[role]
+      };
+    }
+    if (role === `assistant`) {
+      return {
+        ...coreMessage,
+        content: roleContent[role]
+      };
+    }
+    throw new Error(
+      `Encountered unknown role ${role} when converting V4 CoreMessage -> V4 LanguageModelV1Prompt, input message: ${JSON.stringify(coreMessage, null, 2)}`
+    );
+  }
+  static aiV5ModelMessageToV2PromptMessage(modelMessage) {
+    if (modelMessage.role === `system`) {
+      return modelMessage;
+    }
+    if (typeof modelMessage.content === `string` && (modelMessage.role === `assistant` || modelMessage.role === `user`)) {
+      return {
+        role: modelMessage.role,
+        content: [{ type: "text", text: modelMessage.content }],
+        providerOptions: modelMessage.providerOptions
+      };
+    }
+    if (typeof modelMessage.content === `string`) {
+      throw new Error(
+        `Saw text content for input ModelMessage, but the role is ${modelMessage.role}. This is only allowed for "system", "assistant", and "user" roles.`
+      );
+    }
+    const roleContent = {
+      user: [],
+      assistant: [],
+      tool: []
+    };
+    const role = modelMessage.role;
+    for (const part of modelMessage.content) {
+      const incompatibleMessage = `Saw incompatible message content part type ${part.type} for message role ${role}`;
+      switch (part.type) {
+        case "text": {
+          if (role === `tool`) {
+            throw new Error(incompatibleMessage);
+          }
+          roleContent[role].push(part);
+          break;
+        }
+        case "reasoning": {
+          if (role === `tool` || role === `user`) {
+            throw new Error(incompatibleMessage);
+          }
+          roleContent[role].push(part);
+          break;
+        }
+        case "tool-call": {
+          if (role !== `assistant`) {
+            throw new Error(incompatibleMessage);
+          }
+          roleContent[role].push(part);
+          break;
+        }
+        case "tool-result": {
+          if (role === `assistant` || role === `user`) {
+            throw new Error(incompatibleMessage);
+          }
+          roleContent[role].push(part);
+          break;
+        }
+        case "file": {
+          if (role === `tool`) {
+            throw new Error(incompatibleMessage);
+          }
+          roleContent[role].push({
+            ...part,
+            data: part.data instanceof ArrayBuffer ? new Uint8Array(part.data) : part.data
+          });
+          break;
+        }
+        case "image": {
+          if (role === `tool`) {
+            throw new Error(incompatibleMessage);
+          }
+          roleContent[role].push({
+            ...part,
+            mediaType: part.mediaType || "image/unknown",
+            type: "file",
+            data: part.image instanceof ArrayBuffer ? new Uint8Array(part.image) : part.image
+          });
+          break;
+        }
+      }
+    }
+    if (role === `tool`) {
+      return {
+        ...modelMessage,
+        content: roleContent[role]
+      };
+    }
+    if (role === `user`) {
+      return {
+        ...modelMessage,
+        content: roleContent[role]
+      };
+    }
+    if (role === `assistant`) {
+      return {
+        ...modelMessage,
+        content: roleContent[role]
+      };
+    }
+    throw new Error(
+      `Encountered unknown role ${role} when converting V5 ModelMessage -> V5 LanguageModelV2Message, input message: ${JSON.stringify(modelMessage, null, 2)}`
+    );
+  }
+  static mastraMessageV3ToV2(v3Msg) {
+    const toolInvocationParts = v3Msg.content.parts.filter((p) => AIV5.isToolUIPart(p));
+    const hadToolInvocations = v3Msg.content.metadata?.__hadToolInvocations === true;
+    let toolInvocations = void 0;
+    if (toolInvocationParts.length > 0) {
+      const invocations = toolInvocationParts.map((p) => {
+        const toolName = getToolName(p);
+        if (p.state === `output-available`) {
+          return {
+            args: p.input,
+            result: typeof p.output === "object" && p.output && "value" in p.output ? p.output.value : p.output,
+            toolCallId: p.toolCallId,
+            toolName,
+            state: "result"
+          };
+        }
+        return {
+          args: p.input,
+          state: "call",
+          toolName,
+          toolCallId: p.toolCallId
+        };
+      });
+      toolInvocations = invocations;
+    } else if (hadToolInvocations && v3Msg.role === "assistant") {
+      toolInvocations = [];
+    }
+    const attachmentUrls = new Set(v3Msg.content.metadata?.__attachmentUrls || []);
+    const v2Msg = {
+      id: v3Msg.id,
+      resourceId: v3Msg.resourceId,
+      threadId: v3Msg.threadId,
+      createdAt: v3Msg.createdAt,
+      role: v3Msg.role,
+      content: {
+        format: 2,
+        parts: v3Msg.content.parts.map((p) => {
+          if (AIV5.isToolUIPart(p) || p.type === "dynamic-tool") {
+            const toolName = getToolName(p);
+            const shared = {
+              state: p.state,
+              args: p.input,
+              toolCallId: p.toolCallId,
+              toolName
+            };
+            if (p.state === `output-available`) {
+              return {
+                type: "tool-invocation",
+                toolInvocation: {
+                  ...shared,
+                  state: "result",
+                  result: typeof p.output === "object" && p.output && "value" in p.output ? p.output.value : p.output
+                },
+                providerMetadata: p.callProviderMetadata
+              };
+            }
+            return {
+              type: "tool-invocation",
+              toolInvocation: {
+                ...shared,
+                state: p.state === `input-available` ? `call` : `partial-call`
+              }
+            };
+          }
+          switch (p.type) {
+            case "text":
+              return p;
+            case "file":
+              if (attachmentUrls.has(p.url)) {
+                return null;
+              }
+              return {
+                type: "file",
+                mimeType: p.mediaType,
+                data: p.url,
+                providerMetadata: p.providerMetadata
+              };
+            case "reasoning":
+              if (p.text === "") return null;
+              return {
+                type: "reasoning",
+                reasoning: p.text,
+                details: [{ type: "text", text: p.text }],
+                providerMetadata: p.providerMetadata
+              };
+            case "source-url":
+              return {
+                type: "source",
+                source: {
+                  url: p.url,
+                  id: p.sourceId,
+                  sourceType: "url"
+                },
+                providerMetadata: p.providerMetadata
+              };
+            case "step-start":
+              return p;
+          }
+          return null;
+        }).filter((p) => Boolean(p))
+      }
+    };
+    if (toolInvocations !== void 0) {
+      v2Msg.content.toolInvocations = toolInvocations;
+    }
+    if (v3Msg.content.metadata) {
+      const { __originalContent, __originalExperimentalAttachments, __attachmentUrls, ...userMetadata } = v3Msg.content.metadata;
+      v2Msg.content.metadata = userMetadata;
+    }
+    const originalContent = v3Msg.content.metadata?.__originalContent;
+    if (originalContent !== void 0) {
+      if (typeof originalContent !== `string` || v2Msg.content.parts.every((p) => p.type === `step-start` || p.type === `text`)) {
+        v2Msg.content.content = originalContent;
+      }
+    }
+    const originalAttachments = v3Msg.content.metadata?.__originalExperimentalAttachments;
+    if (originalAttachments && Array.isArray(originalAttachments)) {
+      v2Msg.content.experimental_attachments = originalAttachments || [];
+    }
+    if (toolInvocations && toolInvocations.length > 0) {
+      const resultToolInvocations = toolInvocations.filter((t) => t.state === "result");
+      if (resultToolInvocations.length > 0) {
+        v2Msg.content.toolInvocations = resultToolInvocations;
+      }
+    }
+    if (v3Msg.type) v2Msg.type = v3Msg.type;
+    return v2Msg;
+  }
+  mastraMessageV2ToMastraMessageV3(v2Msg) {
+    const parts = [];
+    const v3Msg = {
+      id: v2Msg.id,
+      content: {
+        format: 3,
+        parts
+      },
+      role: v2Msg.role,
+      createdAt: v2Msg.createdAt instanceof Date ? v2Msg.createdAt : new Date(v2Msg.createdAt),
+      resourceId: v2Msg.resourceId,
+      threadId: v2Msg.threadId,
+      type: v2Msg.type
+    };
+    if (v2Msg.content.metadata) {
+      v3Msg.content.metadata = { ...v2Msg.content.metadata };
+    }
+    if (v2Msg.content.content !== void 0) {
+      v3Msg.content.metadata = {
+        ...v3Msg.content.metadata || {},
+        __originalContent: v2Msg.content.content
+      };
+    }
+    if (v2Msg.content.experimental_attachments !== void 0) {
+      v3Msg.content.metadata = {
+        ...v3Msg.content.metadata || {},
+        __originalExperimentalAttachments: v2Msg.content.experimental_attachments
+      };
+    }
+    const fileUrls = /* @__PURE__ */ new Set();
+    for (const part of v2Msg.content.parts) {
+      switch (part.type) {
+        case "step-start":
+        case "text":
+          parts.push(part);
+          break;
+        case "tool-invocation":
+          if (part.toolInvocation.state === `result`) {
+            parts.push({
+              type: `tool-${part.toolInvocation.toolName}`,
+              toolCallId: part.toolInvocation.toolCallId,
+              state: "output-available",
+              input: part.toolInvocation.args,
+              output: part.toolInvocation.result,
+              callProviderMetadata: part.providerMetadata
+            });
+          } else {
+            parts.push({
+              type: `tool-${part.toolInvocation.toolName}`,
+              toolCallId: part.toolInvocation.toolCallId,
+              state: part.toolInvocation.state === `call` ? `input-available` : `input-streaming`,
+              input: part.toolInvocation.args
+            });
+          }
+          break;
+        case "source":
+          parts.push({
+            type: "source-url",
+            sourceId: part.source.id,
+            url: part.source.url,
+            title: part.source.title,
+            providerMetadata: part.source.providerMetadata || part.providerMetadata
+          });
+          break;
+        case "reasoning":
+          const text = part.reasoning || (part.details?.reduce((p, c) => {
+            if (c.type === `text`) return p + c.text;
+            return p;
+          }, "") ?? "");
+          if (text || part.details?.length) {
+            parts.push({
+              type: "reasoning",
+              text: text || "",
+              state: "done",
+              providerMetadata: part.providerMetadata
+            });
+          }
+          break;
+        case "file":
+          parts.push({
+            type: "file",
+            url: part.data,
+            mediaType: part.mimeType,
+            providerMetadata: part.providerMetadata
+          });
+          fileUrls.add(part.data);
+          break;
+      }
+    }
+    if (v2Msg.content.content && !v3Msg.content.parts?.some((p) => p.type === `text`)) {
+      v3Msg.content.parts.push({ type: "text", text: v2Msg.content.content });
+    }
+    const attachmentUrls = [];
+    if (v2Msg.content.experimental_attachments?.length) {
+      for (const attachment of v2Msg.content.experimental_attachments) {
+        if (fileUrls.has(attachment.url)) continue;
+        attachmentUrls.push(attachment.url);
+        parts.push({
+          url: attachment.url,
+          mediaType: attachment.contentType || "unknown",
+          type: "file"
+        });
+      }
+    }
+    if (attachmentUrls.length > 0) {
+      v3Msg.content.metadata = {
+        ...v3Msg.content.metadata || {},
+        __attachmentUrls: attachmentUrls
+      };
+    }
+    return v3Msg;
+  }
+  aiV5UIMessagesToAIV5ModelMessages(messages) {
+    return AIV5.convertToModelMessages(this.sanitizeV5UIMessages(messages));
+  }
+  sanitizeV5UIMessages(messages) {
+    const msgs = messages.map((m) => {
+      if (m.parts.length === 0) return false;
+      const safeParts = m.parts.filter((p) => {
+        if (!AIV5.isToolUIPart(p)) return true;
+        return p.state === "output-available" || p.state === "output-error";
+      });
+      if (!safeParts.length) return false;
+      const sanitized = {
+        ...m,
+        parts: safeParts.map((part) => {
+          if (AIV5.isToolUIPart(part) && part.state === "output-available") {
+            return {
+              ...part,
+              output: typeof part.output === "object" && part.output && "value" in part.output ? part.output.value : part.output
+            };
+          }
+          return part;
+        })
+      };
+      return sanitized;
+    }).filter((m) => Boolean(m));
+    return msgs;
+  }
+  static mastraMessageV3ToAIV5UIMessage(m) {
+    const metadata = {
+      ...m.content.metadata || {}
+    };
+    if (m.createdAt) metadata.createdAt = m.createdAt;
+    if (m.threadId) metadata.threadId = m.threadId;
+    if (m.resourceId) metadata.resourceId = m.resourceId;
+    const filteredParts = m.content.parts;
+    return {
+      id: m.id,
+      role: m.role,
+      metadata,
+      parts: filteredParts
+    };
+  }
+  aiV5ModelMessagesToAIV4CoreMessages(messages, messageSource) {
+    const v3 = messages.map((msg) => this.aiV5ModelMessageToMastraMessageV3(msg, messageSource));
+    const v2 = v3.map(_MessageList.mastraMessageV3ToV2);
+    const ui = v2.map(_MessageList.mastraMessageV2ToAIV4UIMessage);
+    const core = this.aiV4UIMessagesToAIV4CoreMessages(ui);
+    return core;
+  }
+  aiV4CoreMessagesToAIV5ModelMessages(messages, source) {
+    return this.aiV5UIMessagesToAIV5ModelMessages(
+      messages.map((m) => this.aiV4CoreMessageToMastraMessageV2(m, source)).map((m) => this.mastraMessageV2ToMastraMessageV3(m)).map((m) => _MessageList.mastraMessageV3ToAIV5UIMessage(m))
+    );
+  }
+  aiV5UIMessageToMastraMessageV3(message, messageSource) {
+    const content = {
+      format: 3,
+      parts: message.parts,
+      metadata: message.metadata
+    };
+    const metadata = message.metadata;
+    const createdAt = (() => {
+      if ("createdAt" in message && message.createdAt instanceof Date) {
+        return message.createdAt;
+      }
+      if (metadata && "createdAt" in metadata && metadata.createdAt instanceof Date) {
+        return metadata.createdAt;
+      }
+      return void 0;
+    })();
+    if ("metadata" in message && message.metadata) {
+      content.metadata = { ...message.metadata };
+    }
+    return {
+      id: message.id || this.newMessageId(),
+      role: _MessageList.getRole(message),
+      createdAt: this.generateCreatedAt(messageSource, createdAt),
+      threadId: this.memoryInfo?.threadId,
+      resourceId: this.memoryInfo?.resourceId,
+      content
+    };
+  }
+  aiV5ModelMessageToMastraMessageV3(coreMessage, messageSource) {
+    const id = `id` in coreMessage && typeof coreMessage.id === `string` ? coreMessage.id : this.newMessageId();
+    const parts = [];
+    if (messageSource === "input" && coreMessage.role === "user") {
+      parts.push({ type: "step-start" });
+    }
+    if (typeof coreMessage.content === "string") {
+      parts.push({
+        type: "text",
+        text: coreMessage.content
+      });
+    } else if (Array.isArray(coreMessage.content)) {
+      for (const part of coreMessage.content) {
+        switch (part.type) {
+          case "text":
+            parts.push({
+              type: "text",
+              text: part.text,
+              providerMetadata: part.providerOptions
+            });
+            break;
+          case "tool-call":
+            parts.push({
+              type: "dynamic-tool",
+              toolName: part.toolName,
+              state: "input-available",
+              toolCallId: part.toolCallId,
+              input: part.input
+            });
+            break;
+          case "tool-result":
+            parts.push({
+              type: "dynamic-tool",
+              toolName: part.toolName,
+              state: "output-available",
+              toolCallId: part.toolCallId,
+              output: typeof part.output === "string" ? { type: "text", value: part.output } : part.output ?? { type: "text", value: "" },
+              input: {},
+              callProviderMetadata: part.providerOptions
+            });
+            break;
+          case "reasoning":
+            parts.push({
+              type: "reasoning",
+              text: part.text,
+              providerMetadata: part.providerOptions
+            });
+            break;
+          case "image":
+            parts.push({
+              type: "file",
+              url: part.image.toString(),
+              mediaType: part.mediaType || "unknown",
+              providerMetadata: part.providerOptions
+            });
+            break;
+          case "file":
+            if (part.data instanceof URL) {
+              parts.push({
+                type: "file",
+                url: part.data.toString(),
+                mediaType: part.mediaType,
+                providerMetadata: part.providerOptions
+              });
+            } else {
+              try {
+                parts.push({
+                  type: "file",
+                  mediaType: part.mediaType,
+                  url: convertDataContentToBase64String(part.data),
+                  providerMetadata: part.providerOptions
+                });
+              } catch (error) {
+                console.error(`Failed to convert binary data to base64 in CoreMessage file part: ${error}`, error);
+              }
+            }
+            break;
+        }
+      }
+    }
+    const content = {
+      format: 3,
+      parts
+    };
+    if (coreMessage.content) {
+      content.metadata = {
+        ...content.metadata || {},
+        __originalContent: coreMessage.content
+      };
+    }
+    return {
+      id,
+      role: _MessageList.getRole(coreMessage),
+      createdAt: this.generateCreatedAt(messageSource),
+      threadId: this.memoryInfo?.threadId,
+      resourceId: this.memoryInfo?.resourceId,
+      content
+    };
+  }
+  static hasAIV5UIMessageCharacteristics(msg) {
+    if (`toolInvocations` in msg || `reasoning` in msg || `experimental_attachments` in msg || `data` in msg || `annotations` in msg)
+      return false;
+    if (!msg.parts) return false;
+    for (const part of msg.parts) {
+      if (`metadata` in part) return true;
+      if (`toolInvocation` in part) return false;
+      if (`toolCallId` in part) return true;
+      if (part.type === `source`) return false;
+      if (part.type === `source-url`) return true;
+      if (part.type === `reasoning`) {
+        if (`state` in part || `text` in part) return true;
+        if (`reasoning` in part || `details` in part) return false;
+      }
+      if (part.type === `file` && `mediaType` in part) return true;
+    }
+    return false;
+  }
+  static isAIV5UIMessage(msg) {
+    return !_MessageList.isMastraMessage(msg) && !_MessageList.isAIV5CoreMessage(msg) && `parts` in msg && _MessageList.hasAIV5UIMessageCharacteristics(msg);
+  }
+  static hasAIV5CoreMessageCharacteristics(msg) {
+    if (`experimental_providerMetadata` in msg) return false;
+    if (typeof msg.content === `string`) return false;
+    for (const part of msg.content) {
+      if (part.type === `tool-result` && `output` in part) return true;
+      if (part.type === `tool-call` && `input` in part) return true;
+      if (part.type === `tool-result` && `result` in part) return false;
+      if (part.type === `tool-call` && `args` in part) return false;
+      if (`mediaType` in part) return true;
+      if (`mimeType` in part) return false;
+      if (`experimental_providerMetadata` in part) return false;
+      if (part.type === `reasoning` && `signature` in part) return false;
+      if (part.type === `redacted-reasoning`) return false;
+    }
+    return false;
+  }
+  static cacheKeyFromAIV5Parts(parts) {
+    let key = ``;
+    for (const part of parts) {
+      key += part.type;
+      if (part.type === `text`) {
+        key += part.text;
+      }
+      if (AIV5.isToolUIPart(part) || part.type === "dynamic-tool") {
+        key += part.toolCallId;
+        key += part.state;
+      }
+      if (part.type === `reasoning`) {
+        key += part.text;
+      }
+      if (part.type === `file`) {
+        key += part.url.length;
+        key += part.mediaType;
+        key += part.filename || "";
+      }
+    }
+    return key;
+  }
+  static cacheKeyFromAIV5ModelMessageContent(content) {
+    if (typeof content === `string`) return content;
+    let key = ``;
+    for (const part of content) {
+      key += part.type;
+      if (part.type === `text`) {
+        key += part.text.length;
+      }
+      if (part.type === `reasoning`) {
+        key += part.text.length;
+      }
+      if (part.type === `tool-call`) {
+        key += part.toolCallId;
+        key += part.toolName;
+      }
+      if (part.type === `tool-result`) {
+        key += part.toolCallId;
+        key += part.toolName;
+      }
+      if (part.type === `file`) {
+        key += part.filename;
+        key += part.mediaType;
+      }
+      if (part.type === `image`) {
+        key += part.image instanceof URL ? part.image.toString() : part.image.toString().length;
+        key += part.mediaType;
+      }
+    }
+    return key;
+  }
 };
 
-export { MessageList };
-//# sourceMappingURL=chunk-L6YBPFYF.js.map
-//# sourceMappingURL=chunk-L6YBPFYF.js.map
+export { DefaultGeneratedFile, DefaultGeneratedFileWithType, MessageList };
+//# sourceMappingURL=chunk-OPT2L5AM.js.map
+//# sourceMappingURL=chunk-OPT2L5AM.js.map