@mastra/core 0.24.0 → 1.0.0-beta.0

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

@@ -1,10 +1,8 @@
-import { fetchWithRetry } from './chunk-DTTOVV72.js';
-import { MastraError } from './chunk-PZUZNPFM.js';
-import { convertUint8ArrayToBase64, convertBase64ToUint8Array, isUrlSupported } from '@ai-sdk/provider-utils-v5';
-import { randomUUID } from 'crypto';
-import * as AIV4 from 'ai';
+import { convertToCoreMessages, convertUint8ArrayToBase64 as convertUint8ArrayToBase64$1 } from './chunk-QM5SRDJX.js';
+import { MastraError } from './chunk-JJ5O45LH.js';
+import { v4 } from '@lukeed/uuid';
 import * as AIV5 from 'ai-v5';
-import { convertUint8ArrayToBase64 as convertUint8ArrayToBase64$1 } from '@ai-sdk/provider-utils';
+import { convertUint8ArrayToBase64, convertBase64ToUint8Array, isUrlSupported } from '@ai-sdk/provider-utils-v5';
 import { z } from 'zod';
 
 var DefaultGeneratedFile = class {
@@ -587,6 +585,45 @@ function convertDataContentToBase64String(content) {
   }
   return convertUint8ArrayToBase64$1(content);
 }
+
+// src/utils/fetchWithRetry.ts
+async function fetchWithRetry(url, options = {}, maxRetries = 3) {
+  let retryCount = 0;
+  let lastError = null;
+  while (retryCount < maxRetries) {
+    try {
+      const response = await fetch(url, options);
+      if (!response.ok) {
+        if (response.status >= 400 && response.status < 500) {
+          throw new Error(`Request failed with status: ${response.status} ${response.statusText}`);
+        }
+        lastError = new Error(`Request failed with status: ${response.status} ${response.statusText}`);
+        retryCount++;
+        if (retryCount >= maxRetries) {
+          throw lastError;
+        }
+        const delay = Math.min(1e3 * Math.pow(2, retryCount), 1e4);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        continue;
+      }
+      return response;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (lastError.message.includes("status: 4")) {
+        throw lastError;
+      }
+      retryCount++;
+      if (retryCount >= maxRetries) {
+        break;
+      }
+      const delay = Math.min(1e3 * Math.pow(2, retryCount), 1e4);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError || new Error("Request failed after multiple retry attempts");
+}
+
+// src/agent/message-list/prompt/download-assets.ts
 var downloadFromUrl = async ({ url, downloadRetries }) => {
   const urlText = url.toString();
   try {
@@ -649,7 +686,13 @@ async function downloadAssetsFromMessages({
   const downloadedFiles = await pMap(
     filesToDownload,
     async (fileItem) => {
-      return downloadFromUrl({ url: fileItem.url, downloadRetries });
+      if (!fileItem.isUrlSupportedByModel) {
+        return null;
+      }
+      return {
+        url: fileItem.url.toString(),
+        ...await downloadFromUrl({ url: fileItem.url, downloadRetries })
+      };
     },
     {
       concurrency: downloadConcurrency
@@ -657,7 +700,7 @@ async function downloadAssetsFromMessages({
   );
   const downloadFileList = downloadedFiles.filter(
     (downloadedFile) => downloadedFile?.data != null
-  ).map(({ data, mediaType }, index) => [filesToDownload?.[index]?.url.toString(), { data, mediaType }]);
+  ).map(({ url, data, mediaType }) => [url, { data, mediaType }]);
   return Object.fromEntries(downloadFileList);
 }
 
@@ -701,23 +744,10 @@ function imageContentToString(image, fallbackMimeType) {
   }
   if (image instanceof Uint8Array || image instanceof ArrayBuffer || globalThis.Buffer && Buffer.isBuffer(image)) {
     const base64 = convertDataContentToBase64String(image);
-    if (fallbackMimeType && !base64.startsWith("data:")) {
-      return `data:${fallbackMimeType};base64,${base64}`;
-    }
     return base64;
   }
   return String(image);
 }
-function imageContentToDataUri(image, mimeType = "image/png") {
-  const imageStr = imageContentToString(image, mimeType);
-  if (imageStr.startsWith("data:")) {
-    return imageStr;
-  }
-  if (imageStr.startsWith("http://") || imageStr.startsWith("https://")) {
-    return imageStr;
-  }
-  return `data:${mimeType};base64,${imageStr}`;
-}
 function getImageCacheKey(image) {
   if (image instanceof URL) {
     return image.toString();
@@ -810,6 +840,35 @@ function getToolName(type) {
   return type;
 }
 
+// src/agent/message-list/utils/convert-messages.ts
+var MessageConverter = class {
+  messageList;
+  constructor(messages) {
+    this.messageList = new MessageList();
+    this.messageList.add(messages, "memory");
+  }
+  to(format) {
+    switch (format) {
+      // Old format keys (backward compatibility)
+      case "Mastra.V2":
+        return this.messageList.get.all.db();
+      case "AIV4.UI":
+        return this.messageList.get.all.aiV4.ui();
+      case "AIV4.Core":
+        return this.messageList.get.all.aiV4.core();
+      case "AIV5.UI":
+        return this.messageList.get.all.aiV5.ui();
+      case "AIV5.Model":
+        return this.messageList.get.all.aiV5.model();
+      default:
+        throw new Error(`Unsupported output format: ${format}`);
+    }
+  }
+};
+function convertMessages(messages) {
+  return new MessageConverter(messages);
+}
+
 // src/agent/message-list/index.ts
 var MessageList = class _MessageList {
   messages = [];
@@ -932,7 +991,7 @@ var MessageList = class _MessageList {
   get clear() {
     return {
       input: {
-        v2: () => {
+        db: () => {
           const userMessages = Array.from(this.newUserMessages);
           this.messages = this.messages.filter((m) => !this.newUserMessages.has(m));
           this.newUserMessages.clear();
@@ -940,7 +999,7 @@ var MessageList = class _MessageList {
         }
       },
       response: {
-        v2: () => {
+        db: () => {
           const responseMessages = Array.from(this.newResponseMessages);
           this.messages = this.messages.filter((m) => !this.newResponseMessages.has(m));
           this.newResponseMessages.clear();
@@ -950,19 +1009,18 @@ var MessageList = class _MessageList {
     };
   }
   all = {
-    v3: () => this.cleanV3Metadata(this.messages.map(this.mastraMessageV2ToMastraMessageV3)),
-    v2: () => this.messages,
-    v1: () => convertToV1Messages(this.all.v2()),
+    db: () => this.messages,
+    v1: () => convertToV1Messages(this.all.db()),
     aiV5: {
       model: () => this.aiV5UIMessagesToAIV5ModelMessages(this.all.aiV5.ui()),
-      ui: () => this.all.v3().map(_MessageList.mastraMessageV3ToAIV5UIMessage),
+      ui: () => this.all.db().map(_MessageList.mastraDBMessageToAIV5UIMessage),
       // Used when calling AI SDK streamText/generateText
       prompt: () => {
         const systemMessages = this.aiV4CoreMessagesToAIV5ModelMessages(
           [...this.systemMessages, ...Object.values(this.taggedSystemMessages).flat()],
           `system`
         );
-        const modelMessages = this.all.aiV5.model();
+        const modelMessages = this.aiV5UIMessagesToAIV5ModelMessages(this.all.aiV5.ui(), true);
         const messages = [...systemMessages, ...modelMessages];
         return ensureGeminiCompatibleMessages(messages);
       },
@@ -971,7 +1029,7 @@ var MessageList = class _MessageList {
         downloadConcurrency: 10,
         downloadRetries: 3
       }) => {
-        const modelMessages = this.all.aiV5.model();
+        const modelMessages = this.aiV5UIMessagesToAIV5ModelMessages(this.all.aiV5.ui(), true);
         const systemMessages = this.aiV4CoreMessagesToAIV5ModelMessages(
           [...this.systemMessages, ...Object.values(this.taggedSystemMessages).flat()],
           `system`
@@ -1015,11 +1073,11 @@ var MessageList = class _MessageList {
     /* @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),
+    ui: () => this.all.db().map(_MessageList.mastraDBMessageToAIV4UIMessage),
     /* @deprecated use list.get.all.aiV4.core() */
     core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.all.aiV4.ui()),
     aiV4: {
-      ui: () => this.all.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+      ui: () => this.all.db().map(_MessageList.mastraDBMessageToAIV4UIMessage),
       core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.all.aiV4.ui()),
       // Used when calling AI SDK streamText/generateText
       prompt: () => {
@@ -1038,64 +1096,56 @@ var MessageList = class _MessageList {
     }
   };
   remembered = {
-    v3: () => this.remembered.v2().map(this.mastraMessageV2ToMastraMessageV3),
-    v2: () => this.messages.filter((m) => this.memoryMessages.has(m)),
-    v1: () => convertToV1Messages(this.remembered.v2()),
+    db: () => this.messages.filter((m) => this.memoryMessages.has(m)),
+    v1: () => convertToV1Messages(this.remembered.db()),
     aiV5: {
       model: () => this.aiV5UIMessagesToAIV5ModelMessages(this.remembered.aiV5.ui()),
-      ui: () => this.remembered.v3().map(_MessageList.mastraMessageV3ToAIV5UIMessage)
+      ui: () => this.remembered.db().map(_MessageList.mastraDBMessageToAIV5UIMessage)
     },
     /* @deprecated use list.get.remembered.aiV4.ui() */
-    ui: () => this.remembered.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+    ui: () => this.remembered.db().map(_MessageList.mastraDBMessageToAIV4UIMessage),
     /* @deprecated use list.get.remembered.aiV4.core() */
     core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.all.aiV4.ui()),
     aiV4: {
-      ui: () => this.remembered.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+      ui: () => this.remembered.db().map(_MessageList.mastraDBMessageToAIV4UIMessage),
       core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.all.aiV4.ui())
     }
   };
   // TODO: need to update this for new .aiV4/5.x() pattern
   rememberedPersisted = {
-    v2: () => this.all.v2().filter((m) => this.memoryMessagesPersisted.has(m)),
-    v1: () => convertToV1Messages(this.rememberedPersisted.v2()),
-    ui: () => this.rememberedPersisted.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+    db: () => this.all.db().filter((m) => this.memoryMessagesPersisted.has(m)),
+    v1: () => convertToV1Messages(this.rememberedPersisted.db()),
+    ui: () => this.rememberedPersisted.db().map(_MessageList.mastraDBMessageToAIV4UIMessage),
     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()),
+    db: () => this.messages.filter((m) => this.newUserMessages.has(m)),
+    v1: () => convertToV1Messages(this.input.db()),
     aiV5: {
       model: () => this.aiV5UIMessagesToAIV5ModelMessages(this.input.aiV5.ui()),
-      ui: () => this.input.v3().map(_MessageList.mastraMessageV3ToAIV5UIMessage)
+      ui: () => this.input.db().map(_MessageList.mastraDBMessageToAIV5UIMessage)
     },
     /* @deprecated use list.get.input.aiV4.ui() instead */
-    ui: () => this.input.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+    ui: () => this.input.db().map(_MessageList.mastraDBMessageToAIV4UIMessage),
     /* @deprecated use list.get.core.aiV4.ui() instead */
     core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.input.ui()),
     aiV4: {
-      ui: () => this.input.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+      ui: () => this.input.db().map(_MessageList.mastraDBMessageToAIV4UIMessage),
       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.mastraMessageV2ToAIV4UIMessage),
+    db: () => this.messages.filter((m) => this.newUserMessagesPersisted.has(m)),
+    v1: () => convertToV1Messages(this.inputPersisted.db()),
+    ui: () => this.inputPersisted.db().map(_MessageList.mastraDBMessageToAIV4UIMessage),
     core: () => this.aiV4UIMessagesToAIV4CoreMessages(this.inputPersisted.ui())
   };
   response = {
-    v3: () => this.response.v2().map(this.mastraMessageV2ToMastraMessageV3),
-    v2: () => this.messages.filter((m) => this.newResponseMessages.has(m)),
-    v1: () => convertToV1Messages(this.response.v3().map(_MessageList.mastraMessageV3ToV2)),
+    db: () => this.messages.filter((m) => this.newResponseMessages.has(m)),
+    v1: () => convertToV1Messages(this.response.db()),
     aiV5: {
-      ui: () => this.response.v3().map(_MessageList.mastraMessageV3ToAIV5UIMessage),
+      ui: () => this.response.db().map(_MessageList.mastraDBMessageToAIV5UIMessage),
       model: () => this.aiV5UIMessagesToAIV5ModelMessages(this.response.aiV5.ui()).filter(
         (m) => m.role === `tool` || m.role === `assistant`
       ),
@@ -1238,17 +1288,14 @@ var MessageList = class _MessageList {
       }
     },
     aiV4: {
-      ui: () => this.response.v2().map(_MessageList.mastraMessageV2ToAIV4UIMessage),
+      ui: () => this.response.db().map(_MessageList.mastraDBMessageToAIV4UIMessage),
       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.mastraMessageV2ToAIV4UIMessage)
+    db: () => this.messages.filter((m) => this.newResponseMessagesPersisted.has(m)),
+    ui: () => this.responsePersisted.db().map(_MessageList.mastraDBMessageToAIV4UIMessage)
   };
   drainUnsavedMessages() {
     const messages = this.messages.filter((m) => this.newUserMessages.has(m) || this.newResponseMessages.has(m));
@@ -1275,7 +1322,7 @@ var MessageList = class _MessageList {
     return this;
   }
   aiV4UIMessagesToAIV4CoreMessages(messages) {
-    return AIV4.convertToCoreMessages(this.sanitizeAIV4UIMessages(messages));
+    return convertToCoreMessages(this.sanitizeAIV4UIMessages(messages));
   }
   sanitizeAIV4UIMessages(messages) {
     const msgs = messages.map((m) => {
@@ -1299,7 +1346,7 @@ var MessageList = class _MessageList {
   }
   /**
    * Converts various message formats to AIV4 CoreMessage format for system messages
-   * @param message - The message to convert (can be string, MastraMessageV2, or AI SDK message types)
+   * @param message - The message to convert (can be string, MastraDBMessage, or AI SDK message types)
    * @returns AIV4 CoreMessage in the proper format
    */
   systemMessageToAICore(message) {
@@ -1307,10 +1354,11 @@ var MessageList = class _MessageList {
       return { role: "system", content: message };
     }
     if (_MessageList.isAIV5CoreMessage(message)) {
-      return this.aiV5ModelMessagesToAIV4CoreMessages([message], `system`)[0];
+      const dbMsg = _MessageList.aiV5ModelMessageToMastraDBMessage(message, "system");
+      return _MessageList.mastraDBMessageSystemToV4Core(dbMsg);
     }
-    if (_MessageList.isMastraMessageV2(message)) {
-      return _MessageList.mastraMessageV2SystemToV4Core(message);
+    if (_MessageList.isMastraDBMessage(message)) {
+      return _MessageList.mastraDBMessageSystemToV4Core(message);
     }
     return message;
   }
@@ -1339,7 +1387,7 @@ var MessageList = class _MessageList {
       (m) => _MessageList.cacheKeyFromAIV4CoreMessageContent(m.content) === _MessageList.cacheKeyFromAIV4CoreMessageContent(message.content)
     );
   }
-  static mastraMessageV2ToAIV4UIMessage(m) {
+  static mastraDBMessageToAIV4UIMessage(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`) {
@@ -1434,12 +1482,12 @@ var MessageList = class _MessageList {
     return uiMessage;
   }
   /**
-   * Converts a MastraMessageV2 system message directly to AIV4 CoreMessage format
+   * Converts a MastraDBMessage system message directly to AIV4 CoreMessage format
    * This is more efficient than converting to UI message first and then to core
-   * @param message - The MastraMessageV2 message to convert
+   * @param message - The MastraDBMessage message to convert
    * @returns AIV4 CoreMessage with system role
    */
-  static mastraMessageV2SystemToV4Core(message) {
+  static mastraDBMessageSystemToV4Core(message) {
     if (message.role !== `system` || !message.content.content)
       throw new MastraError({
         id: "INVALID_SYSTEM_MESSAGE_FORMAT",
@@ -1486,7 +1534,7 @@ var MessageList = class _MessageList {
     }
     if (message.role === `system`) {
       if (messageSource === `memory`) return null;
-      const isSupportedSystemFormat = _MessageList.isAIV4CoreMessage(message) || _MessageList.isAIV5CoreMessage(message) || _MessageList.isMastraMessageV2(message);
+      const isSupportedSystemFormat = _MessageList.isAIV4CoreMessage(message) || _MessageList.isAIV5CoreMessage(message) || _MessageList.isMastraDBMessage(message);
       if (isSupportedSystemFormat) {
         return this.addSystem(message);
       }
@@ -1501,7 +1549,7 @@ var MessageList = class _MessageList {
         }
       });
     }
-    const messageV2 = this.inputToMastraMessageV2(message, messageSource);
+    const messageV2 = this.inputToMastraDBMessage(message, messageSource);
     const { exists, shouldReplace, id } = this.shouldReplaceMessage(messageV2);
     const latestMessage = this.messages.at(-1);
     if (messageSource === `memory`) {
@@ -1693,7 +1741,7 @@ var MessageList = class _MessageList {
       }
     }
   }
-  inputToMastraMessageV2(message, messageSource) {
+  inputToMastraDBMessage(message, messageSource) {
     if (
       // we can't throw if the threadId doesn't match and this message came from memory
       // this is because per-user semantic recall can retrieve messages from other threads
@@ -1709,25 +1757,33 @@ var MessageList = class _MessageList {
       );
     }
     if (_MessageList.isMastraMessageV1(message)) {
-      return this.mastraMessageV1ToMastraMessageV2(message, messageSource);
+      return this.mastraMessageV1ToMastraDBMessage(message, messageSource);
     }
-    if (_MessageList.isMastraMessageV2(message)) {
-      return this.hydrateMastraMessageV2Fields(message);
+    if (_MessageList.isMastraDBMessage(message)) {
+      return this.hydrateMastraDBMessageFields(message);
     }
     if (_MessageList.isAIV4CoreMessage(message)) {
-      return this.aiV4CoreMessageToMastraMessageV2(message, messageSource);
+      return this.aiV4CoreMessageToMastraDBMessage(message, messageSource);
     }
     if (_MessageList.isAIV4UIMessage(message)) {
-      return this.aiV4UIMessageToMastraMessageV2(message, messageSource);
+      return this.aiV4UIMessageToMastraDBMessage(message, messageSource);
     }
     if (_MessageList.isAIV5CoreMessage(message)) {
-      return _MessageList.mastraMessageV3ToV2(this.aiV5ModelMessageToMastraMessageV3(message, messageSource));
+      const dbMsg = _MessageList.aiV5ModelMessageToMastraDBMessage(message, messageSource);
+      const result = {
+        ...dbMsg,
+        threadId: this.memoryInfo?.threadId,
+        resourceId: this.memoryInfo?.resourceId
+      };
+      return result;
     }
     if (_MessageList.isAIV5UIMessage(message)) {
-      return _MessageList.mastraMessageV3ToV2(this.aiV5UIMessageToMastraMessageV3(message, messageSource));
-    }
-    if (_MessageList.isMastraMessageV3(message)) {
-      return _MessageList.mastraMessageV3ToV2(this.hydrateMastraMessageV3Fields(message));
+      const dbMsg = _MessageList.aiV5UIMessageToMastraDBMessage(message);
+      return {
+        ...dbMsg,
+        threadId: this.memoryInfo?.threadId,
+        resourceId: this.memoryInfo?.resourceId
+      };
     }
     throw new Error(`Found unhandled message ${JSON.stringify(message)}`);
   }
@@ -1760,10 +1816,10 @@ var MessageList = class _MessageList {
     if (this.generateMessageId) {
       return this.generateMessageId();
     }
-    return randomUUID();
+    return v4();
   }
-  mastraMessageV1ToMastraMessageV2(message, messageSource) {
-    const coreV2 = this.aiV4CoreMessageToMastraMessageV2(
+  mastraMessageV1ToMastraDBMessage(message, messageSource) {
+    const coreV2 = this.aiV4CoreMessageToMastraDBMessage(
       {
         content: message.content,
         role: message.role
@@ -1779,11 +1835,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) {
+  hydrateMastraDBMessageFields(message) {
+    if (!message.id) {
+      message.id = this.newMessageId();
+    }
     if (!(message.createdAt instanceof Date)) message.createdAt = new Date(message.createdAt);
     if (message.content.toolInvocations && message.content.parts) {
       message.content.toolInvocations = message.content.toolInvocations.map((ti) => {
@@ -1800,7 +1855,7 @@ var MessageList = class _MessageList {
     }
     return message;
   }
-  aiV4UIMessageToMastraMessageV2(message, messageSource) {
+  aiV4UIMessageToMastraDBMessage(message, messageSource) {
     const content = {
       format: 2,
       parts: message.parts
@@ -1823,7 +1878,7 @@ var MessageList = class _MessageList {
       content
     };
   }
-  aiV4CoreMessageToMastraMessageV2(coreMessage, messageSource) {
+  aiV4CoreMessageToMastraDBMessage(coreMessage, messageSource) {
     const id = `id` in coreMessage ? coreMessage.id : this.newMessageId();
     const parts = [];
     const experimentalAttachments = [];
@@ -1995,21 +2050,16 @@ var MessageList = class _MessageList {
     return !_MessageList.isMastraMessage(msg) && !(`parts` in msg) && `content` in msg && !_MessageList.hasAIV5CoreMessageCharacteristics(msg);
   }
   static isMastraMessage(msg) {
-    return _MessageList.isMastraMessageV3(msg) || _MessageList.isMastraMessageV2(msg) || _MessageList.isMastraMessageV1(msg);
+    return _MessageList.isMastraDBMessage(msg) || _MessageList.isMastraMessageV1(msg);
   }
   static isMastraMessageV1(msg) {
-    return !_MessageList.isMastraMessageV2(msg) && !_MessageList.isMastraMessageV3(msg) && (`threadId` in msg || `resourceId` in msg);
+    return !_MessageList.isMastraDBMessage(msg) && (`threadId` in msg || `resourceId` in msg);
   }
-  static isMastraMessageV2(msg) {
+  static isMastraDBMessage(msg) {
     return Boolean(
       `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`;
@@ -2106,18 +2156,12 @@ var MessageList = class _MessageList {
     if (oneMM1 && twoMM1) {
       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;
+    const oneMM2 = _MessageList.isMastraDBMessage(one) && one;
+    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);
     }
-    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;
@@ -2132,25 +2176,6 @@ var MessageList = class _MessageList {
     }
     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;
@@ -2347,240 +2372,103 @@ var MessageList = class _MessageList {
       `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": {
-              const fileDataSource = "url" in p && typeof p.url === "string" ? p.url : "data" in p && typeof p.data === "string" ? p.data : void 0;
-              if (!fileDataSource) {
-                return null;
-              }
-              if (attachmentUrls.has(fileDataSource)) {
-                return null;
-              }
-              return {
-                type: "file",
-                mimeType: p.mediaType,
-                data: fileDataSource,
-                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) {
-      const hasOnlyTextOrStepStart = v2Msg.content.parts.every((p) => p.type === `step-start` || p.type === `text`);
-      if (typeof originalContent === `string` || hasOnlyTextOrStepStart) {
-        v2Msg.content.content = originalContent;
-      }
-    }
-    const originalAttachments = v3Msg.content.metadata?.__originalExperimentalAttachments;
-    if (originalAttachments && Array.isArray(originalAttachments)) {
-      v2Msg.content.experimental_attachments = originalAttachments || [];
-    }
-    const originalContentIsV5 = Array.isArray(v3Msg.content.metadata?.__originalContent) && v3Msg.content.metadata?.__originalContent.some((part) => part.type === "file");
-    const urlFileParts = originalContentIsV5 ? [] : v2Msg.content.parts.filter(
-      (p) => p.type === "file" && typeof p.data === "string" && (p.data.startsWith("http://") || p.data.startsWith("https://")) && !p.providerMetadata
-      // Don't move if it has providerMetadata (needed for roundtrip)
-    );
-    if (urlFileParts.length > 0) {
-      if (!v2Msg.content.experimental_attachments) {
-        v2Msg.content.experimental_attachments = [];
-      }
-      for (const urlPart of urlFileParts) {
-        if (urlPart.type === "file") {
-          v2Msg.content.experimental_attachments.push({
-            url: urlPart.data,
-            contentType: urlPart.mimeType
+  /**
+   * Direct conversion from MastraDBMessage to AIV5 UIMessage
+   */
+  static mastraDBMessageToAIV5UIMessage(dbMsg) {
+    const parts = [];
+    const metadata = { ...dbMsg.content.metadata || {} };
+    if (dbMsg.createdAt) metadata.createdAt = dbMsg.createdAt;
+    if (dbMsg.threadId) metadata.threadId = dbMsg.threadId;
+    if (dbMsg.resourceId) metadata.resourceId = dbMsg.resourceId;
+    const hasToolInvocationParts = dbMsg.content.parts?.some((p) => p.type === "tool-invocation");
+    if (dbMsg.content.toolInvocations && !hasToolInvocationParts) {
+      for (const invocation of dbMsg.content.toolInvocations) {
+        if (invocation.state === "result") {
+          parts.push({
+            type: `tool-${invocation.toolName}`,
+            toolCallId: invocation.toolCallId,
+            state: "output-available",
+            input: invocation.args,
+            output: invocation.result
+          });
+        } else {
+          parts.push({
+            type: `tool-${invocation.toolName}`,
+            toolCallId: invocation.toolCallId,
+            state: invocation.state === "call" ? "input-available" : "input-streaming",
+            input: invocation.args
           });
         }
       }
-      v2Msg.content.parts = v2Msg.content.parts.filter(
-        (p) => !(p.type === "file" && typeof p.data === "string" && (p.data.startsWith("http://") || p.data.startsWith("https://")) && !p.providerMetadata)
-      );
-    }
-    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
-      };
+    const hasReasoningInParts = dbMsg.content.parts?.some((p) => p.type === "reasoning");
+    const hasFileInParts = dbMsg.content.parts?.some((p) => p.type === "file");
+    if (dbMsg.content.reasoning && !hasReasoningInParts) {
+      parts.push({
+        type: "reasoning",
+        text: dbMsg.content.reasoning
+      });
     }
-    if (v2Msg.content.experimental_attachments !== void 0) {
-      v3Msg.content.metadata = {
-        ...v3Msg.content.metadata || {},
-        __originalExperimentalAttachments: v2Msg.content.experimental_attachments
-      };
+    const attachmentUrls = /* @__PURE__ */ new Set();
+    if (dbMsg.content.experimental_attachments && !hasFileInParts) {
+      for (const attachment of dbMsg.content.experimental_attachments) {
+        attachmentUrls.add(attachment.url);
+        parts.push({
+          type: "file",
+          url: attachment.url,
+          mediaType: attachment.contentType || "unknown"
+        });
+      }
     }
-    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`) {
+    let hasNonToolReasoningParts = false;
+    if (dbMsg.content.parts) {
+      for (const part of dbMsg.content.parts) {
+        if (part.type === "tool-invocation" && part.toolInvocation) {
+          const inv = part.toolInvocation;
+          if (inv.state === "result") {
             parts.push({
-              type: `tool-${part.toolInvocation.toolName}`,
-              toolCallId: part.toolInvocation.toolCallId,
+              type: `tool-${inv.toolName}`,
+              toolCallId: inv.toolCallId,
+              input: inv.args,
+              output: inv.result,
               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
+              type: `tool-${inv.toolName}`,
+              toolCallId: inv.toolCallId,
+              input: inv.args,
+              state: "input-available",
+              callProviderMetadata: part.providerMetadata
             });
           }
-          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;
+          continue;
+        }
+        if (part.type === "reasoning") {
+          const reasoningPart = part;
+          const text = reasoningPart.text || reasoningPart.reasoning || (reasoningPart.details?.reduce((p, c) => {
+            if (c.type === `text` && c.text) return p + c.text;
             return p;
           }, "") ?? "");
-          if (text || part.details?.length) {
+          if (text || reasoningPart.details?.length) {
             parts.push({
               type: "reasoning",
               text: text || "",
               state: "done",
-              providerMetadata: part.providerMetadata
+              ...part.providerMetadata && { providerMetadata: part.providerMetadata }
             });
           }
-          break;
-        case "file": {
+          continue;
+        }
+        if (part.type === "tool-invocation" || part.type.startsWith("tool-")) {
+          continue;
+        }
+        if (part.type === "file") {
+          if (typeof part.data === "string" && attachmentUrls.has(part.data)) {
+            continue;
+          }
           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({
@@ -2589,7 +2477,6 @@ var MessageList = class _MessageList {
               mediaType: categorized.mimeType || "image/png",
               providerMetadata: part.providerMetadata
             });
-            fileUrls.add(part.data);
           } else {
             let filePartData;
             let extractedMimeType = part.mimeType;
@@ -2621,36 +2508,376 @@ var MessageList = class _MessageList {
               providerMetadata: part.providerMetadata
             });
           }
-          fileUrls.add(part.data);
-          break;
+        } else if (part.type === "source") {
+          const sourcePart = part;
+          parts.push({
+            type: "source-url",
+            url: sourcePart.source.url,
+            ...part.providerMetadata && { providerMetadata: part.providerMetadata }
+          });
+        } else if (part.type === "text") {
+          parts.push({
+            type: "text",
+            text: part.text,
+            ...part.providerMetadata && { providerMetadata: part.providerMetadata }
+          });
+          hasNonToolReasoningParts = true;
+        } else {
+          parts.push(part);
+          hasNonToolReasoningParts = true;
         }
       }
     }
-    if (v2Msg.content.content && !v3Msg.content.parts?.some((p) => p.type === `text`)) {
-      v3Msg.content.parts.push({ type: "text", text: v2Msg.content.content });
+    if (dbMsg.content.content && !hasNonToolReasoningParts) {
+      parts.push({ type: "text", text: dbMsg.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"
+    return {
+      id: dbMsg.id,
+      role: dbMsg.role,
+      metadata,
+      parts
+    };
+  }
+  /**
+   * Direct conversion from AIV5 UIMessage to MastraDBMessage
+   * Combines logic from aiV5UIMessageToMastraMessageV3 + mastraMessageV3ToV2
+   */
+  static aiV5UIMessageToMastraDBMessage(uiMsg) {
+    const { parts, metadata: rawMetadata } = uiMsg;
+    const metadata = rawMetadata || {};
+    const createdAtValue = metadata.createdAt;
+    const createdAt = createdAtValue ? typeof createdAtValue === "string" ? new Date(createdAtValue) : createdAtValue instanceof Date ? createdAtValue : /* @__PURE__ */ new Date() : /* @__PURE__ */ new Date();
+    const threadId = metadata.threadId;
+    const resourceId = metadata.resourceId;
+    const cleanMetadata = { ...metadata };
+    delete cleanMetadata.createdAt;
+    delete cleanMetadata.threadId;
+    delete cleanMetadata.resourceId;
+    const toolInvocationParts = parts.filter((p) => AIV5.isToolUIPart(p));
+    const reasoningParts = parts.filter((p) => p.type === "reasoning");
+    const fileParts = parts.filter((p) => p.type === "file");
+    const textParts = parts.filter((p) => p.type === "text");
+    let toolInvocations = void 0;
+    if (toolInvocationParts.length > 0) {
+      toolInvocations = 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,
+          toolCallId: p.toolCallId,
+          toolName,
+          state: "call"
+        };
+      });
+    }
+    let reasoning = void 0;
+    if (reasoningParts.length > 0) {
+      reasoning = reasoningParts.map((p) => p.text).join("\n");
+    }
+    let experimental_attachments = void 0;
+    if (fileParts.length > 0) {
+      experimental_attachments = fileParts.map((p) => ({
+        url: p.url || "",
+        contentType: p.mediaType
+      }));
+    }
+    let content = void 0;
+    if (textParts.length > 0) {
+      content = textParts.map((p) => p.text).join("");
+    }
+    const v2Parts = parts.map((p) => {
+      if (AIV5.isToolUIPart(p)) {
+        const toolName = getToolName(p);
+        const callProviderMetadata = "callProviderMetadata" in p ? p.callProviderMetadata : void 0;
+        if (p.state === "output-available") {
+          return {
+            type: "tool-invocation",
+            toolInvocation: {
+              toolCallId: p.toolCallId,
+              toolName,
+              args: p.input,
+              result: typeof p.output === "object" && p.output && "value" in p.output ? p.output.value : p.output,
+              state: "result"
+            },
+            providerMetadata: callProviderMetadata
+          };
+        }
+        return {
+          type: "tool-invocation",
+          toolInvocation: {
+            toolCallId: p.toolCallId,
+            toolName,
+            args: p.input,
+            state: "call"
+          },
+          providerMetadata: callProviderMetadata
+        };
+      }
+      if (p.type === "reasoning") {
+        return {
+          type: "reasoning",
+          reasoning: "",
+          details: [
+            {
+              type: "text",
+              text: p.text
+            }
+          ],
+          providerMetadata: p.providerMetadata
+        };
+      }
+      if (p.type === "file") {
+        return {
+          type: "file",
+          mimeType: p.mediaType,
+          data: p.url || "",
+          providerMetadata: p.providerMetadata
+        };
+      }
+      if (p.type === "source-url") {
+        return {
+          type: "source",
+          source: {
+            url: p.url,
+            sourceType: "url",
+            id: p.url,
+            // Use URL as ID
+            providerMetadata: p.providerMetadata
+          },
+          providerMetadata: p.providerMetadata
+        };
+      }
+      if (p.type === "text") {
+        return {
+          type: "text",
+          text: p.text,
+          providerMetadata: p.providerMetadata
+        };
+      }
+      if (p.type === "step-start") {
+        return p;
+      }
+      return null;
+    }).filter((p) => p !== null);
+    return {
+      id: uiMsg.id,
+      role: uiMsg.role,
+      createdAt,
+      threadId,
+      resourceId,
+      content: {
+        format: 2,
+        parts: v2Parts,
+        toolInvocations,
+        reasoning,
+        experimental_attachments,
+        content,
+        metadata: Object.keys(cleanMetadata).length > 0 ? cleanMetadata : void 0
+      }
+    };
+  }
+  /**
+   * 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 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 }
+        };
+        v2Parts.push(textPart);
+        textParts.push({ text: part.text, providerMetadata: hasProviderMetadata ? providerMetadata : void 0 });
+        lastPartWasToolResult = false;
+      } else if (part.type === "tool-call") {
+        const toolCallPart = part;
+        const toolInvocationPart = {
+          type: "tool-invocation",
+          toolInvocation: {
+            toolCallId: toolCallPart.toolCallId,
+            toolName: toolCallPart.toolName,
+            args: toolCallPart.input,
+            state: "call"
+          },
+          ...hasProviderMetadata && { providerMetadata }
+        };
+        v2Parts.push(toolInvocationPart);
+        toolInvocations.push({
+          toolCallId: toolCallPart.toolCallId,
+          toolName: toolCallPart.toolName,
+          args: toolCallPart.input,
+          state: "call"
         });
+        lastPartWasToolResult = false;
+      } else if (part.type === "tool-result") {
+        const toolResultPart = part;
+        const matchingCall = toolInvocations.find((inv) => inv.toolCallId === toolResultPart.toolCallId);
+        const matchingV2Part = v2Parts.find(
+          (p) => p.type === "tool-invocation" && "toolInvocation" in p && p.toolInvocation.toolCallId === toolResultPart.toolCallId
+        );
+        if (matchingCall) {
+          matchingCall.state = "result";
+          matchingCall.result = typeof toolResultPart.output === "object" && toolResultPart.output && "value" in toolResultPart.output ? toolResultPart.output.value : toolResultPart.output;
+        } else {
+          const resultPartWithName = toolResultPart;
+          toolInvocations.push({
+            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"
+          });
+        }
+        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;
+          }
+        } else {
+          const resultPartWithName = toolResultPart;
+          const toolInvocationPart = {
+            type: "tool-invocation",
+            toolInvocation: {
+              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"
+            },
+            ...hasProviderMetadata && { providerMetadata }
+          };
+          v2Parts.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 }
+        };
+        v2Parts.push(v2ReasoningPart);
+        reasoningParts.push(reasoningPart.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 imageFilePart = {
+          type: "file",
+          data: imageData,
+          mimeType,
+          ...hasProviderMetadata && { providerMetadata }
+        };
+        v2Parts.push(imageFilePart);
+        experimental_attachments.push({
+          url: imageData,
+          contentType: mimeType
+        });
+        lastPartWasToolResult = false;
+      } 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 v2FilePart = {
+          type: "file",
+          data: fileData,
+          mimeType,
+          ...hasProviderMetadata && { providerMetadata }
+        };
+        v2Parts.push(v2FilePart);
+        experimental_attachments.push({
+          url: fileData,
+          contentType: mimeType
+        });
+        lastPartWasToolResult = false;
       }
     }
-    if (attachmentUrls.length > 0) {
-      v3Msg.content.metadata = {
-        ...v3Msg.content.metadata || {},
-        __attachmentUrls: attachmentUrls
-      };
+    if (modelMsg.role === "assistant" && lastPartWasToolResult && v2Parts.length > 0) {
+      const lastPart = v2Parts[v2Parts.length - 1];
+      if (lastPart && lastPart.type !== "text") {
+        const emptyTextPart = { type: "text", text: "" };
+        v2Parts.push(emptyTextPart);
+        textParts.push({ text: "" });
+      }
+    }
+    let contentString = void 0;
+    if (textParts.length > 0) {
+      contentString = textParts.map((p) => p.text).join("\n");
     }
-    return v3Msg;
+    const metadata = {};
+    const id = `id` in modelMsg && typeof modelMsg.id === `string` ? modelMsg.id : `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    return {
+      id,
+      role: _MessageList.getRole(modelMsg),
+      createdAt: /* @__PURE__ */ new Date(),
+      content: {
+        format: 2,
+        parts: v2Parts,
+        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
+      }
+    };
+  }
+  aiV4CoreMessagesToAIV5ModelMessages(messages, source) {
+    return this.aiV5UIMessagesToAIV5ModelMessages(
+      messages.map((m) => this.aiV4CoreMessageToMastraDBMessage(m, source)).map((m) => _MessageList.mastraDBMessageToAIV5UIMessage(m))
+    );
   }
-  aiV5UIMessagesToAIV5ModelMessages(messages) {
-    const preprocessed = this.addStartStepPartsForAIV5(this.sanitizeV5UIMessages(messages));
+  aiV5UIMessagesToAIV5ModelMessages(messages, filterIncompleteToolCalls = false) {
+    const sanitized = this.sanitizeV5UIMessages(messages, filterIncompleteToolCalls);
+    const preprocessed = this.addStartStepPartsForAIV5(sanitized);
     const result = AIV5.convertToModelMessages(preprocessed);
     return result;
   }
@@ -2666,12 +2893,15 @@ var MessageList = class _MessageList {
     }
     return messages;
   }
-  sanitizeV5UIMessages(messages) {
+  sanitizeV5UIMessages(messages, filterIncompleteToolCalls = false) {
     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 (filterIncompleteToolCalls) {
+          return p.state === "output-available" || p.state === "output-error";
+        }
+        return p.state !== "input-streaming";
       });
       if (!safeParts.length) return false;
       const sanitized = {
@@ -2690,242 +2920,6 @@ var MessageList = class _MessageList {
     }).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 (typeof coreMessage.content === "string") {
-      parts.push({
-        type: "text",
-        text: coreMessage.content,
-        // Preserve providerOptions from ModelMessage level (e.g., system messages with cacheControl)
-        ..."providerOptions" in coreMessage && coreMessage.providerOptions ? { providerMetadata: coreMessage.providerOptions } : {}
-      });
-    } else if (Array.isArray(coreMessage.content)) {
-      for (const part of coreMessage.content) {
-        switch (part.type) {
-          case "text":
-            const prevPart = parts.at(-1);
-            if (coreMessage.role === "assistant" && prevPart && AIV5.isToolUIPart(prevPart) && prevPart.state === "output-available") {
-              parts.push({
-                type: "step-start"
-              });
-            }
-            const mergedProviderMetadataV3 = {
-              ..."providerOptions" in coreMessage && coreMessage.providerOptions ? coreMessage.providerOptions : {},
-              ...part.providerOptions || {}
-            };
-            parts.push({
-              type: "text",
-              text: part.text,
-              ...Object.keys(mergedProviderMetadataV3).length > 0 ? { providerMetadata: mergedProviderMetadataV3 } : {}
-            });
-            break;
-          case "tool-call":
-            parts.push({
-              type: `tool-${part.toolName}`,
-              state: "input-available",
-              toolCallId: part.toolCallId,
-              input: part.input
-            });
-            break;
-          case "tool-result":
-            parts.push({
-              type: `tool-${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": {
-            let imageData;
-            let extractedMimeType = part.mediaType;
-            const imageStr = imageContentToDataUri(part.image, extractedMimeType || "image/png");
-            const parsed = parseDataUri(imageStr);
-            if (parsed.isDataUri) {
-              imageData = parsed.base64Content;
-              if (!extractedMimeType && parsed.mimeType) {
-                extractedMimeType = parsed.mimeType;
-              }
-            } else if (imageStr.startsWith("http://") || imageStr.startsWith("https://")) {
-              parts.push({
-                type: "file",
-                url: imageStr,
-                mediaType: part.mediaType || "image/jpeg",
-                // Default to image/jpeg for URLs
-                providerMetadata: part.providerOptions
-              });
-              break;
-            } else {
-              imageData = imageStr;
-            }
-            const finalMimeType = extractedMimeType || "image/jpeg";
-            const dataUri = imageData.startsWith("data:") ? imageData : createDataUri(imageData, finalMimeType);
-            parts.push({
-              type: "file",
-              url: dataUri,
-              mediaType: finalMimeType,
-              providerMetadata: part.providerOptions
-            });
-            break;
-          }
-          case "file": {
-            if (part.data instanceof URL) {
-              const urlStr = part.data.toString();
-              let extractedMimeType = part.mediaType;
-              const parsed = parseDataUri(urlStr);
-              if (parsed.isDataUri) {
-                if (!extractedMimeType && parsed.mimeType) {
-                  extractedMimeType = parsed.mimeType;
-                }
-                if (parsed.base64Content !== urlStr) {
-                  const dataUri = createDataUri(parsed.base64Content, extractedMimeType || "image/png");
-                  parts.push({
-                    type: "file",
-                    url: dataUri,
-                    mediaType: extractedMimeType || "image/png",
-                    providerMetadata: part.providerOptions
-                  });
-                } else {
-                  parts.push({
-                    type: "file",
-                    url: urlStr,
-                    mediaType: part.mediaType || "image/png",
-                    providerMetadata: part.providerOptions
-                  });
-                }
-              } else {
-                parts.push({
-                  type: "file",
-                  url: urlStr,
-                  mediaType: part.mediaType || "application/octet-stream",
-                  providerMetadata: part.providerOptions
-                });
-              }
-            } else if (typeof part.data === "string") {
-              const categorized = categorizeFileData(part.data, part.mediaType);
-              if (categorized.type === "url" || categorized.type === "dataUri") {
-                parts.push({
-                  type: "file",
-                  url: part.data,
-                  mediaType: categorized.mimeType || "application/octet-stream",
-                  providerMetadata: part.providerOptions
-                });
-              } else {
-                try {
-                  const base64Data = convertDataContentToBase64String(part.data);
-                  const dataUri = createDataUri(base64Data, categorized.mimeType || "image/png");
-                  parts.push({
-                    type: "file",
-                    url: dataUri,
-                    mediaType: categorized.mimeType || "image/png",
-                    providerMetadata: part.providerOptions
-                  });
-                } catch (error) {
-                  console.error(`Failed to convert binary data to base64 in CoreMessage file part: ${error}`, error);
-                }
-              }
-            } else {
-              try {
-                const base64Data = convertDataContentToBase64String(part.data);
-                const dataUri = createDataUri(base64Data, part.mediaType || "image/png");
-                parts.push({
-                  type: "file",
-                  url: dataUri,
-                  mediaType: part.mediaType || "image/png",
-                  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;
@@ -3017,34 +3011,6 @@ var MessageList = class _MessageList {
   }
 };
 
-// src/agent/message-list/utils/convert-messages.ts
-var MessageConverter = class {
-  messageList;
-  constructor(messages) {
-    this.messageList = new MessageList();
-    this.messageList.add(messages, "memory");
-  }
-  to(format) {
-    switch (format) {
-      case "Mastra.V2":
-        return this.messageList.get.all.v2();
-      case "AIV4.UI":
-        return this.messageList.get.all.aiV4.ui();
-      case "AIV4.Core":
-        return this.messageList.get.all.aiV4.core();
-      case "AIV5.UI":
-        return this.messageList.get.all.aiV5.ui();
-      case "AIV5.Model":
-        return this.messageList.get.all.aiV5.model();
-      default:
-        throw new Error(`Unsupported output format: ${format}`);
-    }
-  }
-};
-function convertMessages(messages) {
-  return new MessageConverter(messages);
-}
-
 export { DefaultGeneratedFile, DefaultGeneratedFileWithType, MessageList, convertMessages };
-//# sourceMappingURL=chunk-E3PG7G6E.js.map
-//# sourceMappingURL=chunk-E3PG7G6E.js.map
+//# sourceMappingURL=chunk-JV2KH24V.js.map
+//# sourceMappingURL=chunk-JV2KH24V.js.map