@mastra/server 0.0.0-playground-studio-cloud-20251031080052 → 0.0.0-playground-studio-again-20251114100107

package/dist/{chunk-Y7SH5ZKM.cjs → chunk-U7GLIXYO.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunkG4PUALCE_cjs = require('./chunk-G4PUALCE.cjs');
-var chunkRE4RPXT2_cjs = require('./chunk-RE4RPXT2.cjs');
-var chunk7NADHFD2_cjs = require('./chunk-7NADHFD2.cjs');
+var chunkBTWIR2B7_cjs = require('./chunk-BTWIR2B7.cjs');
+var chunkV5WWQN7P_cjs = require('./chunk-V5WWQN7P.cjs');
+var chunk64ITUOXI_cjs = require('./chunk-64ITUOXI.cjs');
 var chunkO7I5CWRX_cjs = require('./chunk-O7I5CWRX.cjs');
-var agent = require('@mastra/core/agent');
+var di = require('@mastra/core/di');
 var utils = require('@mastra/core/utils');
 
 // src/server/handlers/memory.ts
@@ -15,34 +15,43 @@ chunkO7I5CWRX_cjs.__export(memory_exports, {
   deleteThreadHandler: () => deleteThreadHandler,
   getMemoryConfigHandler: () => getMemoryConfigHandler,
   getMemoryStatusHandler: () => getMemoryStatusHandler,
-  getMessagesHandler: () => getMessagesHandler,
-  getMessagesPaginatedHandler: () => getMessagesPaginatedHandler,
+  getTextContent: () => getTextContent,
   getThreadByIdHandler: () => getThreadByIdHandler,
-  getThreadsHandler: () => getThreadsHandler,
-  getThreadsPaginatedHandler: () => getThreadsPaginatedHandler,
   getWorkingMemoryHandler: () => getWorkingMemoryHandler,
+  listMessagesHandler: () => listMessagesHandler,
+  listThreadsHandler: () => listThreadsHandler,
   saveMessagesHandler: () => saveMessagesHandler,
   searchMemoryHandler: () => searchMemoryHandler,
   updateThreadHandler: () => updateThreadHandler,
   updateWorkingMemoryHandler: () => updateWorkingMemoryHandler
 });
+function getTextContent(message) {
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  if (message.content && typeof message.content === "object" && "parts" in message.content) {
+    const textPart = message.content.parts.find((p) => p.type === "text");
+    return textPart?.text || "";
+  }
+  return "";
+}
 async function getMemoryFromContext({
   mastra,
   agentId,
-  runtimeContext
+  requestContext
 }) {
   const logger = mastra.getLogger();
   let agent;
   if (agentId) {
     try {
-      agent = mastra.getAgent(agentId);
+      agent = mastra.getAgentById(agentId);
     } catch (error) {
       logger.debug("Error getting agent from mastra, searching agents for agent", error);
     }
   }
   if (agentId && !agent) {
     logger.debug("Agent not found, searching agents for agent", { agentId });
-    const agents = mastra.getAgents();
+    const agents = mastra.listAgents();
     if (Object.keys(agents || {}).length) {
       for (const [_, ag] of Object.entries(agents)) {
         try {
@@ -57,140 +66,113 @@ async function getMemoryFromContext({
       }
     }
     if (!agent) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Agent not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Agent not found" });
     }
   }
   if (agent) {
     return await agent?.getMemory({
-      runtimeContext
-    }) || mastra.getMemory();
+      requestContext: requestContext ?? new di.RequestContext()
+    });
   }
-  return mastra.getMemory();
 }
 async function getMemoryStatusHandler({
   mastra,
   agentId,
-  runtimeContext
+  requestContext
 }) {
   try {
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
       return { result: false };
     }
     return { result: true };
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting memory status");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error getting memory status");
   }
 }
 async function getMemoryConfigHandler({
   mastra,
   agentId,
-  runtimeContext
+  requestContext
 }) {
   try {
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     const config = memory.getMergedThreadConfig({});
     return { config };
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting memory configuration");
-  }
-}
-async function getThreadsHandler({
-  mastra,
-  agentId,
-  resourceId,
-  runtimeContext,
-  orderBy,
-  sortDirection
-}) {
-  try {
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
-    if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
-    }
-    chunkG4PUALCE_cjs.validateBody({ resourceId });
-    const threads = await memory.getThreadsByResourceId({
-      resourceId,
-      orderBy,
-      sortDirection
-    });
-    return threads;
-  } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting threads");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error getting memory configuration");
   }
 }
-async function getThreadsPaginatedHandler({
+async function listThreadsHandler({
   mastra,
   agentId,
   resourceId,
-  runtimeContext,
+  requestContext,
   page,
   perPage,
-  orderBy,
-  sortDirection
+  orderBy
 }) {
   try {
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
-    chunkG4PUALCE_cjs.validateBody({ resourceId });
-    const result = await memory.getThreadsByResourceIdPaginated({
+    chunkBTWIR2B7_cjs.validateBody({ resourceId });
+    const result = await memory.listThreadsByResourceId({
       resourceId,
       page,
       perPage,
-      orderBy,
-      sortDirection
+      orderBy
     });
     return result;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting paginated threads");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error listing threads");
   }
 }
 async function getThreadByIdHandler({
   mastra,
   agentId,
   threadId,
-  runtimeContext
+  requestContext
 }) {
   try {
-    chunkG4PUALCE_cjs.validateBody({ threadId });
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    chunkBTWIR2B7_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     const thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Thread not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
     }
     return thread;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting thread");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error getting thread");
   }
 }
 async function saveMessagesHandler({
   mastra,
   agentId,
   body,
-  runtimeContext
+  requestContext
 }) {
   try {
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     if (!body?.messages) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Messages are required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Messages are required" });
     }
     if (!Array.isArray(body.messages)) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Messages should be an array" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Messages should be an array" });
     }
     const invalidMessages = body.messages.filter((message) => !message.threadId || !message.resourceId);
     if (invalidMessages.length > 0) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, {
+      throw new chunk64ITUOXI_cjs.HTTPException(400, {
         message: `All messages must have threadId and resourceId fields. Found ${invalidMessages.length} invalid message(s).`
       });
     }
@@ -202,21 +184,21 @@ async function saveMessagesHandler({
     const result = await memory.saveMessages({ messages: processedMessages, memoryConfig: {} });
     return result;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error saving messages");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error saving messages");
   }
 }
 async function createThreadHandler({
   mastra,
   agentId,
   body,
-  runtimeContext
+  requestContext
 }) {
   try {
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
-    chunkG4PUALCE_cjs.validateBody({ resourceId: body?.resourceId });
+    chunkBTWIR2B7_cjs.validateBody({ resourceId: body?.resourceId });
     const result = await memory.createThread({
       resourceId: body?.resourceId,
       title: body?.title,
@@ -225,7 +207,7 @@ async function createThreadHandler({
     });
     return result;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error saving thread to memory");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error saving thread to memory");
   }
 }
 async function updateThreadHandler({
@@ -233,22 +215,22 @@ async function updateThreadHandler({
   agentId,
   threadId,
   body,
-  runtimeContext
+  requestContext
 }) {
   try {
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!body) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Body is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Body is required" });
     }
     const { title, metadata, resourceId } = body;
     const updatedAt = /* @__PURE__ */ new Date();
-    chunkG4PUALCE_cjs.validateBody({ threadId });
+    chunkBTWIR2B7_cjs.validateBody({ threadId });
     if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     const thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Thread not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
     }
     const updatedThread = {
       ...thread,
@@ -261,82 +243,68 @@ async function updateThreadHandler({
     const result = await memory.saveThread({ thread: updatedThread });
     return result;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error updating thread");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error updating thread");
   }
 }
 async function deleteThreadHandler({
   mastra,
   agentId,
   threadId,
-  runtimeContext
+  requestContext
 }) {
   try {
-    chunkG4PUALCE_cjs.validateBody({ threadId });
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    chunkBTWIR2B7_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     const thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Thread not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
     }
     await memory.deleteThread(threadId);
     return { result: "Thread deleted" };
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error deleting thread");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error deleting thread");
   }
 }
-async function getMessagesPaginatedHandler({
-  mastra,
-  threadId,
-  resourceId,
-  selectBy,
-  format
-}) {
-  try {
-    chunkG4PUALCE_cjs.validateBody({ threadId });
-    const storage = mastra.getStorage();
-    if (!storage) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Storage is not initialized" });
-    }
-    const thread = await storage.getThreadById({ threadId });
-    if (!thread) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Thread not found" });
-    }
-    const result = await storage.getMessagesPaginated({ threadId, resourceId, selectBy, format });
-    return result;
-  } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting messages");
-  }
-}
-async function getMessagesHandler({
+async function listMessagesHandler({
   mastra,
   agentId,
   threadId,
-  limit,
-  runtimeContext
+  resourceId,
+  perPage,
+  page,
+  orderBy,
+  include,
+  filter,
+  requestContext
 }) {
-  if (limit !== void 0 && (!Number.isInteger(limit) || limit <= 0)) {
-    throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Invalid limit: must be a positive integer" });
-  }
   try {
-    chunkG4PUALCE_cjs.validateBody({ threadId });
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    chunkBTWIR2B7_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    if (!threadId) {
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "No threadId found" });
     }
     const thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Thread not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
     }
-    const result = await memory.query({
+    const result = await memory.recall({
       threadId,
-      ...limit && { selectBy: { last: limit } }
+      resourceId,
+      perPage,
+      page,
+      orderBy,
+      include,
+      filter
     });
-    const uiMessages = agent.convertMessages(result.messagesV2).to("AIV5.UI");
-    return { messages: result.messages, uiMessages, legacyMessages: result.uiMessages };
+    return result;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting messages");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error getting messages");
   }
 }
 async function getWorkingMemoryHandler({
@@ -344,14 +312,14 @@ async function getWorkingMemoryHandler({
   agentId,
   threadId,
   resourceId,
-  runtimeContext,
+  requestContext,
   memoryConfig
 }) {
   try {
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
-    chunkG4PUALCE_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
+    chunkBTWIR2B7_cjs.validateBody({ threadId });
     if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     const thread = await memory.getThreadById({ threadId });
     const threadExists = !!thread;
@@ -362,7 +330,7 @@ async function getWorkingMemoryHandler({
     const source = config.workingMemory?.scope !== "thread" && resourceId ? "resource" : "thread";
     return { workingMemory, source, workingMemoryTemplate, threadExists };
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting working memory");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error getting working memory");
   }
 }
 async function updateWorkingMemoryHandler({
@@ -370,47 +338,52 @@ async function updateWorkingMemoryHandler({
   agentId,
   threadId,
   body,
-  runtimeContext
+  requestContext
 }) {
   try {
-    chunkG4PUALCE_cjs.validateBody({ threadId });
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    chunkBTWIR2B7_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     const { resourceId, memoryConfig, workingMemory } = body;
     if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     const thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Thread not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
     }
     await memory.updateWorkingMemory({ threadId, resourceId, workingMemory, memoryConfig });
     return { success: true };
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error updating working memory");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error updating working memory");
   }
 }
 async function deleteMessagesHandler({
   mastra,
   agentId,
   messageIds,
-  runtimeContext
+  requestContext
 }) {
   try {
     if (messageIds === void 0 || messageIds === null) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "messageIds is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "messageIds is required" });
     }
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
-    await memory.deleteMessages(messageIds);
-    let count = 1;
+    let normalizedIds;
     if (Array.isArray(messageIds)) {
-      count = messageIds.length;
-    }
+      normalizedIds = messageIds;
+    } else if (typeof messageIds === "string") {
+      normalizedIds = [messageIds];
+    } else {
+      normalizedIds = [messageIds];
+    }
+    await memory.deleteMessages(normalizedIds);
+    const count = Array.isArray(messageIds) ? messageIds.length : 1;
     return { success: true, message: `${count} message${count === 1 ? "" : "s"} deleted successfully` };
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error deleting messages");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error deleting messages");
   }
 }
 async function searchMemoryHandler({
@@ -420,14 +393,14 @@ async function searchMemoryHandler({
   resourceId,
   threadId,
   limit = 20,
-  runtimeContext,
+  requestContext,
   memoryConfig
 }) {
   try {
-    chunkG4PUALCE_cjs.validateBody({ searchQuery, resourceId });
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    chunkBTWIR2B7_cjs.validateBody({ searchQuery, resourceId });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     const config = memory.getMergedThreadConfig(memoryConfig || {});
     const hasSemanticRecall = !!config?.semanticRecall;
@@ -435,10 +408,10 @@ async function searchMemoryHandler({
     if (threadId && !resourceScope) {
       const thread = await memory.getThreadById({ threadId });
       if (!thread) {
-        throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Thread not found" });
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Thread not found" });
       }
       if (thread.resourceId !== resourceId) {
-        throw new chunk7NADHFD2_cjs.HTTPException(403, { message: "Thread does not belong to the specified resource" });
+        throw new chunk64ITUOXI_cjs.HTTPException(403, { message: "Thread does not belong to the specified resource" });
       }
     }
     const searchResults = [];
@@ -455,8 +428,13 @@ async function searchMemoryHandler({
       }
     }
     if (!threadId) {
-      const threads2 = await memory.getThreadsByResourceId({ resourceId });
-      if (threads2.length === 0) {
+      const { threads } = await memory.listThreadsByResourceId({
+        resourceId,
+        page: 0,
+        perPage: 1,
+        orderBy: { field: "updatedAt", direction: "DESC" }
+      });
+      if (threads.length === 0) {
         return {
           results: [],
           count: 0,
@@ -465,7 +443,7 @@ async function searchMemoryHandler({
           searchType: hasSemanticRecall ? "semantic" : "text"
         };
       }
-      threadId = threads2[0].id;
+      threadId = threads[0].id;
     }
     const beforeRange = typeof config.semanticRecall === `boolean` ? 2 : typeof config.semanticRecall?.messageRange === `number` ? config.semanticRecall.messageRange : config.semanticRecall?.messageRange.before || 2;
     const afterRange = typeof config.semanticRecall === `boolean` ? 2 : typeof config.semanticRecall?.messageRange === `number` ? config.semanticRecall.messageRange : config.semanticRecall?.messageRange.after || 2;
@@ -476,19 +454,27 @@ async function searchMemoryHandler({
         { messageRange: 0, topK: 2, scope: "resource" }
       ) : { ...config.semanticRecall, messageRange: 0 };
     }
-    const result = await memory.rememberMessages({
+    const threadConfig = memory.getMergedThreadConfig(config || {});
+    if (!threadConfig.lastMessages && !threadConfig.semanticRecall) {
+      return { results: [], count: 0, query: searchQuery };
+    }
+    const result = await memory.recall({
       threadId,
       resourceId,
-      vectorMessageSearch: searchQuery,
-      config
+      perPage: threadConfig.lastMessages,
+      threadConfig: config,
+      vectorSearchString: threadConfig.semanticRecall && searchQuery ? searchQuery : void 0
     });
-    const threads = await memory.getThreadsByResourceId({ resourceId });
-    const threadMap = new Map(threads.map((t) => [t.id, t]));
-    for (const msg of result.messagesV2) {
-      const content = typeof msg.content.content === `string` ? msg.content.content : msg.content.parts?.map((p) => p.type === "text" ? p.text : "").join(" ") || "";
+    const threadIds = Array.from(
+      new Set(result.messages.map((m) => m.threadId || threadId).filter(Boolean))
+    );
+    const fetched = await Promise.all(threadIds.map((id) => memory.getThreadById({ threadId: id })));
+    const threadMap = new Map(fetched.filter(Boolean).map((t) => [t.id, t]));
+    for (const msg of result.messages) {
+      const content = getTextContent(msg);
       const msgThreadId = msg.threadId || threadId;
       const thread = threadMap.get(msgThreadId);
-      const threadMessages = (await memory.query({ threadId: msgThreadId })).uiMessages;
+      const threadMessages = (await memory.recall({ threadId: msgThreadId })).messages;
       const messageIndex = threadMessages.findIndex((m) => m.id === msg.id);
       const searchResult = {
         id: msg.id,
@@ -503,13 +489,13 @@ async function searchMemoryHandler({
           before: threadMessages.slice(Math.max(0, messageIndex - beforeRange), messageIndex).map((m) => ({
             id: m.id,
             role: m.role,
-            content: m.content,
+            content: getTextContent(m),
             createdAt: m.createdAt || /* @__PURE__ */ new Date()
           })),
           after: threadMessages.slice(messageIndex + 1, messageIndex + afterRange + 1).map((m) => ({
             id: m.id,
             role: m.role,
-            content: m.content,
+            content: getTextContent(m),
             createdAt: m.createdAt || /* @__PURE__ */ new Date()
           }))
         };
@@ -525,7 +511,7 @@ async function searchMemoryHandler({
       searchType: hasSemanticRecall ? "semantic" : "text"
     };
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error searching memory");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error searching memory");
   }
 }
 
@@ -534,16 +520,15 @@ exports.deleteMessagesHandler = deleteMessagesHandler;
 exports.deleteThreadHandler = deleteThreadHandler;
 exports.getMemoryConfigHandler = getMemoryConfigHandler;
 exports.getMemoryStatusHandler = getMemoryStatusHandler;
-exports.getMessagesHandler = getMessagesHandler;
-exports.getMessagesPaginatedHandler = getMessagesPaginatedHandler;
+exports.getTextContent = getTextContent;
 exports.getThreadByIdHandler = getThreadByIdHandler;
-exports.getThreadsHandler = getThreadsHandler;
-exports.getThreadsPaginatedHandler = getThreadsPaginatedHandler;
 exports.getWorkingMemoryHandler = getWorkingMemoryHandler;
+exports.listMessagesHandler = listMessagesHandler;
+exports.listThreadsHandler = listThreadsHandler;
 exports.memory_exports = memory_exports;
 exports.saveMessagesHandler = saveMessagesHandler;
 exports.searchMemoryHandler = searchMemoryHandler;
 exports.updateThreadHandler = updateThreadHandler;
 exports.updateWorkingMemoryHandler = updateWorkingMemoryHandler;
-//# sourceMappingURL=chunk-Y7SH5ZKM.cjs.map
-//# sourceMappingURL=chunk-Y7SH5ZKM.cjs.map
+//# sourceMappingURL=chunk-U7GLIXYO.cjs.map
+//# sourceMappingURL=chunk-U7GLIXYO.cjs.map