@mastra/server 0.0.0-fix-issue-10434-concurrent-write-corruption-20251124213939 → 0.0.0-fix-backport-setserver-20251201151948

package/dist/chunk-NT5XW5PI.cjs

@@ -0,0 +1,596 @@
+'use strict';
+
+var chunkG4PUALCE_cjs = require('./chunk-G4PUALCE.cjs');
+var chunkRE4RPXT2_cjs = require('./chunk-RE4RPXT2.cjs');
+var chunk7NADHFD2_cjs = require('./chunk-7NADHFD2.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
+var memory_exports = {};
+chunkO7I5CWRX_cjs.__export(memory_exports, {
+  createThreadHandler: () => createThreadHandler,
+  deleteMessagesHandler: () => deleteMessagesHandler,
+  deleteThreadHandler: () => deleteThreadHandler,
+  getMemoryConfigHandler: () => getMemoryConfigHandler,
+  getMemoryStatusHandler: () => getMemoryStatusHandler,
+  getMessagesHandler: () => getMessagesHandler,
+  getMessagesPaginatedHandler: () => getMessagesPaginatedHandler,
+  getThreadByIdHandler: () => getThreadByIdHandler,
+  getThreadsHandler: () => getThreadsHandler,
+  getThreadsPaginatedHandler: () => getThreadsPaginatedHandler,
+  getWorkingMemoryHandler: () => getWorkingMemoryHandler,
+  saveMessagesHandler: () => saveMessagesHandler,
+  searchMemoryHandler: () => searchMemoryHandler,
+  updateThreadHandler: () => updateThreadHandler,
+  updateWorkingMemoryHandler: () => updateWorkingMemoryHandler
+});
+async function getMemoryFromContext({
+  mastra,
+  agentId,
+  runtimeContext
+}) {
+  const logger = mastra.getLogger();
+  let agent;
+  if (agentId) {
+    try {
+      agent = mastra.getAgent(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();
+    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 chunk7NADHFD2_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+  }
+  if (agent) {
+    return await agent?.getMemory({
+      runtimeContext: runtimeContext ?? new di.RuntimeContext()
+    }) || mastra.getMemory();
+  }
+  return mastra.getMemory();
+}
+async function getMemoryStatusHandler({
+  mastra,
+  agentId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    if (!memory) {
+      return { result: false };
+    }
+    return { result: true };
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error getting memory status");
+  }
+}
+async function getMemoryConfigHandler({
+  mastra,
+  agentId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    if (!memory) {
+      throw new chunk7NADHFD2_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");
+  }
+}
+async function getThreadsPaginatedHandler({
+  mastra,
+  agentId,
+  resourceId,
+  runtimeContext,
+  page,
+  perPage,
+  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 result = await memory.getThreadsByResourceIdPaginated({
+      resourceId,
+      page,
+      perPage,
+      orderBy,
+      sortDirection
+    });
+    return result;
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error getting paginated threads");
+  }
+}
+async function getThreadByIdHandler({
+  mastra,
+  agentId,
+  threadId,
+  runtimeContext
+}) {
+  try {
+    chunkG4PUALCE_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    if (!memory) {
+      throw new chunk7NADHFD2_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" });
+    }
+    return thread;
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error getting thread");
+  }
+}
+async function saveMessagesHandler({
+  mastra,
+  agentId,
+  body,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    if (!memory) {
+      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    if (!body?.messages) {
+      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Messages are required" });
+    }
+    if (!Array.isArray(body.messages)) {
+      throw new chunk7NADHFD2_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, {
+        message: `All messages must have threadId and resourceId fields. Found ${invalidMessages.length} invalid message(s).`
+      });
+    }
+    const processedMessages = body.messages.map((message) => ({
+      ...message,
+      id: message.id || memory.generateId(),
+      createdAt: message.createdAt ? new Date(message.createdAt) : /* @__PURE__ */ new Date()
+    }));
+    const result = await memory.saveMessages({ messages: processedMessages, memoryConfig: {} });
+    return result;
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error saving messages");
+  }
+}
+async function createThreadHandler({
+  mastra,
+  agentId,
+  body,
+  runtimeContext
+}) {
+  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: body?.resourceId });
+    const result = await memory.createThread({
+      resourceId: body?.resourceId,
+      title: body?.title,
+      metadata: body?.metadata,
+      threadId: body?.threadId
+    });
+    return result;
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error saving thread to memory");
+  }
+}
+async function updateThreadHandler({
+  mastra,
+  agentId,
+  threadId,
+  body,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    if (!body) {
+      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Body is required" });
+    }
+    const { title, metadata, resourceId } = body;
+    const updatedAt = /* @__PURE__ */ new Date();
+    chunkG4PUALCE_cjs.validateBody({ threadId });
+    if (!memory) {
+      throw new chunk7NADHFD2_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" });
+    }
+    const updatedThread = {
+      ...thread,
+      title: title || thread.title,
+      metadata: metadata || thread.metadata,
+      resourceId: resourceId || thread.resourceId,
+      createdAt: thread.createdAt,
+      updatedAt
+    };
+    const result = await memory.saveThread({ thread: updatedThread });
+    return result;
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error updating thread");
+  }
+}
+async function deleteThreadHandler({
+  mastra,
+  agentId,
+  threadId,
+  runtimeContext
+}) {
+  try {
+    chunkG4PUALCE_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    if (!memory) {
+      throw new chunk7NADHFD2_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" });
+    }
+    await memory.deleteThread(threadId);
+    return { result: "Thread deleted" };
+  } catch (error) {
+    return chunkRE4RPXT2_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({
+  mastra,
+  agentId,
+  threadId,
+  limit,
+  runtimeContext
+}) {
+  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 });
+    if (!memory) {
+      throw new chunk7NADHFD2_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" });
+    }
+    const result = await memory.query({
+      threadId,
+      ...limit && { selectBy: { last: limit } }
+    });
+    const uiMessages = agent.convertMessages(result.messagesV2).to("AIV5.UI");
+    return { messages: result.messages, uiMessages, legacyMessages: result.uiMessages };
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error getting messages");
+  }
+}
+async function getWorkingMemoryHandler({
+  mastra,
+  agentId,
+  threadId,
+  resourceId,
+  runtimeContext,
+  memoryConfig
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    chunkG4PUALCE_cjs.validateBody({ threadId });
+    if (!memory) {
+      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    const threadExists = !!thread;
+    const template = await memory.getWorkingMemoryTemplate({ memoryConfig });
+    const workingMemoryTemplate = template?.format === "json" ? { ...template, content: JSON.stringify(utils.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";
+    return { workingMemory, source, workingMemoryTemplate, threadExists };
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error getting working memory");
+  }
+}
+async function updateWorkingMemoryHandler({
+  mastra,
+  agentId,
+  threadId,
+  body,
+  runtimeContext
+}) {
+  try {
+    chunkG4PUALCE_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    const { resourceId, memoryConfig, workingMemory } = body;
+    if (!memory) {
+      throw new chunk7NADHFD2_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" });
+    }
+    await memory.updateWorkingMemory({ threadId, resourceId, workingMemory, memoryConfig });
+    return { success: true };
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error updating working memory");
+  }
+}
+async function deleteMessagesHandler({
+  mastra,
+  agentId,
+  messageIds,
+  runtimeContext
+}) {
+  try {
+    if (messageIds === void 0 || messageIds === null) {
+      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "messageIds is required" });
+    }
+    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    if (!memory) {
+      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    await memory.deleteMessages(messageIds);
+    let count = 1;
+    if (Array.isArray(messageIds)) {
+      count = messageIds.length;
+    }
+    return { success: true, message: `${count} message${count === 1 ? "" : "s"} deleted successfully` };
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error deleting messages");
+  }
+}
+async function searchMemoryHandler({
+  mastra,
+  agentId,
+  searchQuery,
+  resourceId,
+  threadId,
+  limit = 20,
+  runtimeContext,
+  memoryConfig
+}) {
+  try {
+    chunkG4PUALCE_cjs.validateBody({ searchQuery, resourceId });
+    const memory = await getMemoryFromContext({ mastra, agentId, runtimeContext });
+    if (!memory) {
+      throw new chunk7NADHFD2_cjs.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";
+    if (threadId && !resourceScope) {
+      const thread = await memory.getThreadById({ threadId });
+      if (!thread) {
+        throw new chunk7NADHFD2_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" });
+      }
+    }
+    const searchResults = [];
+    const messageMap = /* @__PURE__ */ new Map();
+    if (threadId && !resourceScope) {
+      const thread = await memory.getThreadById({ threadId });
+      if (!thread) {
+        return {
+          results: [],
+          count: 0,
+          query: searchQuery,
+          searchScope: "thread",
+          searchType: hasSemanticRecall ? "semantic" : "text"
+        };
+      }
+    }
+    if (!threadId || resourceScope) {
+      const threads = await memory.getThreadsByResourceId({ resourceId });
+      if (threads.length === 0) {
+        return {
+          results: [],
+          count: 0,
+          query: searchQuery,
+          searchScope: "resource",
+          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"
+        };
+      }
+      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);
+      });
+    }
+    const sortedResults = searchResults.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, limit);
+    return {
+      results: sortedResults,
+      count: sortedResults.length,
+      query: searchQuery,
+      searchScope: resourceScope ? "resource" : "thread",
+      searchType: hasSemanticRecall ? "semantic" : "text"
+    };
+  } catch (error) {
+    return chunkRE4RPXT2_cjs.handleError(error, "Error searching memory");
+  }
+}
+
+exports.createThreadHandler = createThreadHandler;
+exports.deleteMessagesHandler = deleteMessagesHandler;
+exports.deleteThreadHandler = deleteThreadHandler;
+exports.getMemoryConfigHandler = getMemoryConfigHandler;
+exports.getMemoryStatusHandler = getMemoryStatusHandler;
+exports.getMessagesHandler = getMessagesHandler;
+exports.getMessagesPaginatedHandler = getMessagesPaginatedHandler;
+exports.getThreadByIdHandler = getThreadByIdHandler;
+exports.getThreadsHandler = getThreadsHandler;
+exports.getThreadsPaginatedHandler = getThreadsPaginatedHandler;
+exports.getWorkingMemoryHandler = getWorkingMemoryHandler;
+exports.memory_exports = memory_exports;
+exports.saveMessagesHandler = saveMessagesHandler;
+exports.searchMemoryHandler = searchMemoryHandler;
+exports.updateThreadHandler = updateThreadHandler;
+exports.updateWorkingMemoryHandler = updateWorkingMemoryHandler;
+//# sourceMappingURL=chunk-NT5XW5PI.cjs.map
+//# sourceMappingURL=chunk-NT5XW5PI.cjs.map