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

package/dist/server/index.js

@@ -19,21 +19,22 @@ import { HTTPException } from 'hono/http-exception';
 import { getAgentCardByIdHandler as getAgentCardByIdHandler$1, getAgentExecutionHandler as getAgentExecutionHandler$1 } from '@mastra/server/handlers/a2a';
 import { stream } from 'hono/streaming';
 import { bodyLimit } from 'hono/body-limit';
-import { getAgentsHandler as getAgentsHandler$1, getAgentByIdHandler as getAgentByIdHandler$1, getEvalsByAgentIdHandler as getEvalsByAgentIdHandler$1, getLiveEvalsByAgentIdHandler as getLiveEvalsByAgentIdHandler$1, generateHandler as generateHandler$1, streamGenerateHandler as streamGenerateHandler$1 } from '@mastra/server/handlers/agents';
 import { Agent } from '@mastra/core/agent';
 import { z } from 'zod';
 import { executeAgentToolHandler as executeAgentToolHandler$1, getToolsHandler as getToolsHandler$1, getToolByIdHandler as getToolByIdHandler$1, executeToolHandler as executeToolHandler$1 } from '@mastra/server/handlers/tools';
+import { getAgentsHandler as getAgentsHandler$1, getAgentByIdHandler as getAgentByIdHandler$1, getEvalsByAgentIdHandler as getEvalsByAgentIdHandler$1, getLiveEvalsByAgentIdHandler as getLiveEvalsByAgentIdHandler$1, generateHandler as generateHandler$1, streamGenerateHandler as streamGenerateHandler$1, streamVNextGenerateHandler as streamVNextGenerateHandler$1 } from '@mastra/server/handlers/agents';
 import { getSpeakersHandler as getSpeakersHandler$1, generateSpeechHandler, getListenerHandler as getListenerHandler$1, transcribeSpeechHandler } from '@mastra/server/handlers/voice';
 import { getLogsHandler as getLogsHandler$1, getLogTransports as getLogTransports$1, getLogsByRunIdHandler as getLogsByRunIdHandler$1 } from '@mastra/server/handlers/logs';
 import util from 'util';
 import { Buffer as Buffer$1 } from 'buffer';
-import { getMemoryStatusHandler as getMemoryStatusHandler$1, getThreadsHandler as getThreadsHandler$1, getThreadByIdHandler as getThreadByIdHandler$1, getMessagesHandler as getMessagesHandler$1, createThreadHandler as createThreadHandler$1, updateThreadHandler as updateThreadHandler$1, deleteThreadHandler as deleteThreadHandler$1, saveMessagesHandler as saveMessagesHandler$1, getWorkingMemoryHandler as getWorkingMemoryHandler$1, updateWorkingMemoryHandler as updateWorkingMemoryHandler$1 } from '@mastra/server/handlers/memory';
+import { getMemoryStatusHandler as getMemoryStatusHandler$1, getThreadsHandler as getThreadsHandler$1, getThreadByIdHandler as getThreadByIdHandler$1, getMessagesHandler as getMessagesHandler$1, createThreadHandler as createThreadHandler$1, updateThreadHandler as updateThreadHandler$1, deleteThreadHandler as deleteThreadHandler$1, saveMessagesHandler as saveMessagesHandler$1, getMemoryConfigHandler as getMemoryConfigHandler$1, getMessagesPaginatedHandler as getMessagesPaginatedHandler$1, searchMemoryHandler as searchMemoryHandler$1, getWorkingMemoryHandler as getWorkingMemoryHandler$1, updateWorkingMemoryHandler as updateWorkingMemoryHandler$1 } from '@mastra/server/handlers/memory';
 import { getNetworksHandler as getNetworksHandler$1, getNetworkByIdHandler as getNetworkByIdHandler$1, generateHandler as generateHandler$2, streamGenerateHandler as streamGenerateHandler$2 } from '@mastra/server/handlers/network';
 import { getVNextNetworksHandler as getVNextNetworksHandler$1, getVNextNetworkByIdHandler as getVNextNetworkByIdHandler$1, generateVNextNetworkHandler as generateVNextNetworkHandler$1, loopVNextNetworkHandler as loopVNextNetworkHandler$1, loopStreamVNextNetworkHandler as loopStreamVNextNetworkHandler$1, streamGenerateVNextNetworkHandler as streamGenerateVNextNetworkHandler$1 } from '@mastra/server/handlers/vNextNetwork';
+import { getScorersHandler as getScorersHandler$1, getScorerHandler as getScorerHandler$1, getScoresByRunIdHandler as getScoresByRunIdHandler$1, getScoresByScorerIdHandler as getScoresByScorerIdHandler$1, getScoresByEntityIdHandler as getScoresByEntityIdHandler$1, saveScoreHandler as saveScoreHandler$1 } from '@mastra/server/handlers/scores';
 import { getTelemetryHandler as getTelemetryHandler$1, storeTelemetryHandler as storeTelemetryHandler$1 } from '@mastra/server/handlers/telemetry';
 import { upsertVectors as upsertVectors$1, createIndex as createIndex$1, queryVectors as queryVectors$1, listIndexes as listIndexes$1, describeIndex as describeIndex$1, deleteIndex as deleteIndex$1 } from '@mastra/server/handlers/vector';
+import { getWorkflowsHandler as getWorkflowsHandler$1, getWorkflowByIdHandler as getWorkflowByIdHandler$1, getWorkflowRunsHandler as getWorkflowRunsHandler$1, getWorkflowRunExecutionResultHandler as getWorkflowRunExecutionResultHandler$1, getWorkflowRunByIdHandler as getWorkflowRunByIdHandler$1, resumeWorkflowHandler as resumeWorkflowHandler$1, resumeAsyncWorkflowHandler as resumeAsyncWorkflowHandler$1, streamWorkflowHandler as streamWorkflowHandler$1, streamVNextWorkflowHandler as streamVNextWorkflowHandler$1, createWorkflowRunHandler as createWorkflowRunHandler$1, startAsyncWorkflowHandler as startAsyncWorkflowHandler$1, startWorkflowRunHandler as startWorkflowRunHandler$1, watchWorkflowHandler as watchWorkflowHandler$1, cancelWorkflowRunHandler as cancelWorkflowRunHandler$1, sendWorkflowRunEventHandler as sendWorkflowRunEventHandler$1 } from '@mastra/server/handlers/workflows';
 import { getLegacyWorkflowsHandler as getLegacyWorkflowsHandler$1, getLegacyWorkflowByIdHandler as getLegacyWorkflowByIdHandler$1, getLegacyWorkflowRunsHandler as getLegacyWorkflowRunsHandler$1, resumeLegacyWorkflowHandler as resumeLegacyWorkflowHandler$1, resumeAsyncLegacyWorkflowHandler as resumeAsyncLegacyWorkflowHandler$1, createLegacyWorkflowRunHandler as createLegacyWorkflowRunHandler$1, startAsyncLegacyWorkflowHandler as startAsyncLegacyWorkflowHandler$1, startLegacyWorkflowRunHandler as startLegacyWorkflowRunHandler$1, watchLegacyWorkflowHandler as watchLegacyWorkflowHandler$1 } from '@mastra/server/handlers/legacyWorkflows';
-import { getWorkflowsHandler as getWorkflowsHandler$1, getWorkflowByIdHandler as getWorkflowByIdHandler$1, getWorkflowRunsHandler as getWorkflowRunsHandler$1, getWorkflowRunExecutionResultHandler as getWorkflowRunExecutionResultHandler$1, getWorkflowRunByIdHandler as getWorkflowRunByIdHandler$1, resumeWorkflowHandler as resumeWorkflowHandler$1, resumeAsyncWorkflowHandler as resumeAsyncWorkflowHandler$1, streamWorkflowHandler as streamWorkflowHandler$1, createWorkflowRunHandler as createWorkflowRunHandler$1, startAsyncWorkflowHandler as startAsyncWorkflowHandler$1, startWorkflowRunHandler as startWorkflowRunHandler$1, watchWorkflowHandler as watchWorkflowHandler$1, cancelWorkflowRunHandler as cancelWorkflowRunHandler$1, sendWorkflowRunEventHandler as sendWorkflowRunEventHandler$1 } from '@mastra/server/handlers/workflows';
 
 // src/server/index.ts
 var RequestError = class extends Error {
@@ -258,14 +259,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);
@@ -500,18 +501,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;
@@ -607,10 +608,10 @@ var serveStatic = (options = { root: "" }) => {
       end = size - 1;
     }
     const chunksize = end - start + 1;
-    const stream5 = createReadStream(path, { start, end });
+    const stream6 = 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 = {
@@ -906,15 +907,15 @@ async function getAgentExecutionHandler(c2) {
   if (body.method === "tasks/sendSubscribe") {
     return 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);
@@ -952,6 +953,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);
@@ -1041,6 +1045,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();
   }
@@ -1080,6 +1087,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();
   }
@@ -1130,7 +1140,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");
@@ -1139,7 +1149,7 @@ function handleClientsRefresh(c2) {
       });
     }
   });
-  return new Response(stream5, {
+  return new Response(stream6, {
     headers: {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -1180,111 +1190,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 getAgentsHandler$1({
-    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 getAgentByIdHandler$1({
-    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 getEvalsByAgentIdHandler$1({
-    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 getLiveEvalsByAgentIdHandler$1({
-    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 generateHandler$1({
-      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 streamGenerateHandler$1({
-      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");
@@ -1458,6 +1363,151 @@ async function executeAgentToolHandler(c2) {
     return handleError(error, "Error executing tool");
   }
 }
+async function getAgentsHandler(c2) {
+  const serializedAgents = await getAgentsHandler$1({
+    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 getAgentByIdHandler$1({
+    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 getEvalsByAgentIdHandler$1({
+    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 getLiveEvalsByAgentIdHandler$1({
+    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 generateHandler$1({
+      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 streamGenerateHandler$1({
+      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 stream(
+      c2,
+      async (stream6) => {
+        try {
+          const result = streamVNextGenerateHandler$1({
+            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");
@@ -1531,7 +1581,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();
   router.get(
@@ -1715,16 +1765,81 @@ 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(bodyLimitOptions),
     w({
-      description: "[DEPRECATED] Use /api/agents/:agentId/voice/speakers instead. Get available speakers for an agent",
+      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",
       tags: ["agents"],
       parameters: [
         {
@@ -2350,7 +2465,7 @@ async function getLogTransports(c2) {
   }
 }
 
-// src/server/handlers/routes/logs.ts
+// src/server/handlers/routes/logs/router.ts
 function logsRouter() {
   const router = new Hono();
   router.get(
@@ -4345,7 +4460,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);
@@ -4549,7 +4664,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();
   router.post(
@@ -4958,6 +5073,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");
@@ -4973,6 +5102,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 getMemoryConfigHandler$1({
+      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");
@@ -5083,14 +5227,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 getMessagesHandler$1({
       mastra,
       agentId,
@@ -5103,6 +5240,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 getMessagesPaginatedHandler$1({
+      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");
@@ -5141,8 +5304,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 searchMemoryHandler$1({
+      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();
   router.get(
@@ -5423,6 +5613,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({
@@ -5482,6 +5750,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"],
@@ -5515,46 +5792,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(bodyLimitOptions),
     w({
-      description: "Update working memory for a thread",
+      description: "Get working memory for a thread",
       tags: ["memory"],
       parameters: [
         {
@@ -5568,14 +5951,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(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" }
@@ -5860,7 +6280,7 @@ async function streamGenerateVNextNetworkHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream5) => {
+      async (stream6) => {
         try {
           const result = await streamGenerateVNextNetworkHandler$1({
             mastra,
@@ -5869,12 +6289,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"));
@@ -5915,7 +6335,7 @@ async function loopStreamVNextNetworkHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream5) => {
+      async (stream6) => {
         try {
           const result = await loopStreamVNextNetworkHandler$1({
             mastra,
@@ -5924,12 +6344,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"));
@@ -5944,7 +6364,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();
   router.get(
@@ -6319,6 +6739,288 @@ function networksRouter(bodyLimitOptions) {
   );
   return router;
 }
+async function getScorersHandler(c2) {
+  try {
+    const scorers = await getScorersHandler$1({
+      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 getScorerHandler$1({
+    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 = await getScoresByRunIdHandler$1({
+      mastra,
+      runId,
+      pagination
+    });
+    return c2.json(scores);
+  } 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 = await getScoresByScorerIdHandler$1({
+      mastra,
+      scorerId,
+      pagination,
+      entityId,
+      entityType
+    });
+    return c2.json(scores);
+  } 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 = await getScoresByEntityIdHandler$1({
+      mastra,
+      entityId,
+      entityType,
+      pagination
+    });
+    return c2.json(scores);
+  } 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 saveScoreHandler$1({
+      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();
+  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(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");
@@ -6355,7 +7057,7 @@ async function storeTelemetryHandler(c2) {
   }
 }
 
-// src/server/handlers/routes/telemetry.ts
+// src/server/handlers/routes/telemetry/router.ts
 function telemetryRouter() {
   const router = new Hono();
   router.get(
@@ -6572,7 +7274,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();
   router.post(
@@ -6787,184 +7489,6 @@ function vectorRouter(bodyLimitOptions) {
   );
   return router;
 }
-async function getLegacyWorkflowsHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflows = await getLegacyWorkflowsHandler$1({
-      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 getLegacyWorkflowByIdHandler$1({
-      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 startAsyncLegacyWorkflowHandler$1({
-      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 createLegacyWorkflowRunHandler$1({
-      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 startLegacyWorkflowRunHandler$1({
-      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(400, { message: "runId required to watch workflow" });
-    }
-    return stream(
-      c2,
-      async (stream5) => {
-        try {
-          const result = await watchLegacyWorkflowHandler$1({
-            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(400, { message: "runId required to resume workflow" });
-    }
-    const result = await resumeAsyncLegacyWorkflowHandler$1({
-      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(400, { message: "runId required to resume workflow" });
-    }
-    await resumeLegacyWorkflowHandler$1({
-      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 getLegacyWorkflowRunsHandler$1({
-      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");
@@ -7042,46 +7566,87 @@ async function startWorkflowRunHandler(c2) {
     return handleError(e2, "Error starting workflow run");
   }
 }
-function watchWorkflowHandler(c2) {
+function watchWorkflowHandler(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(400, { message: "runId required to watch workflow" });
+    }
+    c2.header("Transfer-Encoding", "chunked");
+    return stream(
+      c2,
+      async (stream6) => {
+        try {
+          const result = await watchWorkflowHandler$1({
+            mastra,
+            workflowId,
+            runId
+          });
+          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 watch stream: " + (err?.message ?? "Unknown error"));
+        }
+      },
+      async (err) => {
+        logger2.error("Error in watch stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error watching workflow");
+  }
+}
+async function streamWorkflowHandler(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");
-    if (!runId) {
-      throw new HTTPException(400, { message: "runId required to watch workflow" });
-    }
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream5) => {
+      async (stream6) => {
         try {
-          const result = await watchWorkflowHandler$1({
+          const result = await streamWorkflowHandler$1({
             mastra,
             workflowId,
-            runId
+            runId,
+            inputData,
+            runtimeContext
           });
-          const reader = result.getReader();
-          stream5.onAbort(() => {
+          const reader = result.stream.getReader();
+          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 workflow stream: " + (err?.message ?? "Unknown error"));
         }
+        await stream6.close();
       },
       async (err) => {
-        logger2.error("Error in watch stream: " + err?.message);
+        logger2.error("Error in workflow stream: " + err?.message);
       }
     );
   } catch (error) {
-    return handleError(error, "Error watching workflow");
+    return handleError(error, "Error streaming workflow");
   }
 }
-async function streamWorkflowHandler(c2) {
+async function streamVNextWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const runtimeContext = c2.get("runtimeContext");
@@ -7092,29 +7657,29 @@ async function streamWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream5) => {
+      async (stream6) => {
         try {
-          const result = await streamWorkflowHandler$1({
+          const result = await streamVNextWorkflowHandler$1({
             mastra,
             workflowId,
             runId,
             inputData,
             runtimeContext
           });
-          const reader = result.stream.getReader();
-          stream5.onAbort(() => {
+          const reader = result.getReader();
+          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 VNext stream: " + (err?.message ?? "Unknown error"));
         }
       },
       async (err) => {
-        logger2.error("Error in workflow stream: " + err?.message);
+        logger2.error("Error in workflow VNext stream: " + err?.message);
       }
     );
   } catch (error) {
@@ -7247,8 +7812,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 getLegacyWorkflowsHandler$1({
+      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 getLegacyWorkflowByIdHandler$1({
+      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 startAsyncLegacyWorkflowHandler$1({
+      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 createLegacyWorkflowRunHandler$1({
+      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 startLegacyWorkflowRunHandler$1({
+      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(400, { message: "runId required to watch workflow" });
+    }
+    return stream(
+      c2,
+      async (stream6) => {
+        try {
+          const result = await watchLegacyWorkflowHandler$1({
+            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(400, { message: "runId required to resume workflow" });
+    }
+    const result = await resumeAsyncLegacyWorkflowHandler$1({
+      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(400, { message: "runId required to resume workflow" });
+    }
+    await resumeLegacyWorkflowHandler$1({
+      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 getLegacyWorkflowRunsHandler$1({
+      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();
   router.get(
@@ -7785,6 +8528,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(bodyLimitOptions),
@@ -8108,13 +8898,9 @@ var html2 = `
 `;
 
 // src/server/index.ts
-async function createHonoServer(mastra, options = {}) {
-  const app = new Hono();
-  const server = mastra.getServer();
-  let tools = {};
+function getToolExports(tools) {
   try {
-    const toolImports = (await import('#tools')).tools;
-    tools = toolImports.reduce((acc, toolModule) => {
+    return tools.reduce((acc, toolModule) => {
       Object.entries(toolModule).forEach(([key, tool]) => {
         if (tool instanceof Tool) {
           acc[key] = tool;
@@ -8131,6 +8917,12 @@ ${err.stack.split("\n").slice(1).join("\n")}
       err
     );
   }
+}
+async function createHonoServer(mastra, options = {
+  tools: {}
+}) {
+  const app = new Hono();
+  const server = mastra.getServer();
   app.use("*", async function setTelemetryInfo(c2, next) {
     const requestId = c2.req.header("x-request-id") ?? randomUUID();
     const span = Telemetry.getActiveSpan();
@@ -8168,7 +8960,7 @@ ${err.stack.split("\n").slice(1).join("\n")}
     }
     c2.set("runtimeContext", runtimeContext);
     c2.set("mastra", mastra);
-    c2.set("tools", tools);
+    c2.set("tools", options.tools);
     c2.set("playground", options.playground === true);
     c2.set("isDev", options.isDev === true);
     return next();
@@ -8402,7 +9194,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));
+  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(
@@ -8477,7 +9270,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);
@@ -8507,4 +9300,4 @@ async function createNodeServer(mastra, options = {}) {
   return server;
 }
 
-export { createHonoServer, createNodeServer };
+export { createHonoServer, createNodeServer, getToolExports };