@mastra/server 0.0.0-error-handler-fix-20251020202607 → 0.0.0-export-agent-memory-from-local-studio-20251112153946

package/dist/{chunk-OEOGYAQC.js → chunk-4JF5WXPL.js}

@@ -1,8 +1,8 @@
-import { validateBody } from './chunk-4QCXUEAT.js';
-import { handleError } from './chunk-CY4TP3FK.js';
-import { HTTPException } from './chunk-MMROOK5J.js';
+import { validateBody } from './chunk-SZIFSF4T.js';
+import { handleError } from './chunk-UXGQZUYZ.js';
+import { HTTPException } from './chunk-6QWQZI4Q.js';
 import { __export } from './chunk-PR4QN5HX.js';
-import { convertMessages } from '@mastra/core/agent';
+import { RequestContext } from '@mastra/core/di';
 import { generateEmptyFromSchema } from '@mastra/core/utils';
 
 // src/server/handlers/memory.ts
@@ -13,12 +13,10 @@ __export(memory_exports, {
   deleteThreadHandler: () => deleteThreadHandler,
   getMemoryConfigHandler: () => getMemoryConfigHandler,
   getMemoryStatusHandler: () => getMemoryStatusHandler,
-  getMessagesHandler: () => getMessagesHandler,
-  getMessagesPaginatedHandler: () => getMessagesPaginatedHandler,
   getThreadByIdHandler: () => getThreadByIdHandler,
-  getThreadsHandler: () => getThreadsHandler,
-  getThreadsPaginatedHandler: () => getThreadsPaginatedHandler,
   getWorkingMemoryHandler: () => getWorkingMemoryHandler,
+  listMessagesHandler: () => listMessagesHandler,
+  listThreadsHandler: () => listThreadsHandler,
   saveMessagesHandler: () => saveMessagesHandler,
   searchMemoryHandler: () => searchMemoryHandler,
   updateThreadHandler: () => updateThreadHandler,
@@ -27,26 +25,50 @@ __export(memory_exports, {
 async function getMemoryFromContext({
   mastra,
   agentId,
-  runtimeContext
+  requestContext
 }) {
-  const agent = agentId ? mastra.getAgent(agentId) : null;
+  const logger = mastra.getLogger();
+  let agent;
+  if (agentId) {
+    try {
+      agent = mastra.getAgentById(agentId);
+    } catch (error) {
+      logger.debug("Error getting agent from mastra, searching agents for agent", error);
+    }
+  }
   if (agentId && !agent) {
-    throw new HTTPException(404, { message: "Agent not found" });
+    logger.debug("Agent not found, searching agents for agent", { agentId });
+    const agents = mastra.listAgents();
+    if (Object.keys(agents || {}).length) {
+      for (const [_, ag] of Object.entries(agents)) {
+        try {
+          const agents2 = await ag.listAgents();
+          if (agents2[agentId]) {
+            agent = agents2[agentId];
+            break;
+          }
+        } catch (error) {
+          logger.debug("Error getting agent from agent", error);
+        }
+      }
+    }
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
   }
   if (agent) {
     return await agent?.getMemory({
-      runtimeContext
-    }) || mastra.getMemory();
+      requestContext: requestContext ?? new 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 };
     }
@@ -58,10 +80,10 @@ async function getMemoryStatusHandler({
 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 HTTPException(400, { message: "Memory is not initialized" });
     }
@@ -71,67 +93,41 @@ async function getMemoryConfigHandler({
     return 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 HTTPException(400, { message: "Memory is not initialized" });
-    }
-    validateBody({ resourceId });
-    const threads = await memory.getThreadsByResourceId({
-      resourceId,
-      orderBy,
-      sortDirection
-    });
-    return threads;
-  } catch (error) {
-    return handleError(error, "Error getting threads");
-  }
-}
-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 HTTPException(400, { message: "Memory is not initialized" });
     }
     validateBody({ resourceId });
-    const result = await memory.getThreadsByResourceIdPaginated({
+    const result = await memory.listThreadsByResourceId({
       resourceId,
       page,
       perPage,
-      orderBy,
-      sortDirection
+      orderBy
     });
     return result;
   } catch (error) {
-    return handleError(error, "Error getting paginated threads");
+    return handleError(error, "Error listing threads");
   }
 }
 async function getThreadByIdHandler({
   mastra,
   agentId,
   threadId,
-  runtimeContext
+  requestContext
 }) {
   try {
     validateBody({ threadId });
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
     }
@@ -148,10 +144,10 @@ 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 HTTPException(400, { message: "Memory is not initialized" });
     }
@@ -182,10 +178,10 @@ 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 HTTPException(400, { message: "Memory is not initialized" });
     }
@@ -206,10 +202,10 @@ 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 HTTPException(400, { message: "Body is required" });
     }
@@ -241,11 +237,11 @@ async function deleteThreadHandler({
   mastra,
   agentId,
   threadId,
-  runtimeContext
+  requestContext
 }) {
   try {
     validateBody({ threadId });
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
     }
@@ -259,55 +255,41 @@ async function deleteThreadHandler({
     return handleError(error, "Error deleting thread");
   }
 }
-async function getMessagesPaginatedHandler({
-  mastra,
-  threadId,
-  resourceId,
-  selectBy,
-  format
-}) {
-  try {
-    validateBody({ threadId });
-    const storage = mastra.getStorage();
-    if (!storage) {
-      throw new HTTPException(400, { message: "Storage is not initialized" });
-    }
-    const thread = await storage.getThreadById({ threadId });
-    if (!thread) {
-      throw new HTTPException(404, { message: "Thread not found" });
-    }
-    const result = await storage.getMessagesPaginated({ threadId, resourceId, selectBy, format });
-    return result;
-  } catch (error) {
-    return 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 HTTPException(400, { message: "Invalid limit: must be a positive integer" });
-  }
   try {
     validateBody({ threadId });
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
     }
+    if (!threadId) {
+      throw new HTTPException(400, { message: "No threadId found" });
+    }
     const thread = await memory.getThreadById({ threadId });
     if (!thread) {
       throw new 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 = convertMessages(result.messages).to("AIV5.UI");
-    return { messages: result.messages, uiMessages, legacyMessages: result.uiMessages };
+    return result;
   } catch (error) {
     return handleError(error, "Error getting messages");
   }
@@ -317,11 +299,11 @@ async function getWorkingMemoryHandler({
   agentId,
   threadId,
   resourceId,
-  runtimeContext,
+  requestContext,
   memoryConfig
 }) {
   try {
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     validateBody({ threadId });
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
@@ -332,7 +314,7 @@ async function getWorkingMemoryHandler({
     const workingMemoryTemplate = template?.format === "json" ? { ...template, content: JSON.stringify(generateEmptyFromSchema(template.content)) } : template;
     const workingMemory = await memory.getWorkingMemory({ threadId, resourceId, memoryConfig });
     const config = memory.getMergedThreadConfig(memoryConfig || {});
-    const source = config.workingMemory?.scope === "resource" && resourceId ? "resource" : "thread";
+    const source = config.workingMemory?.scope !== "thread" && resourceId ? "resource" : "thread";
     return { workingMemory, source, workingMemoryTemplate, threadExists };
   } catch (error) {
     return handleError(error, "Error getting working memory");
@@ -343,11 +325,11 @@ async function updateWorkingMemoryHandler({
   agentId,
   threadId,
   body,
-  runtimeContext
+  requestContext
 }) {
   try {
     validateBody({ threadId });
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     const { resourceId, memoryConfig, workingMemory } = body;
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
@@ -366,13 +348,13 @@ async function deleteMessagesHandler({
   mastra,
   agentId,
   messageIds,
-  runtimeContext
+  requestContext
 }) {
   try {
     if (messageIds === void 0 || messageIds === null) {
       throw new HTTPException(400, { message: "messageIds is required" });
     }
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
     }
@@ -393,18 +375,18 @@ async function searchMemoryHandler({
   resourceId,
   threadId,
   limit = 20,
-  runtimeContext,
+  requestContext,
   memoryConfig
 }) {
   try {
     validateBody({ searchQuery, resourceId });
-    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const memory = await getMemoryFromContext({ mastra, agentId, requestContext });
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
     }
     const config = memory.getMergedThreadConfig(memoryConfig || {});
     const hasSemanticRecall = !!config?.semanticRecall;
-    const resourceScope = typeof config?.semanticRecall === "object" && config?.semanticRecall?.scope === "resource";
+    const resourceScope = typeof config?.semanticRecall === "object" ? config?.semanticRecall?.scope !== "thread" : true;
     if (threadId && !resourceScope) {
       const thread = await memory.getThreadById({ threadId });
       if (!thread) {
@@ -415,7 +397,6 @@ async function searchMemoryHandler({
       }
     }
     const searchResults = [];
-    const messageMap = /* @__PURE__ */ new Map();
     if (threadId && !resourceScope) {
       const thread = await memory.getThreadById({ threadId });
       if (!thread) {
@@ -423,117 +404,85 @@ async function searchMemoryHandler({
           results: [],
           count: 0,
           query: searchQuery,
-          searchScope: "thread",
+          searchScope: resourceScope ? "resource" : "thread",
           searchType: hasSemanticRecall ? "semantic" : "text"
         };
       }
     }
-    if (!threadId || resourceScope) {
-      const threads = await memory.getThreadsByResourceId({ resourceId });
+    if (!threadId) {
+      const { threads } = await memory.listThreadsByResourceId({
+        resourceId,
+        page: 0,
+        perPage: 1,
+        orderBy: { field: "updatedAt", direction: "DESC" }
+      });
       if (threads.length === 0) {
         return {
           results: [],
           count: 0,
           query: searchQuery,
-          searchScope: "resource",
+          searchScope: resourceScope ? "resource" : "thread",
           searchType: hasSemanticRecall ? "semantic" : "text"
         };
       }
-      for (const thread of threads) {
-        const result = await memory.rememberMessages({
-          threadId: thread.id,
-          resourceId,
-          vectorMessageSearch: searchQuery,
-          config
-        });
-        const threadMessages = (await memory.query({ threadId: thread.id })).uiMessages;
-        result.messagesV2.forEach((msg) => {
-          if (messageMap.has(msg.id)) return;
-          messageMap.set(msg.id, true);
-          const content = msg.content.content || msg.content.parts?.map((p) => p.type === "text" ? p.text : "").join(" ") || "";
-          if (!hasSemanticRecall && !content.toLowerCase().includes(searchQuery.toLowerCase())) {
-            return;
-          }
-          const messageIndex = threadMessages.findIndex((m) => m.id === msg.id);
-          const searchResult = {
-            id: msg.id,
-            role: msg.role,
-            content,
-            createdAt: msg.createdAt,
-            threadId: msg.threadId || thread.id,
-            threadTitle: thread.title || msg.threadId || thread.id
-          };
-          if (messageIndex !== -1) {
-            searchResult.context = {
-              before: threadMessages.slice(Math.max(0, messageIndex - 2), messageIndex).map((m) => ({
-                id: m.id,
-                role: m.role,
-                content: m.content,
-                createdAt: m.createdAt || /* @__PURE__ */ new Date()
-              })),
-              after: threadMessages.slice(messageIndex + 1, messageIndex + 3).map((m) => ({
-                id: m.id,
-                role: m.role,
-                content: m.content,
-                createdAt: m.createdAt || /* @__PURE__ */ new Date()
-              }))
-            };
-          }
-          searchResults.push(searchResult);
-        });
-      }
-    } else if (threadId) {
-      const thread = await memory.getThreadById({ threadId });
-      if (!thread) {
-        return {
-          results: [],
-          count: 0,
-          query: searchQuery,
-          searchScope: "thread",
-          searchType: hasSemanticRecall ? "semantic" : "text"
+      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;
+    if (resourceScope && config.semanticRecall) {
+      config.semanticRecall = typeof config.semanticRecall === `boolean` ? (
+        // make message range 0 so we can highlight the matches in search, message range will include other messages, not the matching ones
+        // and we add prev/next messages in a special section on each message anyway
+        { messageRange: 0, topK: 2, scope: "resource" }
+      ) : { ...config.semanticRecall, messageRange: 0 };
+    }
+    const threadConfig = memory.getMergedThreadConfig(config || {});
+    if (!threadConfig.lastMessages && !threadConfig.semanticRecall) {
+      return { results: [], count: 0, query: searchQuery };
+    }
+    const result = await memory.recall({
+      threadId,
+      resourceId,
+      perPage: threadConfig.lastMessages,
+      threadConfig: config,
+      vectorSearchString: threadConfig.semanticRecall && searchQuery ? searchQuery : void 0
+    });
+    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 = typeof msg.content.content === `string` ? msg.content.content : msg.content.parts?.map((p) => p.type === "text" ? p.text : "").join(" ") || "";
+      const msgThreadId = msg.threadId || threadId;
+      const thread = threadMap.get(msgThreadId);
+      const threadMessages = (await memory.recall({ threadId: msgThreadId })).messages;
+      const messageIndex = threadMessages.findIndex((m) => m.id === msg.id);
+      const searchResult = {
+        id: msg.id,
+        role: msg.role,
+        content,
+        createdAt: msg.createdAt,
+        threadId: msgThreadId,
+        threadTitle: thread?.title || msgThreadId
+      };
+      if (messageIndex !== -1) {
+        searchResult.context = {
+          before: threadMessages.slice(Math.max(0, messageIndex - beforeRange), messageIndex).map((m) => ({
+            id: m.id,
+            role: m.role,
+            content: m.content,
+            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,
+            createdAt: m.createdAt || /* @__PURE__ */ new Date()
+          }))
         };
       }
-      const result = await memory.rememberMessages({
-        threadId,
-        resourceId,
-        vectorMessageSearch: searchQuery,
-        config
-      });
-      const threadMessages = (await memory.query({ threadId })).uiMessages;
-      result.messagesV2.forEach((msg) => {
-        if (messageMap.has(msg.id)) return;
-        messageMap.set(msg.id, true);
-        const content = msg.content.content || msg.content.parts?.map((p) => p.type === "text" ? p.text : "").join(" ") || "";
-        if (!hasSemanticRecall && !content.toLowerCase().includes(searchQuery.toLowerCase())) {
-          return;
-        }
-        const messageIndex = threadMessages.findIndex((m) => m.id === msg.id);
-        const searchResult = {
-          id: msg.id,
-          role: msg.role,
-          content,
-          createdAt: msg.createdAt,
-          threadId,
-          threadTitle: thread?.title || threadId
-        };
-        if (messageIndex !== -1) {
-          searchResult.context = {
-            before: threadMessages.slice(Math.max(0, messageIndex - 2), messageIndex).map((m) => ({
-              id: m.id,
-              role: m.role,
-              content: m.content,
-              createdAt: m.createdAt || /* @__PURE__ */ new Date()
-            })),
-            after: threadMessages.slice(messageIndex + 1, messageIndex + 3).map((m) => ({
-              id: m.id,
-              role: m.role,
-              content: m.content,
-              createdAt: m.createdAt || /* @__PURE__ */ new Date()
-            }))
-          };
-        }
-        searchResults.push(searchResult);
-      });
+      searchResults.push(searchResult);
     }
     const sortedResults = searchResults.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, limit);
     return {
@@ -548,6 +497,6 @@ async function searchMemoryHandler({
   }
 }
 
-export { createThreadHandler, deleteMessagesHandler, deleteThreadHandler, getMemoryConfigHandler, getMemoryStatusHandler, getMessagesHandler, getMessagesPaginatedHandler, getThreadByIdHandler, getThreadsHandler, getThreadsPaginatedHandler, getWorkingMemoryHandler, memory_exports, saveMessagesHandler, searchMemoryHandler, updateThreadHandler, updateWorkingMemoryHandler };
-//# sourceMappingURL=chunk-OEOGYAQC.js.map
-//# sourceMappingURL=chunk-OEOGYAQC.js.map
+export { createThreadHandler, deleteMessagesHandler, deleteThreadHandler, getMemoryConfigHandler, getMemoryStatusHandler, getThreadByIdHandler, getWorkingMemoryHandler, listMessagesHandler, listThreadsHandler, memory_exports, saveMessagesHandler, searchMemoryHandler, updateThreadHandler, updateWorkingMemoryHandler };
+//# sourceMappingURL=chunk-4JF5WXPL.js.map
+//# sourceMappingURL=chunk-4JF5WXPL.js.map