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

package/dist/server/index.cjs

@@ -21,10 +21,10 @@ var httpException = require('hono/http-exception');
 var a2a = require('@mastra/server/handlers/a2a');
 var streaming = require('hono/streaming');
 var bodyLimit = require('hono/body-limit');
-var agents = require('@mastra/server/handlers/agents');
 var agent = require('@mastra/core/agent');
 var zod = require('zod');
 var tools$1 = require('@mastra/server/handlers/tools');
+var agents = require('@mastra/server/handlers/agents');
 var voice = require('@mastra/server/handlers/voice');
 var logs = require('@mastra/server/handlers/logs');
 var util = require('util');
@@ -32,10 +32,11 @@ var buffer = require('buffer');
 var memory = require('@mastra/server/handlers/memory');
 var network = require('@mastra/server/handlers/network');
 var vNextNetwork = require('@mastra/server/handlers/vNextNetwork');
+var scores = require('@mastra/server/handlers/scores');
 var telemetry = require('@mastra/server/handlers/telemetry');
 var vector = require('@mastra/server/handlers/vector');
-var legacyWorkflows = require('@mastra/server/handlers/legacyWorkflows');
 var workflows = require('@mastra/server/handlers/workflows');
+var legacyWorkflows = require('@mastra/server/handlers/legacyWorkflows');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -265,14 +266,14 @@ var Response2 = class _Response {
 });
 Object.setPrototypeOf(Response2, GlobalResponse);
 Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
-function writeFromReadableStream(stream5, writable) {
-  if (stream5.locked) {
+function writeFromReadableStream(stream6, writable) {
+  if (stream6.locked) {
     throw new TypeError("ReadableStream is locked.");
   } else if (writable.destroyed) {
-    stream5.cancel();
+    stream6.cancel();
     return;
   }
-  const reader = stream5.getReader();
+  const reader = stream6.getReader();
   writable.on("close", cancel);
   writable.on("error", cancel);
   reader.read().then(flow, cancel);
@@ -507,18 +508,18 @@ var ENCODINGS = {
   gzip: ".gz"
 };
 var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
-var createStreamBody = (stream5) => {
+var createStreamBody = (stream6) => {
   const body = new ReadableStream({
     start(controller) {
-      stream5.on("data", (chunk) => {
+      stream6.on("data", (chunk) => {
         controller.enqueue(chunk);
       });
-      stream5.on("end", () => {
+      stream6.on("end", () => {
         controller.close();
       });
     },
     cancel() {
-      stream5.destroy();
+      stream6.destroy();
     }
   });
   return body;
@@ -614,10 +615,10 @@ var serveStatic = (options = { root: "" }) => {
       end = size - 1;
     }
     const chunksize = end - start + 1;
-    const stream5 = fs.createReadStream(path, { start, end });
+    const stream6 = fs.createReadStream(path, { start, end });
     c2.header("Content-Length", chunksize.toString());
     c2.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-    return c2.body(createStreamBody(stream5), 206);
+    return c2.body(createStreamBody(stream6), 206);
   };
 };
 var RENDER_TYPE = {
@@ -913,15 +914,15 @@ async function getAgentExecutionHandler(c2) {
   if (body.method === "tasks/sendSubscribe") {
     return streaming.stream(
       c2,
-      async (stream5) => {
+      async (stream6) => {
         try {
-          stream5.onAbort(() => {
+          stream6.onAbort(() => {
             if (!result.locked) {
               return result.cancel();
             }
           });
           for await (const chunk of result) {
-            await stream5.write(JSON.stringify(chunk) + "");
+            await stream6.write(JSON.stringify(chunk) + "");
           }
         } catch (err) {
           logger2.error("Error in tasks/sendSubscribe stream: " + err?.message);
@@ -959,6 +960,9 @@ var defaultAuthConfig = {
 };
 
 // src/server/handlers/auth/helpers.ts
+var isDevPlaygroundRequest = (req) => {
+  return req.header("x-mastra-dev-playground") === "true" && (req.header("referer")?.includes("localhost") ?? false);
+};
 var isProtectedPath = (path, method, authConfig) => {
   const protectedAccess = [...defaultAuthConfig.protected || [], ...authConfig.protected || []];
   return isAnyMatch(path, method, protectedAccess);
@@ -1048,6 +1052,9 @@ var authenticationMiddleware = async (c2, next) => {
   if (!authConfig) {
     return next();
   }
+  if (isDevPlaygroundRequest(c2.req)) {
+    return next();
+  }
   if (!isProtectedPath(c2.req.path, c2.req.method, authConfig)) {
     return next();
   }
@@ -1087,6 +1094,9 @@ var authorizationMiddleware = async (c2, next) => {
   }
   const path = c2.req.path;
   const method = c2.req.method;
+  if (isDevPlaygroundRequest(c2.req)) {
+    return next();
+  }
   if (!isProtectedPath(c2.req.path, c2.req.method, authConfig)) {
     return next();
   }
@@ -1137,7 +1147,7 @@ var authorizationMiddleware = async (c2, next) => {
 // src/server/handlers/client.ts
 var clients = /* @__PURE__ */ new Set();
 function handleClientsRefresh(c2) {
-  const stream5 = new ReadableStream({
+  const stream6 = new ReadableStream({
     start(controller) {
       clients.add(controller);
       controller.enqueue("data: connected\n\n");
@@ -1146,7 +1156,7 @@ function handleClientsRefresh(c2) {
       });
     }
   });
-  return new Response(stream5, {
+  return new Response(stream6, {
     headers: {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -1187,111 +1197,6 @@ function errorHandler(err, c2, isDev) {
 async function rootHandler(c2) {
   return c2.text("Hello to the Mastra API!");
 }
-async function getAgentsHandler(c2) {
-  const serializedAgents = await agents.getAgentsHandler({
-    mastra: c2.get("mastra"),
-    runtimeContext: c2.get("runtimeContext")
-  });
-  return c2.json(serializedAgents);
-}
-async function getAgentByIdHandler(c2) {
-  const mastra = c2.get("mastra");
-  const agentId = c2.req.param("agentId");
-  const runtimeContext = c2.get("runtimeContext");
-  const isPlayground = c2.req.header("x-mastra-dev-playground") === "true";
-  const result = await agents.getAgentByIdHandler({
-    mastra,
-    agentId,
-    runtimeContext,
-    isPlayground
-  });
-  return c2.json(result);
-}
-async function getEvalsByAgentIdHandler(c2) {
-  const mastra = c2.get("mastra");
-  const agentId = c2.req.param("agentId");
-  const runtimeContext = c2.get("runtimeContext");
-  const result = await agents.getEvalsByAgentIdHandler({
-    mastra,
-    agentId,
-    runtimeContext
-  });
-  return c2.json(result);
-}
-async function getLiveEvalsByAgentIdHandler(c2) {
-  const mastra = c2.get("mastra");
-  const agentId = c2.req.param("agentId");
-  const runtimeContext = c2.get("runtimeContext");
-  const result = await agents.getLiveEvalsByAgentIdHandler({
-    mastra,
-    agentId,
-    runtimeContext
-  });
-  return c2.json(result);
-}
-async function generateHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const agentId = c2.req.param("agentId");
-    const runtimeContext = c2.get("runtimeContext");
-    const body = await c2.req.json();
-    const result = await agents.generateHandler({
-      mastra,
-      agentId,
-      runtimeContext,
-      body,
-      abortSignal: c2.req.raw.signal
-    });
-    return c2.json(result);
-  } catch (error) {
-    return handleError(error, "Error generating from agent");
-  }
-}
-async function streamGenerateHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const agentId = c2.req.param("agentId");
-    const runtimeContext = c2.get("runtimeContext");
-    const body = await c2.req.json();
-    const streamResponse = await agents.streamGenerateHandler({
-      mastra,
-      agentId,
-      runtimeContext,
-      body,
-      abortSignal: c2.req.raw.signal
-    });
-    return streamResponse;
-  } catch (error) {
-    return handleError(error, "Error streaming from agent");
-  }
-}
-async function setAgentInstructionsHandler(c2) {
-  try {
-    const isPlayground = c2.get("playground") === true;
-    if (!isPlayground) {
-      return c2.json({ error: "This API is only available in the playground environment" }, 403);
-    }
-    const agentId = c2.req.param("agentId");
-    const { instructions } = await c2.req.json();
-    if (!agentId || !instructions) {
-      return c2.json({ error: "Missing required fields" }, 400);
-    }
-    const mastra = c2.get("mastra");
-    const agent = mastra.getAgent(agentId);
-    if (!agent) {
-      return c2.json({ error: "Agent not found" }, 404);
-    }
-    agent.__updateInstructions(instructions);
-    return c2.json(
-      {
-        instructions
-      },
-      200
-    );
-  } catch (error) {
-    return handleError(error, "Error setting agent instructions");
-  }
-}
 async function generateSystemPromptHandler(c2) {
   try {
     const agentId = c2.req.param("agentId");
@@ -1465,6 +1370,151 @@ async function executeAgentToolHandler(c2) {
     return handleError(error, "Error executing tool");
   }
 }
+async function getAgentsHandler(c2) {
+  const serializedAgents = await agents.getAgentsHandler({
+    mastra: c2.get("mastra"),
+    runtimeContext: c2.get("runtimeContext")
+  });
+  return c2.json(serializedAgents);
+}
+async function getAgentByIdHandler(c2) {
+  const mastra = c2.get("mastra");
+  const agentId = c2.req.param("agentId");
+  const runtimeContext = c2.get("runtimeContext");
+  const isPlayground = c2.req.header("x-mastra-dev-playground") === "true";
+  const result = await agents.getAgentByIdHandler({
+    mastra,
+    agentId,
+    runtimeContext,
+    isPlayground
+  });
+  return c2.json(result);
+}
+async function getEvalsByAgentIdHandler(c2) {
+  const mastra = c2.get("mastra");
+  const agentId = c2.req.param("agentId");
+  const runtimeContext = c2.get("runtimeContext");
+  const result = await agents.getEvalsByAgentIdHandler({
+    mastra,
+    agentId,
+    runtimeContext
+  });
+  return c2.json(result);
+}
+async function getLiveEvalsByAgentIdHandler(c2) {
+  const mastra = c2.get("mastra");
+  const agentId = c2.req.param("agentId");
+  const runtimeContext = c2.get("runtimeContext");
+  const result = await agents.getLiveEvalsByAgentIdHandler({
+    mastra,
+    agentId,
+    runtimeContext
+  });
+  return c2.json(result);
+}
+async function generateHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.param("agentId");
+    const runtimeContext = c2.get("runtimeContext");
+    const body = await c2.req.json();
+    const result = await agents.generateHandler({
+      mastra,
+      agentId,
+      runtimeContext,
+      body,
+      abortSignal: c2.req.raw.signal
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error generating from agent");
+  }
+}
+async function streamGenerateHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.param("agentId");
+    const runtimeContext = c2.get("runtimeContext");
+    const body = await c2.req.json();
+    const streamResponse = await agents.streamGenerateHandler({
+      mastra,
+      agentId,
+      runtimeContext,
+      body,
+      abortSignal: c2.req.raw.signal
+    });
+    return streamResponse;
+  } catch (error) {
+    return handleError(error, "Error streaming from agent");
+  }
+}
+async function streamVNextGenerateHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.param("agentId");
+    const runtimeContext = c2.get("runtimeContext");
+    const body = await c2.req.json();
+    const logger2 = mastra.getLogger();
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(
+      c2,
+      async (stream6) => {
+        try {
+          const result = agents.streamVNextGenerateHandler({
+            mastra,
+            agentId,
+            runtimeContext,
+            body,
+            abortSignal: c2.req.raw.signal
+          });
+          const reader = result.getReader();
+          stream6.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream6.write(JSON.stringify(chunkResult.value) + "");
+          }
+        } catch (err) {
+          logger2.error("Error in streamVNext generate: " + (err?.message ?? "Unknown error"));
+        }
+        await stream6.close();
+      },
+      async (err) => {
+        logger2.error("Error in watch stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error streaming from agent");
+  }
+}
+async function setAgentInstructionsHandler(c2) {
+  try {
+    const isPlayground = c2.get("playground") === true;
+    if (!isPlayground) {
+      return c2.json({ error: "This API is only available in the playground environment" }, 403);
+    }
+    const agentId = c2.req.param("agentId");
+    const { instructions } = await c2.req.json();
+    if (!agentId || !instructions) {
+      return c2.json({ error: "Missing required fields" }, 400);
+    }
+    const mastra = c2.get("mastra");
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      return c2.json({ error: "Agent not found" }, 404);
+    }
+    agent.__updateInstructions(instructions);
+    return c2.json(
+      {
+        instructions
+      },
+      200
+    );
+  } catch (error) {
+    return handleError(error, "Error setting agent instructions");
+  }
+}
 async function getSpeakersHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -1538,7 +1588,7 @@ async function listenHandler(c2) {
   }
 }
 
-// src/server/handlers/routes/agents.ts
+// src/server/handlers/routes/agents/router.ts
 function agentsRouter(bodyLimitOptions) {
   const router = new hono.Hono();
   router.get(
@@ -1722,13 +1772,78 @@ function agentsRouter(bodyLimitOptions) {
     }),
     streamGenerateHandler
   );
-  router.get(
-    "/:agentId/speakers",
-    async (c2, next) => {
-      c2.header("Deprecation", "true");
-      c2.header("Warning", '299 - "This endpoint is deprecated, use /api/agents/:agentId/voice/speakers instead"');
-      c2.header("Link", '</api/agents/:agentId/voice/speakers>; rel="successor-version"');
-      return next();
+  router.post(
+    "/:agentId/streamVNext",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Stream a response from an agent using the VNext streaming API",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                messages: {
+                  type: "array",
+                  items: { type: "object" }
+                },
+                runId: { type: "string" },
+                output: { type: "object" },
+                experimental_output: { type: "object" },
+                instructions: { type: "string" },
+                toolsets: { type: "object" },
+                clientTools: { type: "object" },
+                context: {
+                  type: "array",
+                  items: { type: "object" }
+                },
+                memory: {
+                  type: "object",
+                  properties: {
+                    threadId: { type: "string" },
+                    resourceId: { type: "string", description: "The resource ID for the conversation" }
+                  }
+                },
+                toolChoice: {
+                  oneOf: [
+                    { type: "string", enum: ["auto", "none", "required"] },
+                    { type: "object", properties: { type: { type: "string" }, toolName: { type: "string" } } }
+                  ]
+                }
+              },
+              required: ["messages"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Streamed response"
+        },
+        404: {
+          description: "Agent not found"
+        }
+      }
+    }),
+    streamVNextGenerateHandler
+  );
+  router.get(
+    "/:agentId/speakers",
+    async (c2, next) => {
+      c2.header("Deprecation", "true");
+      c2.header("Warning", '299 - "This endpoint is deprecated, use /api/agents/:agentId/voice/speakers instead"');
+      c2.header("Link", '</api/agents/:agentId/voice/speakers>; rel="successor-version"');
+      return next();
     },
     w({
       description: "[DEPRECATED] Use /api/agents/:agentId/voice/speakers instead. Get available speakers for an agent",
@@ -2357,7 +2472,7 @@ async function getLogTransports(c2) {
   }
 }
 
-// src/server/handlers/routes/logs.ts
+// src/server/handlers/routes/logs/router.ts
 function logsRouter() {
   const router = new hono.Hono();
   router.get(
@@ -4352,7 +4467,7 @@ function toFetchResponse(res) {
   return res.fetchResponse;
 }
 
-// src/server/handlers/mcp.ts
+// src/server/handlers/routes/mcp/handlers.ts
 var getMastra = (c2) => c2.get("mastra");
 var getMcpServerMessageHandler = async (c2) => {
   const mastra = getMastra(c2);
@@ -4556,7 +4671,7 @@ var executeMcpServerToolHandler = async (c2) => {
   }
 };
 
-// src/server/handlers/routes/mcp.ts
+// src/server/handlers/routes/mcp/router.ts
 function mcpRouter(bodyLimitOptions) {
   const router = new hono.Hono();
   router.post(
@@ -4965,6 +5080,20 @@ function mcpRouter(bodyLimitOptions) {
   );
   return router;
 }
+
+// src/server/handlers/utils/query-parsers.ts
+function parseLimit(rawLimit) {
+  if (rawLimit === void 0) {
+    return void 0;
+  }
+  const n2 = Number(rawLimit);
+  if (Number.isFinite(n2) && Number.isInteger(n2) && n2 > 0) {
+    return n2;
+  }
+  return void 0;
+}
+
+// src/server/handlers/routes/memory/handlers.ts
 async function getMemoryStatusHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -4980,6 +5109,21 @@ async function getMemoryStatusHandler(c2) {
     return handleError(error, "Error getting memory status");
   }
 }
+async function getMemoryConfigHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.query("agentId");
+    const networkId = c2.req.query("networkId");
+    const result = await memory.getMemoryConfigHandler({
+      mastra,
+      agentId,
+      networkId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting memory configuration");
+  }
+}
 async function getThreadsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -5090,14 +5234,7 @@ async function getMessagesHandler(c2) {
     const agentId = c2.req.query("agentId");
     const networkId = c2.req.query("networkId");
     const threadId = c2.req.param("threadId");
-    const rawLimit = c2.req.query("limit");
-    let limit = void 0;
-    if (rawLimit !== void 0) {
-      const n2 = Number(rawLimit);
-      if (Number.isFinite(n2) && Number.isInteger(n2) && n2 > 0) {
-        limit = n2;
-      }
-    }
+    const limit = parseLimit(c2.req.query("limit"));
     const result = await memory.getMessagesHandler({
       mastra,
       agentId,
@@ -5110,6 +5247,32 @@ async function getMessagesHandler(c2) {
     return handleError(error, "Error getting messages");
   }
 }
+async function getMessagesPaginatedHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const threadId = c2.req.param("threadId");
+    const resourceId = c2.req.query("resourceId");
+    const format = c2.req.query("format") || "v1";
+    const selectByArgs = c2.req.query("selectBy");
+    let selectBy = {};
+    if (selectByArgs) {
+      try {
+        selectBy = JSON.parse(selectByArgs);
+      } catch (_error) {
+      }
+    }
+    const result = await memory.getMessagesPaginatedHandler({
+      mastra,
+      threadId,
+      resourceId,
+      format,
+      selectBy
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting messages");
+  }
+}
 async function updateWorkingMemoryHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -5148,8 +5311,35 @@ async function getWorkingMemoryHandler(c2) {
     return handleError(error, "Error getting working memory");
   }
 }
+async function searchMemoryHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.query("agentId");
+    const searchQuery = c2.req.query("searchQuery");
+    const resourceId = c2.req.query("resourceId");
+    const threadId = c2.req.query("threadId");
+    const limit = parseLimit(c2.req.query("limit"));
+    const memoryConfig = c2.req.query("memoryConfig") ? JSON.parse(c2.req.query("memoryConfig")) : void 0;
+    const networkId = c2.req.query("networkId");
+    const runtimeContext = c2.get("runtimeContext");
+    const result = await memory.searchMemoryHandler({
+      mastra,
+      agentId,
+      searchQuery,
+      resourceId,
+      threadId,
+      limit,
+      memoryConfig,
+      networkId,
+      runtimeContext
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error searching memory");
+  }
+}
 
-// src/server/handlers/routes/memory.ts
+// src/server/handlers/routes/memory/router.ts
 function memoryRoutes(bodyLimitOptions) {
   const router = new hono.Hono();
   router.get(
@@ -5430,6 +5620,84 @@ function memoryRoutes(bodyLimitOptions) {
     }),
     getMemoryStatusHandler
   );
+  router.get(
+    "/config",
+    w({
+      description: "Get memory configuration",
+      tags: ["memory"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Memory configuration",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  config: {
+                    type: "object",
+                    properties: {
+                      lastMessages: {
+                        oneOf: [{ type: "number" }, { type: "boolean" }]
+                      },
+                      semanticRecall: {
+                        oneOf: [
+                          { type: "boolean" },
+                          {
+                            type: "object",
+                            properties: {
+                              topK: { type: "number" },
+                              messageRange: {
+                                oneOf: [
+                                  { type: "number" },
+                                  {
+                                    type: "object",
+                                    properties: {
+                                      before: { type: "number" },
+                                      after: { type: "number" }
+                                    }
+                                  }
+                                ]
+                              },
+                              scope: { type: "string", enum: ["thread", "resource"] }
+                            }
+                          }
+                        ]
+                      },
+                      workingMemory: {
+                        type: "object",
+                        properties: {
+                          enabled: { type: "boolean" },
+                          scope: { type: "string", enum: ["thread", "resource"] },
+                          template: { type: "string" }
+                        }
+                      },
+                      threads: {
+                        type: "object",
+                        properties: {
+                          generateTitle: {
+                            oneOf: [{ type: "boolean" }, { type: "object" }]
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }),
+    getMemoryConfigHandler
+  );
   router.get(
     "/threads",
     w({
@@ -5489,6 +5757,15 @@ function memoryRoutes(bodyLimitOptions) {
   );
   router.get(
     "/threads/:threadId/messages",
+    async (c2, next) => {
+      c2.header("Deprecation", "true");
+      c2.header(
+        "Warning",
+        '299 - "This endpoint is deprecated, use /api/memory/threads/:threadId/messages/paginated instead"'
+      );
+      c2.header("Link", '</api/memory/threads/:threadId/messages/paginated>; rel="successor-version"');
+      return next();
+    },
     w({
       description: "Get messages for a thread",
       tags: ["memory"],
@@ -5522,46 +5799,152 @@ function memoryRoutes(bodyLimitOptions) {
     getMessagesHandler
   );
   router.get(
-    "/threads/:threadId/working-memory",
+    "/threads/:threadId/messages/paginated",
     w({
-      description: "Get working memory for a thread",
+      description: "Get paginated messages for a thread",
       tags: ["memory"],
       parameters: [
         {
           name: "threadId",
           in: "path",
           required: true,
-          schema: { type: "string" }
+          description: "The unique identifier of the thread",
+          schema: {
+            type: "string"
+          }
         },
         {
-          name: "agentId",
+          name: "resourceId",
+          in: "query",
+          required: false,
+          description: "Filter messages by resource ID",
+          schema: {
+            type: "string"
+          }
+        },
+        {
+          name: "format",
+          in: "query",
+          required: false,
+          description: "Message format to return",
+          schema: {
+            type: "string",
+            enum: ["v1", "v2"],
+            default: "v1"
+          }
+        },
+        {
+          name: "selectBy",
+          in: "query",
+          required: false,
+          description: "JSON string containing selection criteria for messages",
+          schema: {
+            type: "string",
+            example: '{"pagination":{"page":0,"perPage":20,"dateRange":{"start":"2024-01-01T00:00:00Z","end":"2024-12-31T23:59:59Z"}},"include":[{"id":"msg-123","withPreviousMessages":5,"withNextMessages":3}]}'
+          }
+        }
+      ],
+      responses: {
+        200: {
+          description: "List of messages"
+        }
+      }
+    }),
+    getMessagesPaginatedHandler
+  );
+  router.get(
+    "/search",
+    w({
+      description: "Search messages in a thread",
+      tags: ["memory"],
+      parameters: [
+        {
+          name: "searchQuery",
           in: "query",
           required: true,
-          schema: { type: "string" }
+          schema: { type: "string" },
+          description: "The text to search for"
         },
         {
           name: "resourceId",
           in: "query",
+          required: true,
+          schema: { type: "string" },
+          description: "The resource ID (user/org) to validate thread ownership"
+        },
+        {
+          name: "threadId",
+          in: "query",
           required: false,
-          schema: { type: "string" }
+          schema: { type: "string" },
+          description: "The thread ID to search within (optional - searches all threads if not provided)"
+        },
+        {
+          name: "agentId",
+          in: "query",
+          required: true,
+          schema: { type: "string" },
+          description: "The agent ID"
+        },
+        {
+          name: "limit",
+          in: "query",
+          required: false,
+          schema: { type: "number" },
+          description: "Maximum number of results to return (default: 20)"
+        },
+        {
+          name: "memoryConfig",
+          in: "query",
+          required: false,
+          schema: { type: "string" },
+          description: 'JSON-encoded memory configuration (e.g., {"lastMessages": 0} for semantic-only search)'
         }
       ],
       responses: {
         200: {
-          description: "Working memory details"
+          description: "Search results",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  results: {
+                    type: "array",
+                    items: {
+                      type: "object",
+                      properties: {
+                        id: { type: "string" },
+                        role: { type: "string" },
+                        content: { type: "string" },
+                        createdAt: { type: "string" }
+                      }
+                    }
+                  },
+                  count: { type: "number" },
+                  query: { type: "string" }
+                }
+              }
+            }
+          }
+        },
+        400: {
+          description: "Bad request"
+        },
+        403: {
+          description: "Thread does not belong to the specified resource"
         },
         404: {
           description: "Thread not found"
         }
       }
     }),
-    getWorkingMemoryHandler
+    searchMemoryHandler
   );
-  router.post(
+  router.get(
     "/threads/:threadId/working-memory",
-    bodyLimit.bodyLimit(bodyLimitOptions),
     w({
-      description: "Update working memory for a thread",
+      description: "Get working memory for a thread",
       tags: ["memory"],
       parameters: [
         {
@@ -5575,14 +5958,51 @@ function memoryRoutes(bodyLimitOptions) {
           in: "query",
           required: true,
           schema: { type: "string" }
+        },
+        {
+          name: "resourceId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
         }
       ],
-      requestBody: {
-        required: true,
-        content: {
-          "application/json": {
-            schema: {
-              type: "object",
+      responses: {
+        200: {
+          description: "Working memory details"
+        },
+        404: {
+          description: "Thread not found"
+        }
+      }
+    }),
+    getWorkingMemoryHandler
+  );
+  router.post(
+    "/threads/:threadId/working-memory",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Update working memory for a thread",
+      tags: ["memory"],
+      parameters: [
+        {
+          name: "threadId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "agentId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
               properties: {
                 workingMemory: { type: "string" },
                 resourceId: { type: "string" }
@@ -5867,7 +6287,7 @@ async function streamGenerateVNextNetworkHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream5) => {
+      async (stream6) => {
         try {
           const result = await vNextNetwork.streamGenerateVNextNetworkHandler({
             mastra,
@@ -5876,12 +6296,12 @@ async function streamGenerateVNextNetworkHandler(c2) {
             body
           });
           const reader = result.stream.getReader();
-          stream5.onAbort(() => {
+          stream6.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream5.write(JSON.stringify(chunkResult.value) + "");
+            await stream6.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           mastra.getLogger().error("Error in network stream: " + (err?.message ?? "Unknown error"));
@@ -5922,7 +6342,7 @@ async function loopStreamVNextNetworkHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream5) => {
+      async (stream6) => {
         try {
           const result = await vNextNetwork.loopStreamVNextNetworkHandler({
             mastra,
@@ -5931,12 +6351,12 @@ async function loopStreamVNextNetworkHandler(c2) {
             body
           });
           const reader = result.stream.getReader();
-          stream5.onAbort(() => {
+          stream6.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream5.write(JSON.stringify(chunkResult.value) + "");
+            await stream6.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           mastra.getLogger().error("Error in network loop stream: " + (err?.message ?? "Unknown error"));
@@ -5951,7 +6371,7 @@ async function loopStreamVNextNetworkHandler(c2) {
   }
 }
 
-// src/server/handlers/routes/networks.ts
+// src/server/handlers/routes/networks/router.ts
 function vNextNetworksRouter(bodyLimitOptions) {
   const router = new hono.Hono();
   router.get(
@@ -6326,6 +6746,288 @@ function networksRouter(bodyLimitOptions) {
   );
   return router;
 }
+async function getScorersHandler(c2) {
+  try {
+    const scorers = await scores.getScorersHandler({
+      mastra: c2.get("mastra"),
+      runtimeContext: c2.get("runtimeContext")
+    });
+    return c2.json(scorers);
+  } catch (error) {
+    return handleError(error, "Error getting scorers");
+  }
+}
+async function getScorerHandler(c2) {
+  const mastra = c2.get("mastra");
+  const scorerId = c2.req.param("scorerId");
+  const runtimeContext = c2.get("runtimeContext");
+  const scorer = await scores.getScorerHandler({
+    mastra,
+    scorerId,
+    runtimeContext
+  });
+  return c2.json(scorer);
+}
+async function getScoresByRunIdHandler(c2) {
+  const mastra = c2.get("mastra");
+  const runId = c2.req.param("runId");
+  const page = parseInt(c2.req.query("page") || "0");
+  const perPage = parseInt(c2.req.query("perPage") || "10");
+  const pagination = { page, perPage };
+  try {
+    const scores$1 = await scores.getScoresByRunIdHandler({
+      mastra,
+      runId,
+      pagination
+    });
+    return c2.json(scores$1);
+  } catch (error) {
+    return handleError(error, "Error getting scores by run id");
+  }
+}
+async function getScoresByScorerIdHandler(c2) {
+  const mastra = c2.get("mastra");
+  const scorerId = c2.req.param("scorerId");
+  const page = parseInt(c2.req.query("page") || "0");
+  const perPage = parseInt(c2.req.query("perPage") || "10");
+  const entityId = c2.req.query("entityId");
+  const entityType = c2.req.query("entityType");
+  const pagination = { page, perPage };
+  try {
+    const scores$1 = await scores.getScoresByScorerIdHandler({
+      mastra,
+      scorerId,
+      pagination,
+      entityId,
+      entityType
+    });
+    return c2.json(scores$1);
+  } catch (error) {
+    return handleError(error, "Error getting scores by scorer id");
+  }
+}
+async function getScoresByEntityIdHandler(c2) {
+  const mastra = c2.get("mastra");
+  const entityId = c2.req.param("entityId");
+  const entityType = c2.req.param("entityType");
+  const page = parseInt(c2.req.query("page") || "0");
+  const perPage = parseInt(c2.req.query("perPage") || "10");
+  const pagination = { page, perPage };
+  try {
+    const scores$1 = await scores.getScoresByEntityIdHandler({
+      mastra,
+      entityId,
+      entityType,
+      pagination
+    });
+    return c2.json(scores$1);
+  } catch (error) {
+    return handleError(error, "Error getting scores by entity id");
+  }
+}
+async function saveScoreHandler(c2) {
+  const mastra = c2.get("mastra");
+  const score = await c2.req.json();
+  try {
+    const result = await scores.saveScoreHandler({
+      mastra,
+      score
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error saving score");
+  }
+}
+
+// src/server/handlers/routes/scores/router.ts
+function scoresRouter(bodyLimitOptions) {
+  const router = new hono.Hono();
+  router.get(
+    "/scorers",
+    w({
+      description: "Get all scorers",
+      tags: ["scores"],
+      responses: {
+        200: {
+          description: "List of all scorers"
+        }
+      }
+    }),
+    getScorersHandler
+  );
+  router.get(
+    "/scorers/:scorerId",
+    w({
+      description: "Get a scorer by ID",
+      tags: ["scores"],
+      responses: {
+        200: {
+          description: "Scorer details"
+        }
+      }
+    }),
+    getScorerHandler
+  );
+  router.get(
+    "/run/:runId",
+    w({
+      description: "Get scores by run ID",
+      tags: ["scores"],
+      parameters: [
+        {
+          name: "runId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "page",
+          in: "query",
+          required: false,
+          schema: { type: "number" },
+          description: "Page number for pagination (default: 0)"
+        },
+        {
+          name: "perPage",
+          in: "query",
+          required: false,
+          schema: { type: "number" },
+          description: "Number of items per page (default: 10)"
+        }
+      ],
+      responses: {
+        200: {
+          description: "Paginated list of scores for run ID"
+        }
+      }
+    }),
+    getScoresByRunIdHandler
+  );
+  router.get(
+    "/scorer/:scorerId",
+    w({
+      description: "Get scores by scorer ID",
+      tags: ["scores"],
+      parameters: [
+        {
+          name: "scorerId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "page",
+          in: "query",
+          required: false,
+          schema: { type: "number" },
+          description: "Page number for pagination (default: 0)"
+        },
+        {
+          name: "perPage",
+          in: "query",
+          required: false,
+          schema: { type: "number" },
+          description: "Number of items per page (default: 10)"
+        }
+      ],
+      responses: {
+        200: {
+          description: "Paginated list of scores for run ID"
+        }
+      }
+    }),
+    getScoresByScorerIdHandler
+  );
+  router.get(
+    "/entity/:entityType/:entityId",
+    w({
+      description: "Get scores by entity ID and type",
+      tags: ["scores"],
+      parameters: [
+        {
+          name: "entityType",
+          in: "path",
+          required: true,
+          schema: { type: "string" },
+          description: "Type of entity (e.g., agent, workflow, tool)"
+        },
+        {
+          name: "entityId",
+          in: "path",
+          required: true,
+          schema: { type: "string" },
+          description: "ID of the entity"
+        },
+        {
+          name: "page",
+          in: "query",
+          required: false,
+          schema: { type: "number" },
+          description: "Page number for pagination (default: 0)"
+        },
+        {
+          name: "perPage",
+          in: "query",
+          required: false,
+          schema: { type: "number" },
+          description: "Number of items per page (default: 10)"
+        }
+      ],
+      responses: {
+        200: {
+          description: "Paginated list of scores for entity"
+        }
+      }
+    }),
+    getScoresByEntityIdHandler
+  );
+  router.post(
+    "/",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    w({
+      description: "Save a score",
+      tags: ["scores"],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                runId: { type: "string" },
+                scorer: { type: "object" },
+                result: { type: "object" },
+                input: { type: "object" },
+                output: { type: "object" },
+                source: { type: "string" },
+                entityType: { type: "string" },
+                entity: { type: "object" },
+                metadata: { type: "object" },
+                additionalLLMContext: { type: "object" },
+                runtimeContext: { type: "object" },
+                resourceId: { type: "string" },
+                threadId: { type: "string" },
+                traceId: { type: "string" }
+              },
+              required: ["id", "runId", "scorer", "result", "input", "output", "source"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Score saved successfully"
+        },
+        400: {
+          description: "Invalid score data"
+        }
+      }
+    }),
+    saveScoreHandler
+  );
+  return router;
+}
 async function getTelemetryHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -6362,7 +7064,7 @@ async function storeTelemetryHandler(c2) {
   }
 }
 
-// src/server/handlers/routes/telemetry.ts
+// src/server/handlers/routes/telemetry/router.ts
 function telemetryRouter() {
   const router = new hono.Hono();
   router.get(
@@ -6579,7 +7281,7 @@ async function deleteIndex(c2) {
   }
 }
 
-// src/server/handlers/routes/vector.ts
+// src/server/handlers/routes/vector/router.ts
 function vectorRouter(bodyLimitOptions) {
   const router = new hono.Hono();
   router.post(
@@ -6794,22 +7496,22 @@ function vectorRouter(bodyLimitOptions) {
   );
   return router;
 }
-async function getLegacyWorkflowsHandler(c2) {
+async function getWorkflowsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const workflows = await legacyWorkflows.getLegacyWorkflowsHandler({
+    const workflows$1 = await workflows.getWorkflowsHandler({
       mastra
     });
-    return c2.json(workflows);
+    return c2.json(workflows$1);
   } catch (error) {
     return handleError(error, "Error getting workflows");
   }
 }
-async function getLegacyWorkflowByIdHandler(c2) {
+async function getWorkflowByIdHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const workflowId = c2.req.param("workflowId");
-    const workflow = await legacyWorkflows.getLegacyWorkflowByIdHandler({
+    const workflow = await workflows.getWorkflowByIdHandler({
       mastra,
       workflowId
     });
@@ -6818,31 +7520,12 @@ async function getLegacyWorkflowByIdHandler(c2) {
     return handleError(error, "Error getting workflow");
   }
 }
-async function startAsyncLegacyWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
-    const workflowId = c2.req.param("workflowId");
-    const triggerData = await c2.req.json();
-    const runId = c2.req.query("runId");
-    const result = await legacyWorkflows.startAsyncLegacyWorkflowHandler({
-      mastra,
-      runtimeContext,
-      workflowId,
-      runId,
-      triggerData
-    });
-    return c2.json(result);
-  } catch (error) {
-    return handleError(error, "Error executing workflow");
-  }
-}
-async function createLegacyWorkflowRunHandler(c2) {
+async function createWorkflowRunHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const workflowId = c2.req.param("workflowId");
     const prevRunId = c2.req.query("runId");
-    const result = await legacyWorkflows.createLegacyWorkflowRunHandler({
+    const result = await workflows.createWorkflowRunHandler({
       mastra,
       workflowId,
       runId: prevRunId
@@ -6852,178 +7535,19 @@ async function createLegacyWorkflowRunHandler(c2) {
     return handleError(e2, "Error creating run");
   }
 }
-async function startLegacyWorkflowRunHandler(c2) {
+async function startAsyncWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const runtimeContext = c2.get("runtimeContext");
     const workflowId = c2.req.param("workflowId");
-    const triggerData = await c2.req.json();
+    const { inputData } = await c2.req.json();
     const runId = c2.req.query("runId");
-    await legacyWorkflows.startLegacyWorkflowRunHandler({
+    const result = await workflows.startAsyncWorkflowHandler({
       mastra,
       runtimeContext,
       workflowId,
       runId,
-      triggerData
-    });
-    return c2.json({ message: "Workflow run started" });
-  } catch (e2) {
-    return handleError(e2, "Error starting workflow run");
-  }
-}
-function watchLegacyWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const logger2 = mastra.getLogger();
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.query("runId");
-    if (!runId) {
-      throw new httpException.HTTPException(400, { message: "runId required to watch workflow" });
-    }
-    return streaming.stream(
-      c2,
-      async (stream5) => {
-        try {
-          const result = await legacyWorkflows.watchLegacyWorkflowHandler({
-            mastra,
-            workflowId,
-            runId
-          });
-          stream5.onAbort(() => {
-            if (!result.locked) {
-              return result.cancel();
-            }
-          });
-          for await (const chunk of result) {
-            await stream5.write(chunk.toString() + "");
-          }
-        } catch (err) {
-          console.log(err);
-        }
-      },
-      async (err) => {
-        logger2.error("Error in watch stream: " + err?.message);
-      }
-    );
-  } catch (error) {
-    return handleError(error, "Error watching workflow");
-  }
-}
-async function resumeAsyncLegacyWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.query("runId");
-    const { stepId, context } = await c2.req.json();
-    if (!runId) {
-      throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
-    }
-    const result = await legacyWorkflows.resumeAsyncLegacyWorkflowHandler({
-      mastra,
-      runtimeContext,
-      workflowId,
-      runId,
-      body: { stepId, context }
-    });
-    return c2.json(result);
-  } catch (error) {
-    return handleError(error, "Error resuming workflow step");
-  }
-}
-async function resumeLegacyWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.query("runId");
-    const { stepId, context } = await c2.req.json();
-    if (!runId) {
-      throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
-    }
-    await legacyWorkflows.resumeLegacyWorkflowHandler({
-      mastra,
-      runtimeContext,
-      workflowId,
-      runId,
-      body: { stepId, context }
-    });
-    return c2.json({ message: "Workflow run resumed" });
-  } catch (error) {
-    return handleError(error, "Error resuming workflow");
-  }
-}
-async function getLegacyWorkflowRunsHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const { fromDate, toDate, limit, offset, resourceId } = c2.req.query();
-    const workflowRuns = await legacyWorkflows.getLegacyWorkflowRunsHandler({
-      mastra,
-      workflowId,
-      fromDate: fromDate ? new Date(fromDate) : void 0,
-      toDate: toDate ? new Date(toDate) : void 0,
-      limit: limit ? Number(limit) : void 0,
-      offset: offset ? Number(offset) : void 0,
-      resourceId
-    });
-    return c2.json(workflowRuns);
-  } catch (error) {
-    return handleError(error, "Error getting workflow runs");
-  }
-}
-async function getWorkflowsHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflows$1 = await workflows.getWorkflowsHandler({
-      mastra
-    });
-    return c2.json(workflows$1);
-  } catch (error) {
-    return handleError(error, "Error getting workflows");
-  }
-}
-async function getWorkflowByIdHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const workflow = await workflows.getWorkflowByIdHandler({
-      mastra,
-      workflowId
-    });
-    return c2.json(workflow);
-  } catch (error) {
-    return handleError(error, "Error getting workflow");
-  }
-}
-async function createWorkflowRunHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const prevRunId = c2.req.query("runId");
-    const result = await workflows.createWorkflowRunHandler({
-      mastra,
-      workflowId,
-      runId: prevRunId
-    });
-    return c2.json(result);
-  } catch (e2) {
-    return handleError(e2, "Error creating run");
-  }
-}
-async function startAsyncWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
-    const workflowId = c2.req.param("workflowId");
-    const { inputData } = await c2.req.json();
-    const runId = c2.req.query("runId");
-    const result = await workflows.startAsyncWorkflowHandler({
-      mastra,
-      runtimeContext,
-      workflowId,
-      runId,
-      inputData
+      inputData
     });
     return c2.json(result);
   } catch (error) {
@@ -7061,7 +7585,7 @@ function watchWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream5) => {
+      async (stream6) => {
         try {
           const result = await workflows.watchWorkflowHandler({
             mastra,
@@ -7069,15 +7593,15 @@ function watchWorkflowHandler(c2) {
             runId
           });
           const reader = result.getReader();
-          stream5.onAbort(() => {
+          stream6.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream5.write(JSON.stringify(chunkResult.value) + "");
+            await stream6.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
-          mastra.getLogger().error("Error in watch stream: " + (err?.message ?? "Unknown error"));
+          logger2.error("Error in watch stream: " + (err?.message ?? "Unknown error"));
         }
       },
       async (err) => {
@@ -7099,7 +7623,7 @@ async function streamWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream5) => {
+      async (stream6) => {
         try {
           const result = await workflows.streamWorkflowHandler({
             mastra,
@@ -7109,16 +7633,17 @@ async function streamWorkflowHandler(c2) {
             runtimeContext
           });
           const reader = result.stream.getReader();
-          stream5.onAbort(() => {
+          stream6.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream5.write(JSON.stringify(chunkResult.value) + "");
+            await stream6.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
-          console.log(err);
+          logger2.error("Error in workflow stream: " + (err?.message ?? "Unknown error"));
         }
+        await stream6.close();
       },
       async (err) => {
         logger2.error("Error in workflow stream: " + err?.message);
@@ -7128,6 +7653,46 @@ async function streamWorkflowHandler(c2) {
     return handleError(error, "Error streaming workflow");
   }
 }
+async function streamVNextWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const logger2 = mastra.getLogger();
+    const workflowId = c2.req.param("workflowId");
+    const { inputData } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(
+      c2,
+      async (stream6) => {
+        try {
+          const result = await workflows.streamVNextWorkflowHandler({
+            mastra,
+            workflowId,
+            runId,
+            inputData,
+            runtimeContext
+          });
+          const reader = result.getReader();
+          stream6.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream6.write(JSON.stringify(chunkResult.value) + "");
+          }
+        } catch (err) {
+          logger2.error("Error in workflow VNext stream: " + (err?.message ?? "Unknown error"));
+        }
+      },
+      async (err) => {
+        logger2.error("Error in workflow VNext stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error streaming workflow");
+  }
+}
 async function resumeAsyncWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -7254,8 +7819,186 @@ async function sendWorkflowRunEventHandler(c2) {
     return handleError(error, "Error sending workflow run event");
   }
 }
+async function getLegacyWorkflowsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflows = await legacyWorkflows.getLegacyWorkflowsHandler({
+      mastra
+    });
+    return c2.json(workflows);
+  } catch (error) {
+    return handleError(error, "Error getting workflows");
+  }
+}
+async function getLegacyWorkflowByIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const workflow = await legacyWorkflows.getLegacyWorkflowByIdHandler({
+      mastra,
+      workflowId
+    });
+    return c2.json(workflow);
+  } catch (error) {
+    return handleError(error, "Error getting workflow");
+  }
+}
+async function startAsyncLegacyWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const workflowId = c2.req.param("workflowId");
+    const triggerData = await c2.req.json();
+    const runId = c2.req.query("runId");
+    const result = await legacyWorkflows.startAsyncLegacyWorkflowHandler({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      triggerData
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error executing workflow");
+  }
+}
+async function createLegacyWorkflowRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const prevRunId = c2.req.query("runId");
+    const result = await legacyWorkflows.createLegacyWorkflowRunHandler({
+      mastra,
+      workflowId,
+      runId: prevRunId
+    });
+    return c2.json(result);
+  } catch (e2) {
+    return handleError(e2, "Error creating run");
+  }
+}
+async function startLegacyWorkflowRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const workflowId = c2.req.param("workflowId");
+    const triggerData = await c2.req.json();
+    const runId = c2.req.query("runId");
+    await legacyWorkflows.startLegacyWorkflowRunHandler({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      triggerData
+    });
+    return c2.json({ message: "Workflow run started" });
+  } catch (e2) {
+    return handleError(e2, "Error starting workflow run");
+  }
+}
+function watchLegacyWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const logger2 = mastra.getLogger();
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to watch workflow" });
+    }
+    return streaming.stream(
+      c2,
+      async (stream6) => {
+        try {
+          const result = await legacyWorkflows.watchLegacyWorkflowHandler({
+            mastra,
+            workflowId,
+            runId
+          });
+          stream6.onAbort(() => {
+            if (!result.locked) {
+              return result.cancel();
+            }
+          });
+          for await (const chunk of result) {
+            await stream6.write(chunk.toString() + "");
+          }
+        } catch (err) {
+          console.log(err);
+        }
+      },
+      async (err) => {
+        logger2.error("Error in watch stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error watching workflow");
+  }
+}
+async function resumeAsyncLegacyWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    const { stepId, context } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    const result = await legacyWorkflows.resumeAsyncLegacyWorkflowHandler({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      body: { stepId, context }
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error resuming workflow step");
+  }
+}
+async function resumeLegacyWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    const { stepId, context } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    await legacyWorkflows.resumeLegacyWorkflowHandler({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      body: { stepId, context }
+    });
+    return c2.json({ message: "Workflow run resumed" });
+  } catch (error) {
+    return handleError(error, "Error resuming workflow");
+  }
+}
+async function getLegacyWorkflowRunsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const { fromDate, toDate, limit, offset, resourceId } = c2.req.query();
+    const workflowRuns = await legacyWorkflows.getLegacyWorkflowRunsHandler({
+      mastra,
+      workflowId,
+      fromDate: fromDate ? new Date(fromDate) : void 0,
+      toDate: toDate ? new Date(toDate) : void 0,
+      limit: limit ? Number(limit) : void 0,
+      offset: offset ? Number(offset) : void 0,
+      resourceId
+    });
+    return c2.json(workflowRuns);
+  } catch (error) {
+    return handleError(error, "Error getting workflow runs");
+  }
+}
 
-// src/server/handlers/routes/workflows.ts
+// src/server/handlers/routes/workflows/router.ts
 function workflowsRouter(bodyLimitOptions) {
   const router = new hono.Hono();
   router.get(
@@ -7792,6 +8535,53 @@ function workflowsRouter(bodyLimitOptions) {
     }),
     streamWorkflowHandler
   );
+  router.post(
+    "/:workflowId/streamVNext",
+    w({
+      description: "Stream workflow in real-time using the VNext streaming API",
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the workflow execution"
+                }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "workflow run started"
+        },
+        404: {
+          description: "workflow not found"
+        }
+      },
+      tags: ["workflows"]
+    }),
+    streamVNextWorkflowHandler
+  );
   router.post(
     "/:workflowId/create-run",
     bodyLimit.bodyLimit(bodyLimitOptions),
@@ -8115,13 +8905,9 @@ var html2 = `
 `;
 
 // src/server/index.ts
-async function createHonoServer(mastra, options = {}) {
-  const app = new hono.Hono();
-  const server = mastra.getServer();
-  let tools$1 = {};
+function getToolExports(tools$1) {
   try {
-    const toolImports = (await import('#tools')).tools;
-    tools$1 = toolImports.reduce((acc, toolModule) => {
+    return tools$1.reduce((acc, toolModule) => {
       Object.entries(toolModule).forEach(([key, tool]) => {
         if (tool instanceof tools.Tool) {
           acc[key] = tool;
@@ -8138,6 +8924,12 @@ ${err.stack.split("\n").slice(1).join("\n")}
       err
     );
   }
+}
+async function createHonoServer(mastra, options = {
+  tools: {}
+}) {
+  const app = new hono.Hono();
+  const server = mastra.getServer();
   app.use("*", async function setTelemetryInfo(c2, next) {
     const requestId = c2.req.header("x-request-id") ?? crypto.randomUUID();
     const span = core.Telemetry.getActiveSpan();
@@ -8175,7 +8967,7 @@ ${err.stack.split("\n").slice(1).join("\n")}
     }
     c2.set("runtimeContext", runtimeContext$1);
     c2.set("mastra", mastra);
-    c2.set("tools", tools$1);
+    c2.set("tools", options.tools);
     c2.set("playground", options.playground === true);
     c2.set("isDev", options.isDev === true);
     return next();
@@ -8409,7 +9201,8 @@ ${err.stack.split("\n").slice(1).join("\n")}
   app.route("/api/telemetry", telemetryRouter());
   app.route("/api/workflows", workflowsRouter(bodyLimitOptions));
   app.route("/api/logs", logsRouter());
-  app.route("/api/tools", toolsRouter(bodyLimitOptions, tools$1));
+  app.route("/api/scores", scoresRouter(bodyLimitOptions));
+  app.route("/api/tools", toolsRouter(bodyLimitOptions, options.tools));
   app.route("/api/vector", vectorRouter(bodyLimitOptions));
   if (options?.isDev || server?.build?.openAPIDocs || server?.build?.swaggerUI) {
     app.get(
@@ -8484,7 +9277,7 @@ ${err.stack.split("\n").slice(1).join("\n")}
   });
   return app;
 }
-async function createNodeServer(mastra, options = {}) {
+async function createNodeServer(mastra, options = { tools: {} }) {
   const app = await createHonoServer(mastra, options);
   const serverOptions = mastra.getServer();
   const port = serverOptions?.port ?? (Number(process.env.PORT) || 4111);
@@ -8516,3 +9309,4 @@ async function createNodeServer(mastra, options = {}) {
 
 exports.createHonoServer = createHonoServer;
 exports.createNodeServer = createNodeServer;
+exports.getToolExports = getToolExports;