@mastra/server 0.11.0-alpha.1 → 0.11.0-alpha.2

package/dist/chunk-424T5F2J.cjs

@@ -0,0 +1,157 @@
+'use strict';
+
+var chunkPZQDCRPV_cjs = require('./chunk-PZQDCRPV.cjs');
+var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
+
+// src/server/handlers/scores.ts
+var scores_exports = {};
+chunk75ZPJI57_cjs.__export(scores_exports, {
+  getScorerHandler: () => getScorerHandler,
+  getScorersHandler: () => getScorersHandler,
+  getScoresByEntityIdHandler: () => getScoresByEntityIdHandler,
+  getScoresByRunIdHandler: () => getScoresByRunIdHandler,
+  getScoresByScorerIdHandler: () => getScoresByScorerIdHandler,
+  saveScoreHandler: () => saveScoreHandler
+});
+async function getScorersFromSystem({
+  mastra,
+  runtimeContext
+}) {
+  const agents = mastra.getAgents();
+  const workflows = mastra.getWorkflows();
+  const scorersMap = /* @__PURE__ */ new Map();
+  for (const [agentId, agent] of Object.entries(agents)) {
+    const scorers = await agent.getScorers({
+      runtimeContext
+    }) || {};
+    if (Object.keys(scorers).length > 0) {
+      for (const [scorerId, scorer] of Object.entries(scorers)) {
+        if (scorersMap.has(scorerId)) {
+          scorersMap.get(scorerId)?.agentIds.push(agentId);
+        } else {
+          scorersMap.set(scorerId, {
+            workflowIds: [],
+            ...scorer,
+            agentIds: [agent.name]
+          });
+        }
+      }
+    }
+  }
+  for (const [workflowId, workflow] of Object.entries(workflows)) {
+    const scorers = await workflow.getScorers({
+      runtimeContext
+    }) || {};
+    if (Object.keys(scorers).length > 0) {
+      for (const [scorerId, scorer] of Object.entries(scorers)) {
+        if (scorersMap.has(scorerId)) {
+          scorersMap.get(scorerId)?.workflowIds.push(workflowId);
+        } else {
+          scorersMap.set(scorerId, {
+            agentIds: [],
+            ...scorer,
+            workflowIds: [workflowId]
+          });
+        }
+      }
+    }
+  }
+  return Object.fromEntries(scorersMap.entries());
+}
+async function getScorersHandler({ mastra, runtimeContext }) {
+  const scorers = await getScorersFromSystem({
+    mastra,
+    runtimeContext
+  });
+  return scorers;
+}
+async function getScorerHandler({
+  mastra,
+  scorerId,
+  runtimeContext
+}) {
+  const scorers = await getScorersFromSystem({
+    mastra,
+    runtimeContext
+  });
+  const scorer = scorers[scorerId];
+  if (!scorer) {
+    return null;
+  }
+  return scorer;
+}
+async function getScoresByRunIdHandler({
+  mastra,
+  runId,
+  pagination
+}) {
+  try {
+    const scores = await mastra.getStorage()?.getScoresByRunId?.({
+      runId,
+      pagination
+    }) || [];
+    return scores;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting scores by run id");
+  }
+}
+async function getScoresByScorerIdHandler({
+  mastra,
+  scorerId,
+  pagination,
+  entityId,
+  entityType
+}) {
+  try {
+    const scores = await mastra.getStorage()?.getScoresByScorerId?.({
+      scorerId,
+      pagination,
+      entityId,
+      entityType
+    }) || [];
+    return scores;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting scores by scorer id");
+  }
+}
+async function getScoresByEntityIdHandler({
+  mastra,
+  entityId,
+  entityType,
+  pagination
+}) {
+  try {
+    let entityIdToUse = entityId;
+    if (entityType === "AGENT") {
+      const agent = mastra.getAgentById(entityId);
+      entityIdToUse = agent.id;
+    } else if (entityType === "WORKFLOW") {
+      const workflow = mastra.getWorkflowById(entityId);
+      entityIdToUse = workflow.id;
+    }
+    const scores = await mastra.getStorage()?.getScoresByEntityId?.({
+      entityId: entityIdToUse,
+      entityType,
+      pagination
+    }) || [];
+    return scores;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting scores by entity id");
+  }
+}
+async function saveScoreHandler({ mastra, score }) {
+  try {
+    const scores = await mastra.getStorage()?.saveScore?.(score) || [];
+    return scores;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error saving score");
+  }
+}
+
+exports.getScorerHandler = getScorerHandler;
+exports.getScorersHandler = getScorersHandler;
+exports.getScoresByEntityIdHandler = getScoresByEntityIdHandler;
+exports.getScoresByRunIdHandler = getScoresByRunIdHandler;
+exports.getScoresByScorerIdHandler = getScoresByScorerIdHandler;
+exports.saveScoreHandler = saveScoreHandler;
+exports.scores_exports = scores_exports;

package/dist/chunk-6T5JUKOQ.js

@@ -0,0 +1,149 @@
+import { handleError } from './chunk-LF7P5PLR.js';
+import { __export } from './chunk-MLKGABMK.js';
+
+// src/server/handlers/scores.ts
+var scores_exports = {};
+__export(scores_exports, {
+  getScorerHandler: () => getScorerHandler,
+  getScorersHandler: () => getScorersHandler,
+  getScoresByEntityIdHandler: () => getScoresByEntityIdHandler,
+  getScoresByRunIdHandler: () => getScoresByRunIdHandler,
+  getScoresByScorerIdHandler: () => getScoresByScorerIdHandler,
+  saveScoreHandler: () => saveScoreHandler
+});
+async function getScorersFromSystem({
+  mastra,
+  runtimeContext
+}) {
+  const agents = mastra.getAgents();
+  const workflows = mastra.getWorkflows();
+  const scorersMap = /* @__PURE__ */ new Map();
+  for (const [agentId, agent] of Object.entries(agents)) {
+    const scorers = await agent.getScorers({
+      runtimeContext
+    }) || {};
+    if (Object.keys(scorers).length > 0) {
+      for (const [scorerId, scorer] of Object.entries(scorers)) {
+        if (scorersMap.has(scorerId)) {
+          scorersMap.get(scorerId)?.agentIds.push(agentId);
+        } else {
+          scorersMap.set(scorerId, {
+            workflowIds: [],
+            ...scorer,
+            agentIds: [agent.name]
+          });
+        }
+      }
+    }
+  }
+  for (const [workflowId, workflow] of Object.entries(workflows)) {
+    const scorers = await workflow.getScorers({
+      runtimeContext
+    }) || {};
+    if (Object.keys(scorers).length > 0) {
+      for (const [scorerId, scorer] of Object.entries(scorers)) {
+        if (scorersMap.has(scorerId)) {
+          scorersMap.get(scorerId)?.workflowIds.push(workflowId);
+        } else {
+          scorersMap.set(scorerId, {
+            agentIds: [],
+            ...scorer,
+            workflowIds: [workflowId]
+          });
+        }
+      }
+    }
+  }
+  return Object.fromEntries(scorersMap.entries());
+}
+async function getScorersHandler({ mastra, runtimeContext }) {
+  const scorers = await getScorersFromSystem({
+    mastra,
+    runtimeContext
+  });
+  return scorers;
+}
+async function getScorerHandler({
+  mastra,
+  scorerId,
+  runtimeContext
+}) {
+  const scorers = await getScorersFromSystem({
+    mastra,
+    runtimeContext
+  });
+  const scorer = scorers[scorerId];
+  if (!scorer) {
+    return null;
+  }
+  return scorer;
+}
+async function getScoresByRunIdHandler({
+  mastra,
+  runId,
+  pagination
+}) {
+  try {
+    const scores = await mastra.getStorage()?.getScoresByRunId?.({
+      runId,
+      pagination
+    }) || [];
+    return scores;
+  } catch (error) {
+    return handleError(error, "Error getting scores by run id");
+  }
+}
+async function getScoresByScorerIdHandler({
+  mastra,
+  scorerId,
+  pagination,
+  entityId,
+  entityType
+}) {
+  try {
+    const scores = await mastra.getStorage()?.getScoresByScorerId?.({
+      scorerId,
+      pagination,
+      entityId,
+      entityType
+    }) || [];
+    return scores;
+  } catch (error) {
+    return handleError(error, "Error getting scores by scorer id");
+  }
+}
+async function getScoresByEntityIdHandler({
+  mastra,
+  entityId,
+  entityType,
+  pagination
+}) {
+  try {
+    let entityIdToUse = entityId;
+    if (entityType === "AGENT") {
+      const agent = mastra.getAgentById(entityId);
+      entityIdToUse = agent.id;
+    } else if (entityType === "WORKFLOW") {
+      const workflow = mastra.getWorkflowById(entityId);
+      entityIdToUse = workflow.id;
+    }
+    const scores = await mastra.getStorage()?.getScoresByEntityId?.({
+      entityId: entityIdToUse,
+      entityType,
+      pagination
+    }) || [];
+    return scores;
+  } catch (error) {
+    return handleError(error, "Error getting scores by entity id");
+  }
+}
+async function saveScoreHandler({ mastra, score }) {
+  try {
+    const scores = await mastra.getStorage()?.saveScore?.(score) || [];
+    return scores;
+  } catch (error) {
+    return handleError(error, "Error saving score");
+  }
+}
+
+export { getScorerHandler, getScorersHandler, getScoresByEntityIdHandler, getScoresByRunIdHandler, getScoresByScorerIdHandler, saveScoreHandler, scores_exports };

package/dist/{chunk-KOHWJYJT.js → chunk-AHXXKSOO.js}

@@ -9,12 +9,15 @@ var memory_exports = {};
 __export(memory_exports, {
   createThreadHandler: () => createThreadHandler,
   deleteThreadHandler: () => deleteThreadHandler,
+  getMemoryConfigHandler: () => getMemoryConfigHandler,
   getMemoryStatusHandler: () => getMemoryStatusHandler,
   getMessagesHandler: () => getMessagesHandler,
+  getMessagesPaginatedHandler: () => getMessagesPaginatedHandler,
   getThreadByIdHandler: () => getThreadByIdHandler,
   getThreadsHandler: () => getThreadsHandler,
   getWorkingMemoryHandler: () => getWorkingMemoryHandler,
   saveMessagesHandler: () => saveMessagesHandler,
+  searchMemoryHandler: () => searchMemoryHandler,
   updateThreadHandler: () => updateThreadHandler,
   updateWorkingMemoryHandler: () => updateWorkingMemoryHandler
 });
@@ -33,7 +36,7 @@ async function getMemoryFromContext({
     throw new HTTPException(404, { message: "Network not found" });
   }
   if (agent) {
-    return agent?.getMemory() || mastra.getMemory();
+    return await agent?.getMemory() || mastra.getMemory();
   }
   if (network) {
     return await network?.getMemory({ runtimeContext }) || mastra.getMemory();
@@ -56,6 +59,23 @@ async function getMemoryStatusHandler({
     return handleError(error, "Error getting memory status");
   }
 }
+async function getMemoryConfigHandler({
+  mastra,
+  agentId,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const config = memory.getMergedThreadConfig({});
+    return { config };
+  } catch (error) {
+    return handleError(error, "Error getting memory configuration");
+  }
+}
 async function getThreadsHandler({
   mastra,
   agentId,
@@ -210,6 +230,29 @@ 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({
   mastra,
   agentId,
@@ -292,5 +335,167 @@ async function updateWorkingMemoryHandler({
     return handleError(error, "Error updating working memory");
   }
 }
+async function searchMemoryHandler({
+  mastra,
+  agentId,
+  searchQuery,
+  resourceId,
+  threadId,
+  limit = 20,
+  networkId,
+  runtimeContext,
+  memoryConfig
+}) {
+  try {
+    validateBody({ searchQuery, resourceId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    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";
+    if (threadId && !resourceScope) {
+      const thread = await memory.getThreadById({ threadId });
+      if (!thread) {
+        throw new HTTPException(404, { message: "Thread not found" });
+      }
+      if (thread.resourceId !== resourceId) {
+        throw new 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 handleError(error, "Error searching memory");
+  }
+}
 
-export { createThreadHandler, deleteThreadHandler, getMemoryStatusHandler, getMessagesHandler, getThreadByIdHandler, getThreadsHandler, getWorkingMemoryHandler, memory_exports, saveMessagesHandler, updateThreadHandler, updateWorkingMemoryHandler };
+export { createThreadHandler, deleteThreadHandler, getMemoryConfigHandler, getMemoryStatusHandler, getMessagesHandler, getMessagesPaginatedHandler, getThreadByIdHandler, getThreadsHandler, getWorkingMemoryHandler, memory_exports, saveMessagesHandler, searchMemoryHandler, updateThreadHandler, updateWorkingMemoryHandler };

package/dist/{chunk-LZ3VJXSO.cjs → chunk-ENPKI53P.cjs}

@@ -15,7 +15,8 @@ chunk75ZPJI57_cjs.__export(agents_exports, {
   getAgentsHandler: () => getAgentsHandler,
   getEvalsByAgentIdHandler: () => getEvalsByAgentIdHandler,
   getLiveEvalsByAgentIdHandler: () => getLiveEvalsByAgentIdHandler,
-  streamGenerateHandler: () => streamGenerateHandler
+  streamGenerateHandler: () => streamGenerateHandler,
+  streamVNextGenerateHandler: () => streamVNextGenerateHandler
 });
 async function getAgentsHandler({ mastra, runtimeContext }) {
   try {
@@ -268,6 +269,34 @@ async function streamGenerateHandler({
     return chunkPZQDCRPV_cjs.handleError(error, "error streaming agent response");
   }
 }
+function streamVNextGenerateHandler({
+  mastra,
+  runtimeContext: runtimeContext$1,
+  agentId,
+  body,
+  abortSignal
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const { messages, runtimeContext: agentRuntimeContext, ...rest } = body;
+    const finalRuntimeContext = new runtimeContext.RuntimeContext([
+      ...Array.from(runtimeContext$1.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
+    chunkCCGRCYWJ_cjs.validateBody({ messages });
+    const streamResult = agent.streamVNext(messages, {
+      ...rest,
+      runtimeContext: finalRuntimeContext,
+      abortSignal
+    });
+    return streamResult;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "error streaming agent response");
+  }
+}
 
 exports.agents_exports = agents_exports;
 exports.generateHandler = generateHandler;
@@ -276,3 +305,4 @@ exports.getAgentsHandler = getAgentsHandler;
 exports.getEvalsByAgentIdHandler = getEvalsByAgentIdHandler;
 exports.getLiveEvalsByAgentIdHandler = getLiveEvalsByAgentIdHandler;
 exports.streamGenerateHandler = streamGenerateHandler;
+exports.streamVNextGenerateHandler = streamVNextGenerateHandler;

package/dist/{chunk-B2PAS2IB.cjs → chunk-G7AFLCTK.cjs}

@@ -21,6 +21,7 @@ chunk75ZPJI57_cjs.__export(workflows_exports, {
   sendWorkflowRunEventHandler: () => sendWorkflowRunEventHandler,
   startAsyncWorkflowHandler: () => startAsyncWorkflowHandler,
   startWorkflowRunHandler: () => startWorkflowRunHandler,
+  streamVNextWorkflowHandler: () => streamVNextWorkflowHandler,
   streamWorkflowHandler: () => streamWorkflowHandler,
   watchWorkflowHandler: () => watchWorkflowHandler
 });
@@ -342,6 +343,34 @@ async function streamWorkflowHandler({
     return chunkPZQDCRPV_cjs.handleError(error, "Error executing workflow");
   }
 }
+async function streamVNextWorkflowHandler({
+  mastra,
+  runtimeContext,
+  workflowId,
+  runId,
+  inputData
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "runId required to stream workflow" });
+    }
+    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    if (!workflow) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
+    }
+    const run = await workflow.createRunAsync({ runId });
+    const result = run.streamVNext({
+      inputData,
+      runtimeContext
+    });
+    return result;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error streaming workflow");
+  }
+}
 async function resumeAsyncWorkflowHandler({
   mastra,
   workflowId,
@@ -509,6 +538,7 @@ exports.resumeWorkflowHandler = resumeWorkflowHandler;
 exports.sendWorkflowRunEventHandler = sendWorkflowRunEventHandler;
 exports.startAsyncWorkflowHandler = startAsyncWorkflowHandler;
 exports.startWorkflowRunHandler = startWorkflowRunHandler;
+exports.streamVNextWorkflowHandler = streamVNextWorkflowHandler;
 exports.streamWorkflowHandler = streamWorkflowHandler;
 exports.watchWorkflowHandler = watchWorkflowHandler;
 exports.workflows_exports = workflows_exports;

package/dist/{chunk-LRCAAFUA.js → chunk-RFV6JJFC.js}

@@ -3,7 +3,7 @@ import { validateBody } from './chunk-RSEO4XPX.js';
 import { handleError } from './chunk-LF7P5PLR.js';
 import { HTTPException } from './chunk-LCM566I4.js';
 import { __export } from './chunk-MLKGABMK.js';
-import { isVercelTool } from '@mastra/core/tools';
+import { isVercelTool } from '@mastra/core/tools/is-vercel-tool';
 
 // src/server/handlers/tools.ts
 var tools_exports = {};