@mastra/deployer 0.24.0 → 1.0.0-beta.1

package/dist/server/index.cjs

@@ -1,18 +1,17 @@
 'use strict';
 
-var crypto = require('crypto');
 var promises = require('fs/promises');
 var https = require('https');
 var posix = require('path/posix');
 var http = require('http');
 var http2 = require('http2');
 var stream = require('stream');
+var crypto = require('crypto');
 var mime = require('hono/utils/mime');
 var fs = require('fs');
 var path = require('path');
 var html = require('hono/html');
-var runtimeContext = require('@mastra/core/runtime-context');
-var telemetry = require('@mastra/core/telemetry');
+var requestContext = require('@mastra/core/request-context');
 var tools = require('@mastra/core/tools');
 var store = require('@mastra/server/a2a/store');
 var hono = require('hono');
@@ -36,13 +35,11 @@ var logs = require('@mastra/server/handlers/logs');
 var util = require('util');
 var buffer = require('buffer');
 var memory = require('@mastra/server/handlers/memory');
-var aiTracing = require('@mastra/core/ai-tracing');
-var observability = require('@mastra/server/handlers/observability');
+var observability = require('@mastra/core/observability');
+var observability$1 = require('@mastra/server/handlers/observability');
 var scores = require('@mastra/server/handlers/scores');
-var telemetry$1 = require('@mastra/server/handlers/telemetry');
 var vector = require('@mastra/server/handlers/vector');
 var workflows = require('@mastra/server/handlers/workflows');
-var legacyWorkflows = require('@mastra/server/handlers/legacyWorkflows');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -64,8 +61,8 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var https__namespace = /*#__PURE__*/_interopNamespace(https);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var util__default = /*#__PURE__*/_interopDefault(util);
 
 // src/server/index.ts
@@ -353,13 +350,13 @@ function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromi
     }
   }
 }
-function writeFromReadableStream(stream6, writable) {
-  if (stream6.locked) {
+function writeFromReadableStream(stream5, writable) {
+  if (stream5.locked) {
     throw new TypeError("ReadableStream is locked.");
   } else if (writable.destroyed) {
     return;
   }
-  return writeFromReadableStreamDefaultReader(stream6.getReader(), writable);
+  return writeFromReadableStreamDefaultReader(stream5.getReader(), writable);
 }
 var buildOutgoingHttpHeaders = (headers) => {
   const res = {};
@@ -624,21 +621,21 @@ var ENCODINGS = {
   gzip: ".gz"
 };
 var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
-var createStreamBody = (stream6) => {
+var createStreamBody = (stream5) => {
   const body = new ReadableStream({
     start(controller) {
-      stream6.on("data", (chunk) => {
+      stream5.on("data", (chunk) => {
         controller.enqueue(chunk);
       });
-      stream6.on("error", (err) => {
+      stream5.on("error", (err) => {
         controller.error(err);
       });
-      stream6.on("end", () => {
+      stream5.on("end", () => {
         controller.close();
       });
     },
     cancel() {
-      stream6.destroy();
+      stream5.destroy();
     }
   });
   return body;
@@ -689,7 +686,6 @@ var serveStatic = (options = { root: "" }) => {
       await options.onNotFound?.(path$1, c2);
       return next();
     }
-    await options.onFound?.(path$1, c2);
     const mimeType = mime.getMimeType(path$1);
     c2.header("Content-Type", mimeType || "application/octet-stream");
     if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
@@ -710,30 +706,33 @@ var serveStatic = (options = { root: "" }) => {
         }
       }
     }
+    let result;
     const size = stats.size;
+    const range = c2.req.header("range") || "";
     if (c2.req.method == "HEAD" || c2.req.method == "OPTIONS") {
       c2.header("Content-Length", size.toString());
       c2.status(200);
-      return c2.body(null);
-    }
-    const range = c2.req.header("range") || "";
-    if (!range) {
+      result = c2.body(null);
+    } else if (!range) {
       c2.header("Content-Length", size.toString());
-      return c2.body(createStreamBody(fs.createReadStream(path$1)), 200);
-    }
-    c2.header("Accept-Ranges", "bytes");
-    c2.header("Date", stats.birthtime.toUTCString());
-    const parts = range.replace(/bytes=/, "").split("-", 2);
-    const start = parseInt(parts[0], 10) || 0;
-    let end = parseInt(parts[1], 10) || size - 1;
-    if (size < end - start + 1) {
-      end = size - 1;
-    }
-    const chunksize = end - start + 1;
-    const stream6 = fs.createReadStream(path$1, { start, end });
-    c2.header("Content-Length", chunksize.toString());
-    c2.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-    return c2.body(createStreamBody(stream6), 206);
+      result = c2.body(createStreamBody(fs.createReadStream(path$1)), 200);
+    } else {
+      c2.header("Accept-Ranges", "bytes");
+      c2.header("Date", stats.birthtime.toUTCString());
+      const parts = range.replace(/bytes=/, "").split("-", 2);
+      const start = parseInt(parts[0], 10) || 0;
+      let end = parseInt(parts[1], 10) || size - 1;
+      if (size < end - start + 1) {
+        end = size - 1;
+      }
+      const chunksize = end - start + 1;
+      const stream5 = fs.createReadStream(path$1, { start, end });
+      c2.header("Content-Length", chunksize.toString());
+      c2.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
+      result = c2.body(createStreamBody(stream5), 206);
+    }
+    await options.onFound?.(path$1, c2);
+    return result;
   };
 };
 var RENDER_TYPE = {
@@ -854,7 +853,7 @@ var middleware = (options) => async (c2) => {
   );
 };
 
-// ../../node_modules/.pnpm/hono-openapi@0.4.8_hono@4.10.1_openapi-types@12.1.3_zod@3.25.76/node_modules/hono-openapi/utils.js
+// ../../node_modules/.pnpm/hono-openapi@0.4.8_hono@4.10.3_openapi-types@12.1.3_zod@3.25.76/node_modules/hono-openapi/utils.js
 var e = Symbol("openapi");
 var n = ["GET", "PUT", "POST", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"];
 var s2 = (e2) => e2.charAt(0).toUpperCase() + e2.slice(1);
@@ -1000,18 +999,18 @@ async function x(e2, t2, n2 = {}) {
 async function getAgentCardByIdHandler(c2) {
   const mastra = c2.get("mastra");
   const agentId = c2.req.param("agentId");
-  const runtimeContext = c2.get("runtimeContext");
+  const requestContext = c2.get("requestContext");
   const result = await a2a.getAgentCardByIdHandler({
     mastra,
     agentId,
-    runtimeContext
+    requestContext
   });
   return c2.json(result);
 }
 async function getAgentExecutionHandler(c2) {
   const mastra = c2.get("mastra");
   const agentId = c2.req.param("agentId");
-  const runtimeContext = c2.get("runtimeContext");
+  const requestContext = c2.get("requestContext");
   const taskStore = c2.get("taskStore");
   const logger2 = mastra.getLogger();
   const body = await c2.req.json();
@@ -1021,7 +1020,7 @@ async function getAgentExecutionHandler(c2) {
   const result = await a2a.getAgentExecutionHandler({
     mastra,
     agentId,
-    runtimeContext,
+    requestContext,
     requestId: crypto.randomUUID(),
     method: body.method,
     params: body.params,
@@ -1031,15 +1030,15 @@ async function getAgentExecutionHandler(c2) {
   if (body.method === "message/stream") {
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream5) => {
         try {
-          stream6.onAbort(() => {
+          stream5.onAbort(() => {
             if (!result.locked) {
               return result.cancel();
             }
           });
           for await (const chunk of result) {
-            await stream6.write(JSON.stringify(chunk) + "");
+            await stream5.write(JSON.stringify(chunk) + "");
           }
         } catch (err) {
           logger2.error("Error in message/stream stream: " + err?.message);
@@ -1179,7 +1178,7 @@ var checkRules = async (rules, path, method, user) => {
 // src/server/handlers/auth/index.ts
 var authenticationMiddleware = async (c2, next) => {
   const mastra = c2.get("mastra");
-  const authConfig = mastra.getServer()?.experimental_auth;
+  const authConfig = mastra.getServer()?.auth;
   const customRouteAuthConfig = c2.get("customRouteAuthConfig");
   if (!authConfig) {
     return next();
@@ -1211,7 +1210,7 @@ var authenticationMiddleware = async (c2, next) => {
     if (!user) {
       return c2.json({ error: "Invalid or expired token" }, 401);
     }
-    c2.get("runtimeContext").set("user", user);
+    c2.get("requestContext").set("user", user);
     return next();
   } catch (err) {
     console.error(err);
@@ -1220,7 +1219,7 @@ var authenticationMiddleware = async (c2, next) => {
 };
 var authorizationMiddleware = async (c2, next) => {
   const mastra = c2.get("mastra");
-  const authConfig = mastra.getServer()?.experimental_auth;
+  const authConfig = mastra.getServer()?.auth;
   const customRouteAuthConfig = c2.get("customRouteAuthConfig");
   if (!authConfig) {
     return next();
@@ -1236,7 +1235,7 @@ var authorizationMiddleware = async (c2, next) => {
   if (canAccessPublicly(path, method, authConfig)) {
     return next();
   }
-  const user = c2.get("runtimeContext").get("user");
+  const user = c2.get("requestContext").get("user");
   if ("authorizeUser" in authConfig && typeof authConfig.authorizeUser === "function") {
     try {
       const isAuthorized = await authConfig.authorizeUser(user, c2.req);
@@ -1281,7 +1280,7 @@ var authorizationMiddleware = async (c2, next) => {
 var clients = /* @__PURE__ */ new Set();
 var hotReloadDisabled = false;
 function handleClientsRefresh(c2) {
-  const stream6 = new ReadableStream({
+  const stream5 = new ReadableStream({
     start(controller) {
       clients.add(controller);
       controller.enqueue("data: connected\n\n");
@@ -1290,7 +1289,7 @@ function handleClientsRefresh(c2) {
       });
     }
   });
-  return new Response(stream6, {
+  return new Response(stream5, {
     headers: {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -1338,6 +1337,11 @@ function errorHandler(err, c2, isDev) {
   return c2.json({ error: "Internal Server Error" }, 500);
 }
 
+// src/server/handlers/health.ts
+async function healthHandler(c2) {
+  return c2.json({ success: true }, 200);
+}
+
 // src/server/handlers/root.ts
 async function rootHandler(c2) {
   const baseUrl = new URL(c2.req.url).origin;
@@ -1499,17 +1503,18 @@ async function createAgentBuilderActionRunHandler(c2) {
 async function startAsyncAgentBuilderActionHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const actionId = c2.req.param("actionId");
-    const { inputData } = await c2.req.json();
+    const { inputData, tracingOptions } = await c2.req.json();
     const runId = c2.req.query("runId");
     disableHotReload();
     const result = await agentBuilder.startAsyncAgentBuilderActionHandler({
       mastra,
-      runtimeContext,
+      requestContext,
       actionId,
       runId,
-      inputData
+      inputData,
+      tracingOptions
     });
     enableHotReload();
     return c2.json(result);
@@ -1521,73 +1526,35 @@ async function startAsyncAgentBuilderActionHandler(c2) {
 async function startAgentBuilderActionRunHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const actionId = c2.req.param("actionId");
-    const { inputData } = await c2.req.json();
+    const { inputData, tracingOptions } = await c2.req.json();
     const runId = c2.req.query("runId");
     await agentBuilder.startAgentBuilderActionRunHandler({
       mastra,
-      runtimeContext,
+      requestContext,
       actionId,
       runId,
-      inputData
+      inputData,
+      tracingOptions
     });
     return c2.json({ message: "Agent builder action run started" });
   } catch (error) {
     return handleError(error, "Error starting agent builder action run");
   }
 }
-async function watchAgentBuilderActionHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const logger2 = mastra.getLogger();
-    const actionId = c2.req.param("actionId");
-    const runId = c2.req.query("runId");
-    const eventType = c2.req.query("eventType");
-    if (!runId) {
-      throw new httpException.HTTPException(400, { message: "runId required to watch action" });
-    }
-    c2.header("Transfer-Encoding", "chunked");
-    return streaming.stream(c2, async (stream6) => {
-      try {
-        disableHotReload();
-        const result = await agentBuilder.watchAgentBuilderActionHandler({
-          mastra,
-          actionId,
-          runId,
-          eventType
-        });
-        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) + "");
-        }
-        enableHotReload();
-      } catch (err) {
-        enableHotReload();
-        logger2.error("Error in watch stream: " + (err?.message ?? "Unknown error"));
-      }
-    });
-  } catch (error) {
-    enableHotReload();
-    return handleError(error, "Error watching agent builder action");
-  }
-}
 async function streamAgentBuilderActionHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const logger2 = mastra.getLogger();
     const actionId = c2.req.param("actionId");
-    const { inputData } = await c2.req.json();
+    const { inputData, tracingOptions } = await c2.req.json();
     const runId = c2.req.query("runId");
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream5) => {
         try {
           disableHotReload();
           const result = await agentBuilder.streamAgentBuilderActionHandler({
@@ -1595,20 +1562,21 @@ async function streamAgentBuilderActionHandler(c2) {
             actionId,
             runId,
             inputData,
-            runtimeContext
+            requestContext,
+            tracingOptions
           });
-          const reader = result.stream.getReader();
-          stream6.onAbort(() => {
+          const reader = result.getReader();
+          stream5.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream5.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           logger2.error("Error in action stream: " + (err?.message ?? "Unknown error"));
         }
-        await stream6.close();
+        await stream5.close();
         enableHotReload();
       },
       async (err) => {
@@ -1623,15 +1591,15 @@ async function streamAgentBuilderActionHandler(c2) {
 async function streamVNextAgentBuilderActionHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const logger2 = mastra.getLogger();
     const actionId = c2.req.param("actionId");
-    const { inputData } = await c2.req.json();
+    const { inputData, closeOnSuspend, tracingOptions } = await c2.req.json();
     const runId = c2.req.query("runId");
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream5) => {
         try {
           disableHotReload();
           const result = await agentBuilder.streamVNextAgentBuilderActionHandler({
@@ -1639,15 +1607,17 @@ async function streamVNextAgentBuilderActionHandler(c2) {
             actionId,
             runId,
             inputData,
-            runtimeContext
+            requestContext,
+            closeOnSuspend,
+            tracingOptions
           });
           const reader = result.getReader();
-          stream6.onAbort(() => {
+          stream5.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream5.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           logger2.error("Error in action VNext stream: " + (err?.message ?? "Unknown error"));
@@ -1666,20 +1636,21 @@ async function streamVNextAgentBuilderActionHandler(c2) {
 async function resumeAsyncAgentBuilderActionHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const actionId = c2.req.param("actionId");
     const runId = c2.req.query("runId");
-    const { step, resumeData } = await c2.req.json();
+    const { step, resumeData, tracingOptions } = await c2.req.json();
     if (!runId) {
       throw new httpException.HTTPException(400, { message: "runId required to resume action" });
     }
     disableHotReload();
     const result = await agentBuilder.resumeAsyncAgentBuilderActionHandler({
       mastra,
-      runtimeContext,
+      requestContext,
       actionId,
       runId,
-      body: { step, resumeData }
+      body: { step, resumeData },
+      tracingOptions
     });
     enableHotReload();
     return c2.json(result);
@@ -1691,20 +1662,21 @@ async function resumeAsyncAgentBuilderActionHandler(c2) {
 async function resumeAgentBuilderActionHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const actionId = c2.req.param("actionId");
     const runId = c2.req.query("runId");
-    const { step, resumeData } = await c2.req.json();
+    const { step, resumeData, tracingOptions } = await c2.req.json();
     if (!runId) {
       throw new httpException.HTTPException(400, { message: "runId required to resume action" });
     }
     disableHotReload();
     await agentBuilder.resumeAgentBuilderActionHandler({
       mastra,
-      runtimeContext,
+      requestContext,
       actionId,
       runId,
-      body: { step, resumeData }
+      body: { step, resumeData },
+      tracingOptions
     });
     enableHotReload();
     return c2.json({ message: "Action run resumed" });
@@ -1717,14 +1689,15 @@ async function getAgentBuilderActionRunsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const actionId = c2.req.param("actionId");
-    const { fromDate, toDate, limit, offset, resourceId } = c2.req.query();
+    const queryParams = c2.req.query();
+    const { fromDate, toDate, perPage, page, resourceId } = queryParams;
     const runs = await agentBuilder.getAgentBuilderActionRunsHandler({
       mastra,
       actionId,
       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,
+      perPage: perPage !== null && perPage !== void 0 && !isNaN(Number(perPage)) ? Number(perPage) : void 0,
+      page: page !== null && page !== void 0 && !isNaN(Number(page)) ? Number(page) : void 0,
       resourceId
     });
     return c2.json(runs);
@@ -1777,22 +1750,219 @@ async function cancelAgentBuilderActionRunHandler(c2) {
     return handleError(error, "Error cancelling agent builder action run");
   }
 }
-async function sendAgentBuilderActionRunEventHandler(c2) {
+async function streamLegacyAgentBuilderActionHandler(c2) {
   try {
     const mastra = c2.get("mastra");
+    const requestContext = c2.get("requestContext");
+    const logger2 = mastra.getLogger();
     const actionId = c2.req.param("actionId");
-    const runId = c2.req.param("runId");
-    const { event, data } = await c2.req.json();
-    const result = await agentBuilder.sendAgentBuilderActionRunEventHandler({
-      mastra,
-      actionId,
-      runId,
-      event,
-      data
+    const { inputData, tracingOptions } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(
+      c2,
+      async (stream5) => {
+        try {
+          disableHotReload();
+          const result = await agentBuilder.streamLegacyAgentBuilderActionHandler({
+            mastra,
+            actionId,
+            runId,
+            inputData,
+            requestContext,
+            tracingOptions
+          });
+          const reader = result?.stream?.getReader();
+          if (!reader) {
+            throw new Error("No reader available from legacy stream");
+          }
+          stream5.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream5.write(JSON.stringify(chunkResult.value) + "");
+          }
+        } catch (err) {
+          logger2.error("Error in action legacy stream: " + (err?.message ?? "Unknown error"));
+        }
+        await stream5.close();
+        enableHotReload();
+      },
+      async (err) => {
+        logger2.error("Error in action legacy stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    enableHotReload();
+    return handleError(error, "Error streaming legacy agent builder action");
+  }
+}
+async function observeStreamLegacyAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const logger2 = mastra.getLogger();
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.query("runId");
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to observe stream" });
+    }
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(c2, async (stream5) => {
+      try {
+        disableHotReload();
+        const result = await agentBuilder.observeStreamLegacyAgentBuilderActionHandler({
+          mastra,
+          actionId,
+          runId
+        });
+        const reader = result?.getReader();
+        if (!reader) {
+          throw new Error("No reader available from observe stream");
+        }
+        stream5.onAbort(() => {
+          void reader.cancel("request aborted");
+        });
+        let chunkResult;
+        while ((chunkResult = await reader.read()) && !chunkResult.done) {
+          await stream5.write(JSON.stringify(chunkResult.value) + "");
+        }
+        enableHotReload();
+      } catch (err) {
+        enableHotReload();
+        logger2.error("Error in observe legacy stream: " + (err?.message ?? "Unknown error"));
+      }
     });
-    return c2.json(result);
   } catch (error) {
-    return handleError(error, "Error sending agent builder action run event");
+    enableHotReload();
+    return handleError(error, "Error observing legacy stream for agent builder action");
+  }
+}
+async function observeStreamAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const logger2 = mastra.getLogger();
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.query("runId");
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to observe stream" });
+    }
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(c2, async (stream5) => {
+      try {
+        disableHotReload();
+        const result = await agentBuilder.observeStreamAgentBuilderActionHandler({
+          mastra,
+          actionId,
+          runId
+        });
+        const reader = result?.getReader();
+        if (!reader) {
+          throw new Error("No reader available from observe stream");
+        }
+        stream5.onAbort(() => {
+          void reader.cancel("request aborted");
+        });
+        let chunkResult;
+        while ((chunkResult = await reader.read()) && !chunkResult.done) {
+          await stream5.write(JSON.stringify(chunkResult.value) + "");
+        }
+        enableHotReload();
+      } catch (err) {
+        enableHotReload();
+        logger2.error("Error in observe stream: " + (err?.message ?? "Unknown error"));
+      }
+    });
+  } catch (error) {
+    enableHotReload();
+    return handleError(error, "Error observing stream for agent builder action");
+  }
+}
+async function observeStreamVNextAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const logger2 = mastra.getLogger();
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.query("runId");
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to observe stream" });
+    }
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(c2, async (stream5) => {
+      try {
+        disableHotReload();
+        const result = await agentBuilder.observeStreamVNextAgentBuilderActionHandler({
+          mastra,
+          actionId,
+          runId
+        });
+        const reader = result?.getReader();
+        if (!reader) {
+          throw new Error("No reader available from observe stream VNext");
+        }
+        stream5.onAbort(() => {
+          void reader.cancel("request aborted");
+        });
+        let chunkResult;
+        while ((chunkResult = await reader.read()) && !chunkResult.done) {
+          await stream5.write(JSON.stringify(chunkResult.value) + "");
+        }
+        enableHotReload();
+      } catch (err) {
+        enableHotReload();
+        logger2.error("Error in observe VNext stream: " + (err?.message ?? "Unknown error"));
+      }
+    });
+  } catch (error) {
+    enableHotReload();
+    return handleError(error, "Error observing VNext stream for agent builder action");
+  }
+}
+async function resumeStreamAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const requestContext = c2.get("requestContext");
+    const logger2 = mastra.getLogger();
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.query("runId");
+    const { step, resumeData, tracingOptions } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to resume stream" });
+    }
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(
+      c2,
+      async (stream5) => {
+        try {
+          disableHotReload();
+          const result = await agentBuilder.resumeStreamAgentBuilderActionHandler({
+            mastra,
+            actionId,
+            runId,
+            requestContext,
+            body: { step, resumeData },
+            tracingOptions
+          });
+          const reader = result.getReader();
+          stream5.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream5.write(JSON.stringify(chunkResult.value) + "");
+          }
+        } catch (err) {
+          logger2.error("Error in resume stream: " + (err?.message ?? "Unknown error"));
+        }
+        enableHotReload();
+      },
+      async (err) => {
+        logger2.error("Error in resume stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    enableHotReload();
+    return handleError(error, "Error resuming stream for agent builder action");
   }
 }
 
@@ -1952,9 +2122,20 @@ function agentBuilderRouter(bodyLimitOptions) {
                   oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
                 },
                 resumeData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
                   type: "object",
-                  description: "Runtime context for the agent builder action execution"
+                  description: "Request Context for the agent builder action execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the action execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
                 }
               }
             }
@@ -1995,9 +2176,20 @@ function agentBuilderRouter(bodyLimitOptions) {
                   oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
                 },
                 resumeData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
+                  type: "object",
+                  description: "Request Context for the agent builder action execution"
+                },
+                tracingOptions: {
                   type: "object",
-                  description: "Runtime context for the agent builder action execution"
+                  description: "Tracing options for the action execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
                 }
               }
             }
@@ -2008,9 +2200,10 @@ function agentBuilderRouter(bodyLimitOptions) {
     resumeAsyncAgentBuilderActionHandler
   );
   router.post(
-    "/:actionId/stream",
+    "/:actionId/resume-stream",
     w({
-      description: "Stream agent builder action in real-time",
+      description: "Resume a suspended agent builder action that uses streamVNext",
+      tags: ["agent-builder"],
       parameters: [
         {
           name: "actionId",
@@ -2021,7 +2214,7 @@ function agentBuilderRouter(bodyLimitOptions) {
         {
           name: "runId",
           in: "query",
-          required: false,
+          required: true,
           schema: { type: "string" }
         }
       ],
@@ -2032,32 +2225,38 @@ function agentBuilderRouter(bodyLimitOptions) {
             schema: {
               type: "object",
               properties: {
-                inputData: { type: "object" },
-                runtimeContext: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                resumeData: { type: "object" },
+                requestContext: {
+                  type: "object",
+                  description: "Request Context for the agent builder action execution"
+                },
+                tracingOptions: {
                   type: "object",
-                  description: "Runtime context for the agent builder action execution"
+                  description: "Tracing options for the action execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
                 }
-              }
+              },
+              required: ["step"]
             }
           }
         }
-      },
-      responses: {
-        200: {
-          description: "agent builder action run started"
-        },
-        404: {
-          description: "agent builder action not found"
-        }
-      },
-      tags: ["agent-builder"]
+      }
     }),
-    streamAgentBuilderActionHandler
+    resumeStreamAgentBuilderActionHandler
   );
   router.post(
-    "/:actionId/streamVNext",
+    "/:actionId/stream-legacy",
     w({
-      description: "Stream agent builder action in real-time using the VNext streaming API",
+      description: "Stream legacy agent builder action in real-time",
       parameters: [
         {
           name: "actionId",
@@ -2080,9 +2279,20 @@ function agentBuilderRouter(bodyLimitOptions) {
               type: "object",
               properties: {
                 inputData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
                   type: "object",
-                  description: "Runtime context for the agent builder action execution"
+                  description: "Request Context for the agent builder action execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the action execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
                 }
               }
             }
@@ -2099,14 +2309,12 @@ function agentBuilderRouter(bodyLimitOptions) {
       },
       tags: ["agent-builder"]
     }),
-    streamVNextAgentBuilderActionHandler
+    streamLegacyAgentBuilderActionHandler
   );
   router.post(
-    "/:actionId/create-run",
-    bodyLimit.bodyLimit(bodyLimitOptions),
+    "/:actionId/observe-stream-legacy",
     w({
-      description: "Create a new agent builder action run",
-      tags: ["agent-builder"],
+      description: "Observe agent builder action stream in real-time",
       parameters: [
         {
           name: "actionId",
@@ -2117,24 +2325,26 @@ function agentBuilderRouter(bodyLimitOptions) {
         {
           name: "runId",
           in: "query",
-          required: false,
+          required: true,
           schema: { type: "string" }
         }
       ],
       responses: {
         200: {
-          description: "New agent builder action run created"
+          description: "agent builder action stream observed"
+        },
+        404: {
+          description: "agent builder action not found"
         }
-      }
+      },
+      tags: ["agent-builder"]
     }),
-    createAgentBuilderActionRunHandler
+    observeStreamLegacyAgentBuilderActionHandler
   );
   router.post(
-    "/:actionId/start-async",
-    bodyLimit.bodyLimit(bodyLimitOptions),
+    "/:actionId/stream",
     w({
-      description: "Execute/Start an agent builder action",
-      tags: ["agent-builder"],
+      description: "Stream agent builder action in real-time",
       parameters: [
         {
           name: "actionId",
@@ -2157,9 +2367,20 @@ function agentBuilderRouter(bodyLimitOptions) {
               type: "object",
               properties: {
                 inputData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
+                  type: "object",
+                  description: "Request Context for the agent builder action execution"
+                },
+                tracingOptions: {
                   type: "object",
-                  description: "Runtime context for the agent builder action execution"
+                  description: "Tracing options for the action execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
                 }
               }
             }
@@ -2168,20 +2389,50 @@ function agentBuilderRouter(bodyLimitOptions) {
       },
       responses: {
         200: {
-          description: "agent builder action execution result"
+          description: "agent builder action run started"
         },
         404: {
           description: "agent builder action not found"
         }
-      }
+      },
+      tags: ["agent-builder"]
     }),
-    startAsyncAgentBuilderActionHandler
+    streamAgentBuilderActionHandler
   );
   router.post(
-    "/:actionId/start",
+    "/:actionId/observe",
     w({
-      description: "Create and start a new agent builder action run",
-      tags: ["agent-builder"],
+      description: "Observe agent builder action stream in real-time using the streaming API",
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "agent builder action stream observed"
+        },
+        404: {
+          description: "agent builder action not found"
+        }
+      },
+      tags: ["agent-builder"]
+    }),
+    observeStreamAgentBuilderActionHandler
+  );
+  router.post(
+    "/:actionId/observe-streamVNext",
+    w({
+      description: "Observe agent builder action stream in real-time using the VNext streaming API",
       parameters: [
         {
           name: "actionId",
@@ -2196,6 +2447,36 @@ function agentBuilderRouter(bodyLimitOptions) {
           schema: { type: "string" }
         }
       ],
+      responses: {
+        200: {
+          description: "agent builder action stream vNext observed"
+        },
+        404: {
+          description: "agent builder action not found"
+        }
+      },
+      tags: ["agent-builder"]
+    }),
+    observeStreamVNextAgentBuilderActionHandler
+  );
+  router.post(
+    "/:actionId/streamVNext",
+    w({
+      description: "Stream agent builder action in real-time using the VNext streaming API",
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        }
+      ],
       requestBody: {
         required: true,
         content: {
@@ -2204,9 +2485,24 @@ function agentBuilderRouter(bodyLimitOptions) {
               type: "object",
               properties: {
                 inputData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
+                  type: "object",
+                  description: "Request Context for the agent builder action execution"
+                },
+                closeOnSuspend: {
+                  type: "boolean",
+                  description: "Close the stream on suspend"
+                },
+                tracingOptions: {
                   type: "object",
-                  description: "Runtime context for the agent builder action execution"
+                  description: "Tracing options for the action execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
                 }
               }
             }
@@ -2220,14 +2516,17 @@ function agentBuilderRouter(bodyLimitOptions) {
         404: {
           description: "agent builder action not found"
         }
-      }
+      },
+      tags: ["agent-builder"]
     }),
-    startAgentBuilderActionRunHandler
+    streamVNextAgentBuilderActionHandler
   );
-  router.get(
-    "/:actionId/watch",
+  router.post(
+    "/:actionId/create-run",
+    bodyLimit.bodyLimit(bodyLimitOptions),
     w({
-      description: "Watch agent builder action transitions in real-time",
+      description: "Create a new agent builder action run",
+      tags: ["agent-builder"],
       parameters: [
         {
           name: "actionId",
@@ -2240,27 +2539,22 @@ function agentBuilderRouter(bodyLimitOptions) {
           in: "query",
           required: false,
           schema: { type: "string" }
-        },
-        {
-          name: "eventType",
-          in: "query",
-          required: false,
-          schema: { type: "string", enum: ["watch", "watch-v2"] }
         }
       ],
-      tags: ["agent-builder"],
       responses: {
         200: {
-          description: "agent builder action transitions in real-time"
+          description: "New agent builder action run created"
         }
       }
     }),
-    watchAgentBuilderActionHandler
+    createAgentBuilderActionRunHandler
   );
   router.post(
-    "/:actionId/runs/:runId/cancel",
+    "/:actionId/start-async",
+    bodyLimit.bodyLimit(bodyLimitOptions),
     w({
-      description: "Cancel an agent builder action run",
+      description: "Execute/Start an agent builder action",
+      tags: ["agent-builder"],
       parameters: [
         {
           name: "actionId",
@@ -2270,24 +2564,55 @@ function agentBuilderRouter(bodyLimitOptions) {
         },
         {
           name: "runId",
-          in: "path",
-          required: true,
+          in: "query",
+          required: false,
           schema: { type: "string" }
         }
       ],
-      tags: ["agent-builder"],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object" },
+                requestContext: {
+                  type: "object",
+                  description: "Request Context for the agent builder action execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the action execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
       responses: {
         200: {
-          description: "agent builder action run cancelled"
+          description: "agent builder action execution result"
+        },
+        404: {
+          description: "agent builder action not found"
         }
       }
     }),
-    cancelAgentBuilderActionRunHandler
+    startAsyncAgentBuilderActionHandler
   );
   router.post(
-    "/:actionId/runs/:runId/send-event",
+    "/:actionId/start",
     w({
-      description: "Send an event to an agent builder action run",
+      description: "Create and start a new agent builder action run",
+      tags: ["agent-builder"],
       parameters: [
         {
           name: "actionId",
@@ -2297,7 +2622,7 @@ function agentBuilderRouter(bodyLimitOptions) {
         },
         {
           name: "runId",
-          in: "path",
+          in: "query",
           required: true,
           schema: { type: "string" }
         }
@@ -2306,18 +2631,67 @@ function agentBuilderRouter(bodyLimitOptions) {
         required: true,
         content: {
           "application/json": {
-            schema: { type: "object", properties: { event: { type: "string" }, data: { type: "object" } } }
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object" },
+                requestContext: {
+                  type: "object",
+                  description: "Request Context for the agent builder action execution"
+                },
+                tracingOptions: {
+                  type: "object",
+                  description: "Tracing options for the action execution",
+                  properties: {
+                    metadata: {
+                      type: "object",
+                      description: "Custom metadata to attach to the trace",
+                      additionalProperties: true
+                    }
+                  }
+                }
+              }
+            }
           }
         }
       },
+      responses: {
+        200: {
+          description: "agent builder action run started"
+        },
+        404: {
+          description: "agent builder action not found"
+        }
+      }
+    }),
+    startAgentBuilderActionRunHandler
+  );
+  router.post(
+    "/:actionId/runs/:runId/cancel",
+    w({
+      description: "Cancel an agent builder action run",
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
       tags: ["agent-builder"],
       responses: {
         200: {
-          description: "agent builder action run event sent"
+          description: "agent builder action run cancelled"
         }
       }
     }),
-    sendAgentBuilderActionRunEventHandler
+    cancelAgentBuilderActionRunHandler
   );
   return router;
 }
@@ -2337,26 +2711,6 @@ async function generateSystemPromptHandler(c2) {
     if (!agent$1) {
       return c2.json({ error: "Agent not found" }, 404);
     }
-    let evalSummary = "";
-    try {
-      const testEvals = await mastra.getStorage()?.getEvalsByAgentName?.(agent$1.name, "test") || [];
-      const liveEvals = await mastra.getStorage()?.getEvalsByAgentName?.(agent$1.name, "live") || [];
-      const evalsMapped = [...testEvals, ...liveEvals].filter(
-        ({ instructions: evalInstructions }) => evalInstructions === instructions
-      );
-      evalSummary = evalsMapped.map(
-        ({ input, output, result: result2 }) => `
-          Input: ${input}
-
-          Output: ${output}
-
-          Result: ${JSON.stringify(result2)}
-
-        `
-      ).join("");
-    } catch (error) {
-      mastra.getLogger().error(`Error fetching evals`, { error });
-    }
     const ENHANCE_SYSTEM_PROMPT_INSTRUCTIONS = `
             You are an expert system prompt engineer, specialized in analyzing and enhancing instructions to create clear, effective, and comprehensive system prompts. Your goal is to help users transform their basic instructions into well-structured system prompts that will guide AI behavior effectively.
             Follow these steps to analyze and enhance the instructions:
@@ -2405,24 +2759,24 @@ async function generateSystemPromptHandler(c2) {
             Focus on creating prompts that are clear, actionable, and aligned with the intended use case.
         `;
     const systemPromptAgent = new agent.Agent({
+      id: "system-prompt-enhancer",
       name: "system-prompt-enhancer",
       instructions: ENHANCE_SYSTEM_PROMPT_INSTRUCTIONS,
-      model: agent$1.llm?.getModel()
+      model: await agent$1.getModel()
     });
     const result = await systemPromptAgent.generate(
       `
             We need to improve the system prompt. 
             Current: ${instructions}
             ${comment ? `User feedback: ${comment}` : ""}
-            ${evalSummary ? `
-Evaluation Results:
-${evalSummary}` : ""}
         `,
       {
-        output: zod.z.object({
-          new_prompt: zod.z.string(),
-          explanation: zod.z.string()
-        })
+        structuredOutput: {
+          schema: zod.z.object({
+            new_prompt: zod.z.string(),
+            explanation: zod.z.string()
+          })
+        }
       }
     );
     return c2.json(result?.object || {});
@@ -2430,10 +2784,10 @@ ${evalSummary}` : ""}
     return handleError(error, "Error generating system prompt");
   }
 }
-async function getToolsHandler(c2) {
+async function listToolsHandler(c2) {
   try {
     const tools = c2.get("tools");
-    const result = await tools$1.getToolsHandler({
+    const result = await tools$1.listToolsHandler({
       tools
     });
     return c2.json(result || {});
@@ -2458,7 +2812,7 @@ function executeToolHandler(tools) {
   return async (c2) => {
     try {
       const mastra = c2.get("mastra");
-      const runtimeContext = c2.get("runtimeContext");
+      const requestContext = c2.get("requestContext");
       const toolId = decodeURIComponent(c2.req.param("toolId"));
       const runId = c2.req.query("runId");
       const { data } = await c2.req.json();
@@ -2466,7 +2820,7 @@ function executeToolHandler(tools) {
         mastra,
         toolId,
         data,
-        runtimeContext,
+        requestContext,
         runId
       });
       return c2.json(result);
@@ -2478,14 +2832,14 @@ function executeToolHandler(tools) {
 async function getAgentToolHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const agentId = c2.req.param("agentId");
     const toolId = c2.req.param("toolId");
     const result = await tools$1.getAgentToolHandler({
       mastra,
       agentId,
       toolId,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -2495,7 +2849,7 @@ async function getAgentToolHandler(c2) {
 async function executeAgentToolHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const agentId = c2.req.param("agentId");
     const toolId = c2.req.param("toolId");
     const { data } = await c2.req.json();
@@ -2504,7 +2858,7 @@ async function executeAgentToolHandler(c2) {
       agentId,
       toolId,
       data,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -2575,10 +2929,10 @@ var vNextBodyOptions = {
   },
   ...sharedBodyOptions
 };
-async function getAgentsHandler(c2) {
-  const serializedAgents = await agents.getAgentsHandler({
+async function listAgentsHandler(c2) {
+  const serializedAgents = await agents.listAgentsHandler({
     mastra: c2.get("mastra"),
-    runtimeContext: c2.get("runtimeContext")
+    requestContext: c2.get("requestContext")
   });
   return c2.json(serializedAgents);
 }
@@ -2606,48 +2960,26 @@ async function getProvidersHandler(c2) {
 async function getAgentByIdHandler(c2) {
   const mastra = c2.get("mastra");
   const agentId = c2.req.param("agentId");
-  const runtimeContext = c2.get("runtimeContext");
+  const requestContext = c2.get("requestContext");
   const isPlayground = c2.req.header("x-mastra-dev-playground") === "true";
   const result = await agents.getAgentByIdHandler({
     mastra,
     agentId,
-    runtimeContext,
+    requestContext,
     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 generateLegacyHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const body = await c2.req.json();
     const result = await agents.generateLegacyHandler({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body,
       abortSignal: c2.req.raw.signal
     });
@@ -2660,12 +2992,12 @@ async function generateHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const body = await c2.req.json();
     const result = await agents.generateHandler({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body,
       abortSignal: c2.req.raw.signal
     });
@@ -2678,12 +3010,12 @@ async function streamGenerateLegacyHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const body = await c2.req.json();
     const streamResponse = await agents.streamGenerateLegacyHandler({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body,
       abortSignal: c2.req.raw.signal
     });
@@ -2695,7 +3027,7 @@ async function streamGenerateLegacyHandler(c2) {
 async function streamGenerateHandler(c2) {
   const mastra = c2.get("mastra");
   const agentId = c2.req.param("agentId");
-  const runtimeContext = c2.get("runtimeContext");
+  const requestContext = c2.get("requestContext");
   const body = await c2.req.json();
   const logger2 = mastra.getLogger();
   let streamResponse;
@@ -2703,7 +3035,7 @@ async function streamGenerateHandler(c2) {
     streamResponse = await agents.streamGenerateHandler({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body,
       abortSignal: c2.req.raw.signal
     });
@@ -2713,19 +3045,19 @@ async function streamGenerateHandler(c2) {
   c2.header("Transfer-Encoding", "chunked");
   return streaming.stream(
     c2,
-    async (stream6) => {
+    async (stream5) => {
       try {
         const reader = streamResponse.fullStream.getReader();
-        stream6.onAbort(() => {
+        stream5.onAbort(() => {
           void reader.cancel("request aborted");
         });
         let chunkResult;
         while ((chunkResult = await reader.read()) && !chunkResult.done) {
-          await stream6.write(`data: ${JSON.stringify(chunkResult.value)}
+          await stream5.write(`data: ${JSON.stringify(chunkResult.value)}
 
 `);
         }
-        await stream6.write("data: [DONE]\n\n");
+        await stream5.write("data: [DONE]\n\n");
       } catch (err) {
         logger2.error("Error in stream generate: " + (err?.message ?? "Unknown error"));
         const errorChunk = {
@@ -2736,11 +3068,11 @@ async function streamGenerateHandler(c2) {
             error: error.getErrorFromUnknown(err, { fallbackMessage: "Unknown error in stream generate" })
           }
         };
-        await stream6.write(`data: ${JSON.stringify(errorChunk)}
+        await stream5.write(`data: ${JSON.stringify(errorChunk)}
 
 `);
       }
-      await stream6.close();
+      await stream5.close();
     },
     async (err) => {
       logger2.error("Error in watch stream: " + err?.message);
@@ -2750,14 +3082,14 @@ async function streamGenerateHandler(c2) {
 async function approveToolCallHandler(c2) {
   const mastra = c2.get("mastra");
   const agentId = c2.req.param("agentId");
-  const runtimeContext = c2.get("runtimeContext");
+  const requestContext = c2.get("requestContext");
   const body = await c2.req.json();
   const logger2 = mastra.getLogger();
   let streamResponse;
   try {
     streamResponse = await agents.approveToolCallHandler({
       mastra,
-      runtimeContext,
+      requestContext,
       agentId,
       body,
       abortSignal: c2.req.raw.signal
@@ -2768,19 +3100,19 @@ async function approveToolCallHandler(c2) {
   c2.header("Transfer-Encoding", "chunked");
   return streaming.stream(
     c2,
-    async (stream6) => {
+    async (stream5) => {
       try {
         const reader = streamResponse.fullStream.getReader();
-        stream6.onAbort(() => {
+        stream5.onAbort(() => {
           void reader.cancel("request aborted");
         });
         let chunkResult;
         while ((chunkResult = await reader.read()) && !chunkResult.done) {
-          await stream6.write(`data: ${JSON.stringify(chunkResult.value)}
+          await stream5.write(`data: ${JSON.stringify(chunkResult.value)}
 
 `);
         }
-        await stream6.write("data: [DONE]\n\n");
+        await stream5.write("data: [DONE]\n\n");
       } catch (err) {
         logger2.error("Error in approve tool call: " + (err?.message ?? "Unknown error"));
         const errorChunk = {
@@ -2795,11 +3127,11 @@ async function approveToolCallHandler(c2) {
             } : String(err)
           }
         };
-        await stream6.write(`data: ${JSON.stringify(errorChunk)}
+        await stream5.write(`data: ${JSON.stringify(errorChunk)}
 
 `);
       }
-      await stream6.close();
+      await stream5.close();
     },
     async (err) => {
       logger2.error("Error in watch stream: " + err?.message);
@@ -2809,14 +3141,14 @@ async function approveToolCallHandler(c2) {
 async function declineToolCallHandler(c2) {
   const mastra = c2.get("mastra");
   const agentId = c2.req.param("agentId");
-  const runtimeContext = c2.get("runtimeContext");
+  const requestContext = c2.get("requestContext");
   const body = await c2.req.json();
   const logger2 = mastra.getLogger();
   let streamResponse;
   try {
     streamResponse = await agents.declineToolCallHandler({
       mastra,
-      runtimeContext,
+      requestContext,
       agentId,
       body,
       abortSignal: c2.req.raw.signal
@@ -2827,19 +3159,19 @@ async function declineToolCallHandler(c2) {
   c2.header("Transfer-Encoding", "chunked");
   return streaming.stream(
     c2,
-    async (stream6) => {
+    async (stream5) => {
       try {
         const reader = streamResponse.fullStream.getReader();
-        stream6.onAbort(() => {
+        stream5.onAbort(() => {
           void reader.cancel("request aborted");
         });
         let chunkResult;
         while ((chunkResult = await reader.read()) && !chunkResult.done) {
-          await stream6.write(`data: ${JSON.stringify(chunkResult.value)}
+          await stream5.write(`data: ${JSON.stringify(chunkResult.value)}
 
 `);
         }
-        await stream6.write("data: [DONE]\n\n");
+        await stream5.write("data: [DONE]\n\n");
       } catch (err) {
         logger2.error("Error in decline tool call: " + (err?.message ?? "Unknown error"));
         const errorChunk = {
@@ -2854,11 +3186,11 @@ async function declineToolCallHandler(c2) {
             } : String(err)
           }
         };
-        await stream6.write(`data: ${JSON.stringify(errorChunk)}
+        await stream5.write(`data: ${JSON.stringify(errorChunk)}
 
 `);
       }
-      await stream6.close();
+      await stream5.close();
     },
     async (err) => {
       logger2.error("Error in watch stream: " + err?.message);
@@ -2868,11 +3200,11 @@ async function declineToolCallHandler(c2) {
 async function streamNetworkHandler(c2) {
   const mastra = c2.get("mastra");
   const agentId = c2.req.param("agentId");
-  const runtimeContext = c2.get("runtimeContext");
+  const requestContext = c2.get("requestContext");
   const body = await c2.req.json();
   const logger2 = mastra.getLogger();
   const agent = await agents.getAgentFromSystem({ mastra, agentId });
-  const memory = await agent.getMemory({ runtimeContext });
+  const memory = await agent.getMemory({ requestContext });
   if (!memory) {
     return handleError(
       new error.MastraError({
@@ -2892,7 +3224,7 @@ async function streamNetworkHandler(c2) {
     streamResponse = await agents.streamNetworkHandler({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body
       // abortSignal: c.req.raw.signal,
     });
@@ -2902,19 +3234,19 @@ async function streamNetworkHandler(c2) {
   c2.header("Transfer-Encoding", "chunked");
   return streaming.stream(
     c2,
-    async (stream6) => {
+    async (stream5) => {
       try {
         const reader = streamResponse.getReader();
-        stream6.onAbort(() => {
+        stream5.onAbort(() => {
           void reader.cancel("request aborted");
         });
         let chunkResult;
         while ((chunkResult = await reader.read()) && !chunkResult.done) {
-          await stream6.write(`data: ${JSON.stringify(chunkResult.value)}
+          await stream5.write(`data: ${JSON.stringify(chunkResult.value)}
 
 `);
         }
-        await stream6.write("data: [DONE]\n\n");
+        await stream5.write("data: [DONE]\n\n");
       } catch (err) {
         logger2.error("Error in streamNetwork generate: " + (err?.message ?? "Unknown error"));
         const errorChunk = {
@@ -2929,11 +3261,11 @@ async function streamNetworkHandler(c2) {
             } : String(err)
           }
         };
-        await stream6.write(`data: ${JSON.stringify(errorChunk)}
+        await stream5.write(`data: ${JSON.stringify(errorChunk)}
 
 `);
       }
-      await stream6.close();
+      await stream5.close();
     },
     async (err) => {
       logger2.error("Error in watch stream: " + err?.message);
@@ -2944,12 +3276,12 @@ async function streamUIMessageHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const body = await c2.req.json();
     const streamResponse = await agents.streamUIMessageHandler({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body,
       abortSignal: c2.req.raw.signal
     });
@@ -3058,11 +3390,11 @@ async function getSpeakersHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const speakers = await voice.getSpeakersHandler({
       mastra,
       agentId,
-      runtimeContext
+      requestContext
     });
     return c2.json(speakers);
   } catch (error) {
@@ -3073,12 +3405,12 @@ async function speakHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const { input, options } = await c2.req.json();
     const audioStream = await voice.generateSpeechHandler({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body: { text: input, speakerId: options?.speakerId }
     });
     c2.header("Content-Type", `audio/${options?.filetype ?? "mp3"}`);
@@ -3092,11 +3424,11 @@ async function getListenerHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const listeners = await voice.getListenerHandler({
       mastra,
       agentId,
-      runtimeContext
+      requestContext
     });
     return c2.json(listeners);
   } catch (error) {
@@ -3107,7 +3439,7 @@ async function listenHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.param("agentId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const formData = await c2.req.formData();
     const audioFile = formData.get("audio");
     const options = formData.get("options");
@@ -3123,7 +3455,7 @@ async function listenHandler(c2) {
     const transcription = await voice.transcribeSpeechHandler({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body: {
         audioData: Buffer.from(audioData),
         options: parsedOptions
@@ -3149,7 +3481,7 @@ function agentsRouter(bodyLimitOptions) {
         }
       }
     }),
-    getAgentsHandler
+    listAgentsHandler
   );
   router.get(
     "/providers",
@@ -3188,48 +3520,6 @@ function agentsRouter(bodyLimitOptions) {
     }),
     getAgentByIdHandler
   );
-  router.get(
-    "/:agentId/evals/ci",
-    w({
-      description: "Get CI evals by agent ID",
-      tags: ["agents"],
-      parameters: [
-        {
-          name: "agentId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      responses: {
-        200: {
-          description: "List of evals"
-        }
-      }
-    }),
-    getEvalsByAgentIdHandler
-  );
-  router.get(
-    "/:agentId/evals/live",
-    w({
-      description: "Get live evals by agent ID",
-      tags: ["agents"],
-      parameters: [
-        {
-          name: "agentId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      responses: {
-        200: {
-          description: "List of evals"
-        }
-      }
-    }),
-    getLiveEvalsByAgentIdHandler
-  );
   router.post(
     "/:agentId/generate-legacy",
     bodyLimit.bodyLimit(bodyLimitOptions),
@@ -3719,7 +4009,7 @@ function agentsRouter(bodyLimitOptions) {
     "/:agentId/stream/vnext/ui",
     bodyLimit.bodyLimit(bodyLimitOptions),
     w({
-      description: "[DEPRECATED] This endpoint is deprecated. Please use /stream/ui instead.",
+      description: "[DEPRECATED] This endpoint is deprecated. Please use the @mastra/ai-sdk package to for uiMessage transformations",
       tags: ["agents"],
       deprecated: true,
       parameters: [
@@ -3757,8 +4047,9 @@ function agentsRouter(bodyLimitOptions) {
     "/:agentId/stream/ui",
     bodyLimit.bodyLimit(bodyLimitOptions),
     w({
-      description: "Stream a response from an agent",
+      description: "[DEPRECATED] This endpoint is deprecated. Please use the @mastra/ai-sdk package to for uiMessage transformations",
       tags: ["agents"],
+      deprecated: true,
       parameters: [
         {
           name: "agentId",
@@ -4440,7 +4731,7 @@ function agentsRouter(bodyLimitOptions) {
               type: "object",
               properties: {
                 data: { type: "object" },
-                runtimeContext: { type: "object" }
+                requestContext: { type: "object" }
               },
               required: ["data"]
             }
@@ -4481,7 +4772,7 @@ function agentsRouter(bodyLimitOptions) {
               properties: {
                 runId: { type: "string", description: "The run ID for the execution" },
                 toolCallId: { type: "string", description: "The tool call ID for the execution" },
-                runtimeContext: { type: "object", description: "Runtime context for the execution" },
+                requestContext: { type: "object", description: "Request Context for the execution" },
                 format: { type: "string", enum: ["aisdk", "mastra"], description: "Output format" }
               },
               required: ["runId", "toolCallId"]
@@ -4523,7 +4814,7 @@ function agentsRouter(bodyLimitOptions) {
               properties: {
                 runId: { type: "string", description: "The run ID for the execution" },
                 toolCallId: { type: "string", description: "The tool call ID for the execution" },
-                runtimeContext: { type: "object", description: "Runtime context for the execution" },
+                requestContext: { type: "object", description: "Request Context for the execution" },
                 format: { type: "string", enum: ["aisdk", "mastra"], description: "Output format" }
               },
               required: ["runId", "toolCallId"]
@@ -4663,12 +4954,12 @@ function agentsRouterDev(bodyLimitOptions) {
   );
   return router;
 }
-async function getLogsHandler(c2) {
+async function listLogsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const { transportId, fromDate, toDate, logLevel, page, perPage } = c2.req.query();
     const filters = c2.req.queries("filters");
-    const logs$1 = await logs.getLogsHandler({
+    const logs$1 = await logs.listLogsHandler({
       mastra,
       transportId,
       params: {
@@ -4685,13 +4976,13 @@ async function getLogsHandler(c2) {
     return handleError(error, "Error getting logs");
   }
 }
-async function getLogsByRunIdHandler(c2) {
+async function listLogsByRunIdHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const runId = c2.req.param("runId");
     const { transportId, fromDate, toDate, logLevel, page, perPage } = c2.req.query();
     const filters = c2.req.queries("filters");
-    const logs$1 = await logs.getLogsByRunIdHandler({
+    const logs$1 = await logs.listLogsByRunIdHandler({
       mastra,
       runId,
       transportId,
@@ -4709,10 +5000,10 @@ async function getLogsByRunIdHandler(c2) {
     return handleError(error, "Error getting logs by run ID");
   }
 }
-async function getLogTransports(c2) {
+async function listLogTransports(c2) {
   try {
     const mastra = c2.get("mastra");
-    const result = await logs.getLogTransports({
+    const result = await logs.listLogTransports({
       mastra
     });
     return c2.json(result);
@@ -4779,7 +5070,7 @@ function logsRouter() {
         }
       }
     }),
-    getLogsHandler
+    listLogsHandler
   );
   router.get(
     "/transports",
@@ -4792,7 +5083,7 @@ function logsRouter() {
         }
       }
     }),
-    getLogTransports
+    listLogTransports
   );
   router.get(
     "/:runId",
@@ -4855,7 +5146,7 @@ function logsRouter() {
         }
       }
     }),
-    getLogsByRunIdHandler
+    listLogsByRunIdHandler
   );
   return router;
 }
@@ -6722,11 +7013,11 @@ var getMcpServerMessageHandler = async (c2) => {
   const mastra = getMastra(c2);
   const serverId = c2.req.param("serverId");
   const { req, res } = toReqRes(c2.req.raw);
-  const server = mastra.getMCPServer(serverId);
+  const server = mastra.getMCPServerById(serverId);
   if (!server) {
     res.writeHead(404, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ error: `MCP server '${serverId}' not found` }));
-    return;
+    return await toFetchResponse(res);
   }
   try {
     await server.startHTTP({
@@ -6750,15 +7041,17 @@ var getMcpServerMessageHandler = async (c2) => {
           // Cannot determine original request ID in catch
         })
       );
+      return await toFetchResponse(res);
     } else {
       c2.get("logger")?.error("Error after headers sent:", error);
+      return await toFetchResponse(res);
     }
   }
 };
 var getMcpServerSseHandler = async (c2) => {
   const mastra = getMastra(c2);
   const serverId = c2.req.param("serverId");
-  const server = mastra.getMCPServer(serverId);
+  const server = mastra.getMCPServerById(serverId);
   if (!server) {
     return c2.json({ error: `MCP server '${serverId}' not found` }, 404);
   }
@@ -6779,13 +7072,13 @@ var getMcpServerSseHandler = async (c2) => {
 };
 var listMcpRegistryServersHandler = async (c2) => {
   const mastra = getMastra(c2);
-  if (!mastra || typeof mastra.getMCPServers !== "function") {
-    c2.get("logger")?.error("Mastra instance or getMCPServers method not available in listMcpRegistryServersHandler");
-    return c2.json({ error: "Mastra instance or getMCPServers method not available" }, 500);
+  if (!mastra || typeof mastra.listMCPServers !== "function") {
+    c2.get("logger")?.error("Mastra instance or listMCPServers method not available in listMcpRegistryServersHandler");
+    return c2.json({ error: "Mastra instance or listMCPServers method not available" }, 500);
   }
-  const mcpServersMap = mastra.getMCPServers();
+  const mcpServersMap = mastra.listMCPServers();
   if (!mcpServersMap) {
-    c2.get("logger")?.warn("getMCPServers returned undefined or null in listMcpRegistryServersHandler");
+    c2.get("logger")?.warn("listMCPServers returned undefined or null in listMcpRegistryServersHandler");
     return c2.json({ servers: [], next: null, total_count: 0 });
   }
   const allServersArray = Array.from(
@@ -6814,11 +7107,13 @@ var getMcpRegistryServerDetailHandler = async (c2) => {
   const mastra = getMastra(c2);
   const serverId = c2.req.param("id");
   const requestedVersion = c2.req.query("version");
-  if (!mastra || typeof mastra.getMCPServer !== "function") {
-    c2.get("logger")?.error("Mastra instance or getMCPServer method not available in getMcpRegistryServerDetailHandler");
-    return c2.json({ error: "Mastra instance or getMCPServer method not available" }, 500);
+  if (!mastra || typeof mastra.getMCPServerById !== "function") {
+    c2.get("logger")?.error(
+      "Mastra instance or getMCPServerById method not available in getMcpRegistryServerDetailHandler"
+    );
+    return c2.json({ error: "Mastra instance or getMCPServerById method not available" }, 500);
   }
-  const server = mastra.getMCPServer(serverId);
+  const server = mastra.getMCPServerById(serverId);
   if (!server) {
     return c2.json({ error: `MCP server with ID '${serverId}' not found` }, 404);
   }
@@ -6840,11 +7135,11 @@ var getMcpRegistryServerDetailHandler = async (c2) => {
 var listMcpServerToolsHandler = async (c2) => {
   const mastra = getMastra(c2);
   const serverId = c2.req.param("serverId");
-  if (!mastra || typeof mastra.getMCPServer !== "function") {
-    c2.get("logger")?.error("Mastra instance or getMCPServer method not available in listMcpServerToolsHandler");
-    return c2.json({ error: "Mastra instance or getMCPServer method not available" }, 500);
+  if (!mastra || typeof mastra.getMCPServerById !== "function") {
+    c2.get("logger")?.error("Mastra instance or getMCPServerById method not available in listMcpServerToolsHandler");
+    return c2.json({ error: "Mastra instance or getMCPServerById method not available" }, 500);
   }
-  const server = mastra.getMCPServer(serverId);
+  const server = mastra.getMCPServerById(serverId);
   if (!server) {
     return c2.json({ error: `MCP server with ID '${serverId}' not found` }, 404);
   }
@@ -6864,11 +7159,11 @@ var getMcpServerToolDetailHandler = async (c2) => {
   const mastra = getMastra(c2);
   const serverId = c2.req.param("serverId");
   const toolId = c2.req.param("toolId");
-  if (!mastra || typeof mastra.getMCPServer !== "function") {
-    c2.get("logger")?.error("Mastra instance or getMCPServer method not available in getMcpServerToolDetailHandler");
-    return c2.json({ error: "Mastra instance or getMCPServer method not available" }, 500);
+  if (!mastra || typeof mastra.getMCPServerById !== "function") {
+    c2.get("logger")?.error("Mastra instance or getMCPServerById method not available in getMcpServerToolDetailHandler");
+    return c2.json({ error: "Mastra instance or getMCPServerById method not available" }, 500);
   }
-  const server = mastra.getMCPServer(serverId);
+  const server = mastra.getMCPServerById(serverId);
   if (!server) {
     return c2.json({ error: `MCP server with ID '${serverId}' not found` }, 404);
   }
@@ -6893,11 +7188,11 @@ var executeMcpServerToolHandler = async (c2) => {
   const mastra = getMastra(c2);
   const serverId = c2.req.param("serverId");
   const toolId = c2.req.param("toolId");
-  if (!mastra || typeof mastra.getMCPServer !== "function") {
-    c2.get("logger")?.error("Mastra instance or getMCPServer method not available in executeMcpServerToolHandler");
-    return c2.json({ error: "Mastra instance or getMCPServer method not available" }, 500);
+  if (!mastra || typeof mastra.getMCPServerById !== "function") {
+    c2.get("logger")?.error("Mastra instance or getMCPServerById method not available in executeMcpServerToolHandler");
+    return c2.json({ error: "Mastra instance or getMCPServerById method not available" }, 500);
   }
-  const server = mastra.getMCPServer(serverId);
+  const server = mastra.getMCPServerById(serverId);
   if (!server) {
     return c2.json({ error: `MCP server with ID '${serverId}' not found` }, 404);
   }
@@ -6908,8 +7203,8 @@ var executeMcpServerToolHandler = async (c2) => {
   try {
     const body = await c2.req.json();
     const args = body?.data;
-    const runtimeContext = body?.runtimeContext;
-    const result = await server.executeTool(toolId, args, runtimeContext);
+    const requestContext = body?.requestContext;
+    const result = await server.executeTool(toolId, args, requestContext);
     return c2.json({ result });
   } catch (error) {
     c2.get("logger")?.error(`Error executing tool '${toolId}' on server '${serverId}':`, { error: error.message });
@@ -7311,7 +7606,7 @@ function mcpRouter(bodyLimitOptions) {
               type: "object",
               properties: {
                 data: { type: "object" },
-                runtimeContext: { type: "object" }
+                requestContext: { type: "object" }
               }
             }
           }
@@ -7341,17 +7636,38 @@ function parseLimit(rawLimit) {
   }
   return void 0;
 }
+function parsePage(value, defaultValue = 0) {
+  const parsed = parseInt(value || String(defaultValue), 10);
+  return isNaN(parsed) ? defaultValue : Math.max(0, parsed);
+}
+function parsePerPage(value, defaultValue = 100, max = 1e3) {
+  const normalized = (value || "").trim().toLowerCase();
+  if (normalized === "false") {
+    return false;
+  }
+  const parsed = parseInt(value || String(defaultValue), 10);
+  if (isNaN(parsed)) return defaultValue;
+  return Math.min(max, Math.max(1, parsed));
+}
 
 // src/server/handlers/routes/memory/handlers.ts
+function parseJsonParam(value) {
+  if (!value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
 async function getMemoryStatusHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const result = await memory.getMemoryStatusHandler({
       mastra,
       agentId,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7362,61 +7678,51 @@ async function getMemoryConfigHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const result = await memory.getMemoryConfigHandler({
       mastra,
       agentId,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
     return handleError(error, "Error getting memory configuration");
   }
 }
-async function getThreadsHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const agentId = c2.req.query("agentId");
-    const resourceId = c2.req.query("resourceid");
-    const orderBy = c2.req.query("orderBy");
-    const sortDirection = c2.req.query("sortDirection");
-    const runtimeContext = c2.get("runtimeContext");
-    const result = await memory.getThreadsHandler({
-      mastra,
-      agentId,
-      resourceId,
-      orderBy,
-      sortDirection,
-      runtimeContext
-    });
-    return c2.json(result);
-  } catch (error) {
-    return handleError(error, "Error getting threads");
-  }
-}
-async function getThreadsPaginatedHandler(c2) {
+async function listThreadsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
     const resourceId = c2.req.query("resourceId");
-    const page = parseInt(c2.req.query("page") || "0", 10);
-    const perPage = parseInt(c2.req.query("perPage") || "100", 10);
-    const orderBy = c2.req.query("orderBy");
-    const sortDirection = c2.req.query("sortDirection");
-    const runtimeContext = c2.get("runtimeContext");
-    const result = await memory.getThreadsPaginatedHandler({
+    const page = parsePage(c2.req.query("page"));
+    const perPage = parsePerPage(c2.req.query("perPage"));
+    const field = c2.req.query("orderBy");
+    const direction = c2.req.query("sortDirection");
+    const requestContext = c2.get("requestContext");
+    const validFields = ["createdAt", "updatedAt"];
+    const validDirections = ["ASC", "DESC"];
+    if (field && !validFields.includes(field)) {
+      return c2.json({ error: `Invalid orderBy field: ${field}. Must be one of: ${validFields.join(", ")}` }, 400);
+    }
+    if (direction && !validDirections.includes(direction)) {
+      return c2.json(
+        { error: `Invalid sortDirection: ${direction}. Must be one of: ${validDirections.join(", ")}` },
+        400
+      );
+    }
+    const orderBy = field || direction ? { field: field || "createdAt", direction: direction || "DESC" } : void 0;
+    const result = await memory.listThreadsHandler({
       mastra,
       agentId,
       resourceId,
       page,
       perPage,
       orderBy,
-      sortDirection,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
-    return handleError(error, "Error getting paginated threads");
+    return handleError(error, "Error listing threads");
   }
 }
 async function getThreadByIdHandler(c2) {
@@ -7424,12 +7730,12 @@ async function getThreadByIdHandler(c2) {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const result = await memory.getThreadByIdHandler({
       mastra,
       agentId,
       threadId,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7441,12 +7747,12 @@ async function saveMessagesHandler(c2) {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
     const body = await c2.req.json();
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const result = await memory.saveMessagesHandler({
       mastra,
       agentId,
       body,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7458,12 +7764,12 @@ async function createThreadHandler(c2) {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
     const body = await c2.req.json();
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const result = await memory.createThreadHandler({
       mastra,
       agentId,
       body,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7476,13 +7782,13 @@ async function updateThreadHandler(c2) {
     const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
     const body = await c2.req.json();
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const result = await memory.updateThreadHandler({
       mastra,
       agentId,
       threadId,
       body,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7494,57 +7800,41 @@ async function deleteThreadHandler(c2) {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const result = await memory.deleteThreadHandler({
       mastra,
       agentId,
       threadId,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
     return handleError(error, "Error deleting thread");
   }
 }
-async function getMessagesHandler(c2) {
+async function listMessagesHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
-    const limit = parseLimit(c2.req.query("limit"));
-    const runtimeContext = c2.get("runtimeContext");
-    const result = await memory.getMessagesHandler({
-      mastra,
-      agentId,
-      threadId,
-      limit,
-      runtimeContext
-    });
-    return c2.json(result);
-  } catch (error) {
-    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({
+    const page = parsePage(c2.req.query("page"));
+    const perPage = parsePerPage(c2.req.query("perPage"));
+    const orderBy = parseJsonParam(c2.req.query("orderBy"));
+    const include = parseJsonParam(c2.req.query("include"));
+    const filter = parseJsonParam(c2.req.query("filter"));
+    const requestContext = c2.get("requestContext");
+    const result = await memory.listMessagesHandler({
       mastra,
+      agentId,
       threadId,
       resourceId,
-      format,
-      selectBy
+      page,
+      perPage,
+      orderBy,
+      include,
+      filter,
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7557,13 +7847,13 @@ async function updateWorkingMemoryHandler(c2) {
     const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
     const body = await c2.req.json();
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const result = await memory.updateWorkingMemoryHandler({
       mastra,
       agentId,
       threadId,
       body,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7576,13 +7866,13 @@ async function getWorkingMemoryHandler(c2) {
     const agentId = c2.req.query("agentId");
     const threadId = c2.req.param("threadId");
     const resourceId = c2.req.query("resourceId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const result = await memory.getWorkingMemoryHandler({
       mastra,
       agentId,
       threadId,
       resourceId,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7598,7 +7888,7 @@ async function searchMemoryHandler(c2) {
     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 runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const result = await memory.searchMemoryHandler({
       mastra,
       agentId,
@@ -7607,7 +7897,7 @@ async function searchMemoryHandler(c2) {
       threadId,
       limit,
       memoryConfig,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7618,14 +7908,14 @@ async function deleteMessagesHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const agentId = c2.req.query("agentId");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const body = await c2.req.json();
     const messageIds = body?.messageIds;
     const result = await memory.deleteMessagesHandler({
       mastra,
       agentId,
       messageIds,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7675,6 +7965,20 @@ function memoryRoutes(bodyLimitOptions) {
           required: true,
           schema: { type: "string" }
         },
+        {
+          name: "offset",
+          in: "query",
+          required: false,
+          schema: { type: "number", default: 0 },
+          description: "Number of records to skip"
+        },
+        {
+          name: "limit",
+          in: "query",
+          required: false,
+          schema: { type: "number", default: 100 },
+          description: "Maximum number of threads to return"
+        },
         {
           name: "orderBy",
           in: "query",
@@ -7704,7 +8008,7 @@ function memoryRoutes(bodyLimitOptions) {
         }
       }
     }),
-    getThreadsHandler
+    listThreadsHandler
   );
   router.get(
     "/network/threads/:threadId",
@@ -7739,14 +8043,17 @@ function memoryRoutes(bodyLimitOptions) {
   router.get(
     "/network/threads/:threadId/messages",
     w({
-      description: "Get messages for a thread",
+      description: "Get paginated messages for a thread",
       tags: ["networkMemory"],
       parameters: [
         {
           name: "threadId",
           in: "path",
           required: true,
-          schema: { type: "string" }
+          description: "The unique identifier of the thread",
+          schema: {
+            type: "string"
+          }
         },
         {
           name: "networkId",
@@ -7755,20 +8062,85 @@ function memoryRoutes(bodyLimitOptions) {
           schema: { type: "string" }
         },
         {
-          name: "limit",
+          name: "agentId",
+          in: "query",
+          required: true,
+          description: "The unique identifier of the agent",
+          schema: {
+            type: "string"
+          }
+        },
+        {
+          name: "resourceId",
           in: "query",
           required: false,
-          schema: { type: "number" },
-          description: "Limit the number of messages to retrieve (default: 40)"
+          description: "Filter messages by resource ID",
+          schema: {
+            type: "string"
+          }
+        },
+        {
+          name: "page",
+          in: "query",
+          required: false,
+          description: "Zero-indexed page number for pagination (default: 0)",
+          schema: {
+            type: "integer",
+            minimum: 0,
+            default: 0
+          }
+        },
+        {
+          name: "perPage",
+          in: "query",
+          required: false,
+          description: 'Number of items per page, or "false" to fetch all records (default: 40)',
+          schema: {
+            oneOf: [
+              { type: "integer", minimum: 0 },
+              { type: "boolean", enum: [false] }
+            ],
+            default: 40
+          }
+        },
+        {
+          name: "orderBy",
+          in: "query",
+          required: false,
+          description: "JSON string specifying sort order",
+          schema: {
+            type: "string",
+            example: '{"field":"createdAt","direction":"DESC"}'
+          }
+        },
+        {
+          name: "include",
+          in: "query",
+          required: false,
+          description: "JSON string specifying messages to include with context",
+          schema: {
+            type: "string",
+            example: '[{"id":"msg-123","withPreviousMessages":5,"withNextMessages":3}]'
+          }
+        },
+        {
+          name: "filter",
+          in: "query",
+          required: false,
+          description: "JSON string specifying filter criteria",
+          schema: {
+            type: "string",
+            example: '{"dateRange":{"start":"2024-01-01T00:00:00Z","end":"2024-12-31T23:59:59Z"}}'
+          }
         }
       ],
       responses: {
         200: {
-          description: "List of messages"
+          description: "Paginated list of messages with metadata"
         }
       }
     }),
-    getMessagesHandler
+    listMessagesHandler
   );
   router.post(
     "/network/threads",
@@ -8134,55 +8506,6 @@ function memoryRoutes(bodyLimitOptions) {
   );
   router.get(
     "/threads",
-    w({
-      description: "Get all threads",
-      tags: ["memory"],
-      parameters: [
-        {
-          name: "resourceid",
-          in: "query",
-          required: true,
-          schema: { type: "string" }
-        },
-        {
-          name: "agentId",
-          in: "query",
-          required: true,
-          schema: { type: "string" }
-        },
-        {
-          name: "orderBy",
-          in: "query",
-          required: false,
-          schema: {
-            type: "string",
-            enum: ["createdAt", "updatedAt"],
-            default: "createdAt"
-          },
-          description: "Field to sort by"
-        },
-        {
-          name: "sortDirection",
-          in: "query",
-          required: false,
-          schema: {
-            type: "string",
-            enum: ["ASC", "DESC"],
-            default: "DESC"
-          },
-          description: "Sort direction"
-        }
-      ],
-      responses: {
-        200: {
-          description: "List of all threads"
-        }
-      }
-    }),
-    getThreadsHandler
-  );
-  router.get(
-    "/threads/paginated",
     w({
       description: "Get paginated threads",
       tags: ["memory"],
@@ -8200,18 +8523,18 @@ function memoryRoutes(bodyLimitOptions) {
           schema: { type: "string" }
         },
         {
-          name: "page",
+          name: "offset",
           in: "query",
           required: false,
           schema: { type: "number", default: 0 },
-          description: "Page number"
+          description: "Number of records to skip"
         },
         {
-          name: "perPage",
+          name: "limit",
           in: "query",
           required: false,
           schema: { type: "number", default: 100 },
-          description: "Number of threads per page"
+          description: "Maximum number of threads to return"
         },
         {
           name: "orderBy",
@@ -8240,7 +8563,7 @@ function memoryRoutes(bodyLimitOptions) {
         }
       }
     }),
-    getThreadsPaginatedHandler
+    listThreadsHandler
   );
   router.get(
     "/threads/:threadId",
@@ -8274,58 +8597,24 @@ 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",
+      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",
           in: "query",
           required: true,
-          schema: { type: "string" }
-        },
-        {
-          name: "limit",
-          in: "query",
-          required: false,
-          schema: { type: "number" },
-          description: "Limit the number of messages to retrieve (default: 40)"
-        }
-      ],
-      responses: {
-        200: {
-          description: "List of messages"
-        }
-      }
-    }),
-    getMessagesHandler
-  );
-  router.get(
-    "/threads/:threadId/messages/paginated",
-    w({
-      description: "Get paginated messages for a thread",
-      tags: ["memory"],
-      parameters: [
-        {
-          name: "threadId",
-          in: "path",
-          required: true,
-          description: "The unique identifier of the thread",
+          description: "The unique identifier of the agent",
           schema: {
             type: "string"
           }
@@ -8340,34 +8629,67 @@ function memoryRoutes(bodyLimitOptions) {
           }
         },
         {
-          name: "format",
+          name: "page",
           in: "query",
           required: false,
-          description: "Message format to return",
+          description: "Zero-indexed page number for pagination (default: 0)",
           schema: {
-            type: "string",
-            enum: ["v1", "v2"],
-            default: "v1"
+            type: "integer",
+            minimum: 0,
+            default: 0
           }
         },
         {
-          name: "selectBy",
+          name: "perPage",
           in: "query",
           required: false,
-          description: "JSON string containing selection criteria for messages",
+          description: 'Number of items per page, or "false" to fetch all records (default: 40)',
+          schema: {
+            oneOf: [
+              { type: "integer", minimum: 0 },
+              { type: "boolean", enum: [false] }
+            ],
+            default: 40
+          }
+        },
+        {
+          name: "orderBy",
+          in: "query",
+          required: false,
+          description: "JSON string specifying sort order",
+          schema: {
+            type: "string",
+            example: '{"field":"createdAt","direction":"DESC"}'
+          }
+        },
+        {
+          name: "include",
+          in: "query",
+          required: false,
+          description: "JSON string specifying messages to include with context",
+          schema: {
+            type: "string",
+            example: '[{"id":"msg-123","withPreviousMessages":5,"withNextMessages":3}]'
+          }
+        },
+        {
+          name: "filter",
+          in: "query",
+          required: false,
+          description: "JSON string specifying filter criteria",
           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}]}'
+            example: '{"dateRange":{"start":"2024-01-01T00:00:00Z","end":"2024-12-31T23:59:59Z"}}'
           }
         }
       ],
       responses: {
         200: {
-          description: "List of messages"
+          description: "Paginated list of messages with metadata"
         }
       }
     }),
-    getMessagesPaginatedHandler
+    listMessagesHandler
   );
   router.get(
     "/search",
@@ -8805,23 +9127,23 @@ function memoryRoutes(bodyLimitOptions) {
   );
   return router;
 }
-async function getAITraceHandler(c2) {
+async function getTraceHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const traceId = c2.req.param("traceId");
     if (!traceId) {
       return c2.json({ error: "Trace ID is required" }, 400);
     }
-    const trace = await observability.getAITraceHandler({
+    const trace = await observability$1.getTraceHandler({
       mastra,
       traceId
     });
     return c2.json(trace);
   } catch (error) {
-    return handleError(error, "Error getting AI trace");
+    return handleError(error, "Error getting trace");
   }
 }
-async function getAITracesPaginatedHandler(c2) {
+async function getTracesPaginatedHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const { page, perPage, name, spanType, dateRange, entityId, entityType } = c2.req.query();
@@ -8832,7 +9154,7 @@ async function getAITracesPaginatedHandler(c2) {
     const filters = {};
     if (name) filters.name = name;
     if (spanType) {
-      if (Object.values(aiTracing.AISpanType).includes(spanType)) {
+      if (Object.values(observability.SpanType).includes(spanType)) {
         filters.spanType = spanType;
       } else {
         return c2.json({ error: "Invalid spanType" }, 400);
@@ -8856,7 +9178,7 @@ async function getAITracesPaginatedHandler(c2) {
     if (start || end) {
       pagination.dateRange = { start, end };
     }
-    const result = await observability.getAITracesPaginatedHandler({
+    const result = await observability$1.getTracesPaginatedHandler({
       mastra,
       body: {
         pagination,
@@ -8865,14 +9187,14 @@ async function getAITracesPaginatedHandler(c2) {
     });
     return c2.json(result);
   } catch (error) {
-    return handleError(error, "Error getting AI traces paginated");
+    return handleError(error, "Error getting traces paginated");
   }
 }
 async function processTraceScoringHandler(c2) {
   try {
     const mastra = c2.get("mastra");
     const { scorerName, targets } = await c2.req.json();
-    const result = await observability.scoreTracesHandler({
+    const result = await observability$1.scoreTracesHandler({
       mastra,
       body: { scorerName, targets }
     });
@@ -8881,7 +9203,7 @@ async function processTraceScoringHandler(c2) {
     return handleError(error, "Error processing trace scoring");
   }
 }
-async function getScoresBySpan(c2) {
+async function listScoresBySpan(c2) {
   const mastra = c2.get("mastra");
   const traceId = c2.req.param("traceId");
   const spanId = c2.req.param("spanId");
@@ -8889,7 +9211,7 @@ async function getScoresBySpan(c2) {
   const perPage = parseInt(c2.req.query("perPage") || "10");
   const pagination = { page, perPage };
   try {
-    const scores = await observability.getScoresBySpan({
+    const scores = await observability$1.listScoresBySpan({
       mastra,
       traceId,
       spanId,
@@ -8907,7 +9229,7 @@ function observabilityRouter() {
   router.get(
     "/traces",
     w({
-      description: "Get paginated list of AI traces",
+      description: "Get paginated list of traces",
       tags: ["observability"],
       parameters: [
         {
@@ -8955,19 +9277,19 @@ function observabilityRouter() {
       ],
       responses: {
         200: {
-          description: "Paginated list of AI traces"
+          description: "Paginated list of traces"
         },
         400: {
           description: "Bad request - invalid parameters"
         }
       }
     }),
-    getAITracesPaginatedHandler
+    getTracesPaginatedHandler
   );
   router.get(
     "/traces/:traceId",
     w({
-      description: "Get a specific AI trace by ID",
+      description: "Get a specific trace by ID",
       tags: ["observability"],
       parameters: [
         {
@@ -8980,7 +9302,7 @@ function observabilityRouter() {
       ],
       responses: {
         200: {
-          description: "AI trace with all its spans"
+          description: "Trace with all its spans"
         },
         400: {
           description: "Bad request - missing trace ID"
@@ -8990,7 +9312,7 @@ function observabilityRouter() {
         }
       }
     }),
-    getAITraceHandler
+    getTraceHandler
   );
   router.get(
     "/traces/:traceId/:spanId/scores",
@@ -9033,7 +9355,7 @@ function observabilityRouter() {
         }
       }
     }),
-    getScoresBySpan
+    listScoresBySpan
   );
   router.post(
     "/traces/score",
@@ -9156,36 +9478,36 @@ function observabilityRouter() {
   );
   return router;
 }
-async function getScorersHandler(c2) {
+async function listScorersHandler(c2) {
   try {
-    const scorers = await scores.getScorersHandler({
+    const scorers = await scores.listScorersHandler({
       mastra: c2.get("mastra"),
-      runtimeContext: c2.get("runtimeContext")
+      requestContext: c2.get("requestContext")
     });
     return c2.json(scorers);
   } catch (error) {
-    return handleError(error, "Error getting scorers");
+    return handleError(error, "Error listing scorers");
   }
 }
 async function getScorerHandler(c2) {
   const mastra = c2.get("mastra");
   const scorerId = c2.req.param("scorerId");
-  const runtimeContext = c2.get("runtimeContext");
+  const requestContext = c2.get("requestContext");
   const scorer = await scores.getScorerHandler({
     mastra,
     scorerId,
-    runtimeContext
+    requestContext
   });
   return c2.json(scorer);
 }
-async function getScoresByRunIdHandler(c2) {
+async function listScoresByRunIdHandler(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 page = parsePage(c2.req.query("page"));
+  const perPage = parsePerPage(c2.req.query("perPage"), 10);
   const pagination = { page, perPage };
   try {
-    const scores$1 = await scores.getScoresByRunIdHandler({
+    const scores$1 = await scores.listScoresByRunIdHandler({
       mastra,
       runId,
       pagination
@@ -9195,16 +9517,16 @@ async function getScoresByRunIdHandler(c2) {
     return handleError(error, "Error getting scores by run id");
   }
 }
-async function getScoresByScorerIdHandler(c2) {
+async function listScoresByScorerIdHandler(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 page = parsePage(c2.req.query("page"));
+  const perPage = parsePerPage(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({
+    const scores$1 = await scores.listScoresByScorerIdHandler({
       mastra,
       scorerId,
       pagination,
@@ -9216,15 +9538,15 @@ async function getScoresByScorerIdHandler(c2) {
     return handleError(error, "Error getting scores by scorer id");
   }
 }
-async function getScoresByEntityIdHandler(c2) {
+async function listScoresByEntityIdHandler(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 page = parsePage(c2.req.query("page"));
+  const perPage = parsePerPage(c2.req.query("perPage"), 10);
   const pagination = { page, perPage };
   try {
-    const scores$1 = await scores.getScoresByEntityIdHandler({
+    const scores$1 = await scores.listScoresByEntityIdHandler({
       mastra,
       entityId,
       entityType,
@@ -9263,7 +9585,7 @@ function scoresRouter(bodyLimitOptions) {
         }
       }
     }),
-    getScorersHandler
+    listScorersHandler
   );
   router.get(
     "/scorers/:scorerId",
@@ -9311,7 +9633,7 @@ function scoresRouter(bodyLimitOptions) {
         }
       }
     }),
-    getScoresByRunIdHandler
+    listScoresByRunIdHandler
   );
   router.get(
     "/scorer/:scorerId",
@@ -9346,7 +9668,7 @@ function scoresRouter(bodyLimitOptions) {
         }
       }
     }),
-    getScoresByScorerIdHandler
+    listScoresByScorerIdHandler
   );
   router.get(
     "/entity/:entityType/:entityId",
@@ -9389,7 +9711,7 @@ function scoresRouter(bodyLimitOptions) {
         }
       }
     }),
-    getScoresByEntityIdHandler
+    listScoresByEntityIdHandler
   );
   router.post(
     "/",
@@ -9415,7 +9737,7 @@ function scoresRouter(bodyLimitOptions) {
                 entity: { type: "object" },
                 metadata: { type: "object" },
                 additionalLLMContext: { type: "object" },
-                runtimeContext: { type: "object" },
+                requestContext: { type: "object" },
                 resourceId: { type: "string" },
                 threadId: { type: "string" },
                 traceId: { type: "string" }
@@ -9438,73 +9760,6 @@ function scoresRouter(bodyLimitOptions) {
   );
   return router;
 }
-async function getTelemetryHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const { name, scope, page, perPage, fromDate, toDate } = c2.req.query();
-    const attribute = c2.req.queries("attribute");
-    const traces = await telemetry$1.getTelemetryHandler({
-      mastra,
-      body: {
-        name,
-        scope,
-        page: Number(page ?? 0),
-        perPage: Number(perPage ?? 100),
-        attribute,
-        fromDate: fromDate ? new Date(fromDate) : void 0,
-        toDate: toDate ? new Date(toDate) : void 0
-      }
-    });
-    return c2.json({ traces });
-  } catch (error) {
-    return handleError(error, "Error getting telemetry traces");
-  }
-}
-async function storeTelemetryHandler(c2) {
-  try {
-    const body = await c2.req.json();
-    const mastra = c2.get("mastra");
-    const result = await telemetry$1.storeTelemetryHandler({ mastra, body });
-    if (result.status === "error") {
-      return c2.json(result, 500);
-    }
-    return c2.json(result, 200);
-  } catch (error) {
-    return handleError(error, "Error storing telemetry traces");
-  }
-}
-
-// src/server/handlers/routes/telemetry/router.ts
-function telemetryRouter() {
-  const router = new hono.Hono();
-  router.get(
-    "/",
-    w({
-      description: "Get all traces",
-      tags: ["telemetry"],
-      responses: {
-        200: {
-          description: "List of all traces (paged)"
-        }
-      }
-    }),
-    getTelemetryHandler
-  );
-  router.post(
-    "/",
-    w({
-      description: "Store telemetry",
-      tags: ["telemetry"],
-      responses: {
-        200: {
-          description: "Traces stored"
-        }
-      }
-    }),
-    storeTelemetryHandler
-  );
-  return router;
-}
 function toolsRouter(bodyLimitOptions, tools) {
   const router = new hono.Hono();
   router.get(
@@ -9518,7 +9773,7 @@ function toolsRouter(bodyLimitOptions, tools) {
         }
       }
     }),
-    getToolsHandler
+    listToolsHandler
   );
   router.get(
     "/:toolId",
@@ -9572,7 +9827,7 @@ function toolsRouter(bodyLimitOptions, tools) {
               type: "object",
               properties: {
                 data: { type: "object" },
-                runtimeContext: { type: "object" }
+                requestContext: { type: "object" }
               },
               required: ["data"]
             }
@@ -9906,10 +10161,10 @@ function vectorRouter(bodyLimitOptions) {
   );
   return router;
 }
-async function getWorkflowsHandler(c2) {
+async function listWorkflowsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const workflows$1 = await workflows.getWorkflowsHandler({
+    const workflows$1 = await workflows.listWorkflowsHandler({
       mastra
     });
     return c2.json(workflows$1);
@@ -9948,13 +10203,13 @@ async function createWorkflowRunHandler(c2) {
 async function startAsyncWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const workflowId = c2.req.param("workflowId");
     const { inputData, tracingOptions } = await c2.req.json();
     const runId = c2.req.query("runId");
     const result = await workflows.startAsyncWorkflowHandler({
       mastra,
-      runtimeContext,
+      requestContext,
       workflowId,
       runId,
       inputData,
@@ -9968,13 +10223,13 @@ async function startAsyncWorkflowHandler(c2) {
 async function startWorkflowRunHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const workflowId = c2.req.param("workflowId");
     const { inputData, tracingOptions } = await c2.req.json();
     const runId = c2.req.query("runId");
     await workflows.startWorkflowRunHandler({
       mastra,
-      runtimeContext,
+      requestContext,
       workflowId,
       runId,
       inputData,
@@ -9985,49 +10240,10 @@ async function startWorkflowRunHandler(c2) {
     return handleError(e2, "Error starting workflow run");
   }
 }
-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.HTTPException(400, { message: "runId required to watch workflow" });
-    }
-    c2.header("Transfer-Encoding", "chunked");
-    return streaming.stream(
-      c2,
-      async (stream6) => {
-        try {
-          const result = await workflows.watchWorkflowHandler({
-            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 streamVNextWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const logger2 = mastra.getLogger();
     const workflowId = c2.req.param("workflowId");
     const { inputData, closeOnSuspend, tracingOptions } = await c2.req.json();
@@ -10035,24 +10251,24 @@ async function streamVNextWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream5) => {
         try {
           const result = await workflows.streamVNextWorkflowHandler({
             mastra,
             workflowId,
             runId,
             inputData,
-            runtimeContext,
+            requestContext,
             closeOnSuspend,
             tracingOptions
           });
           const reader = result.getReader();
-          stream6.onAbort(() => {
+          stream5.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream5.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           logger2.error("Error in workflow stream: " + (err?.message ?? "Unknown error"));
@@ -10075,7 +10291,7 @@ async function observeStreamVNextWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream5) => {
         try {
           const result = await workflows.observeStreamVNextWorkflowHandler({
             mastra,
@@ -10083,12 +10299,12 @@ async function observeStreamVNextWorkflowHandler(c2) {
             runId
           });
           const reader = result.getReader();
-          stream6.onAbort(() => {
+          stream5.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream5.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           logger2.error("Error in workflow observe stream: " + (err?.message ?? "Unknown error"));
@@ -10105,7 +10321,7 @@ async function observeStreamVNextWorkflowHandler(c2) {
 async function streamLegacyWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
+    const requestContext = c2.get("requestContext");
     const logger2 = mastra.getLogger();
     const workflowId = c2.req.param("workflowId");
     const { inputData, tracingOptions } = await c2.req.json();
@@ -10113,28 +10329,28 @@ async function streamLegacyWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream5) => {
         try {
           const result = await workflows.streamLegacyWorkflowHandler({
             mastra,
             workflowId,
             runId,
             inputData,
-            runtimeContext,
+            requestContext,
             tracingOptions
           });
           const reader = result.stream.getReader();
-          stream6.onAbort(() => {
+          stream5.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream5.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           logger2.error("Error in workflow stream: " + (err?.message ?? "Unknown error"));
         }
-        await stream6.close();
+        await stream5.close();
       },
       async (err) => {
         logger2.error("Error in workflow stream: " + err?.message);
@@ -10156,684 +10372,189 @@ async function observeStreamLegacyWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
-        try {
-          const result = await workflows.observeStreamLegacyWorkflowHandler({
-            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 workflow observe stream: " + (err?.message ?? "Unknown error"));
-        }
-        await stream6.close();
-      },
-      async (err) => {
-        logger2.error("Error in workflow observe stream: " + err?.message);
-      }
-    );
-  } catch (error) {
-    return handleError(error, "Error observing workflow stream");
-  }
-}
-async function resumeStreamWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
-    const logger2 = mastra.getLogger();
-    const workflowId = c2.req.param("workflowId");
-    const { step, resumeData, tracingOptions } = 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.resumeStreamWorkflowHandler({
-            mastra,
-            workflowId,
-            runId,
-            body: { step, resumeData },
-            runtimeContext,
-            tracingOptions
-          });
-          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");
-    const runtimeContext = c2.get("runtimeContext");
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.query("runId");
-    const { step, resumeData, tracingOptions } = await c2.req.json();
-    if (!runId) {
-      throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
-    }
-    const result = await workflows.resumeAsyncWorkflowHandler({
-      mastra,
-      runtimeContext,
-      workflowId,
-      runId,
-      body: { step, resumeData },
-      tracingOptions
-    });
-    return c2.json(result);
-  } catch (error) {
-    return handleError(error, "Error resuming workflow step");
-  }
-}
-async function resumeWorkflowHandler(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 { step, resumeData, tracingOptions } = await c2.req.json();
-    if (!runId) {
-      throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
-    }
-    await workflows.resumeWorkflowHandler({
-      mastra,
-      runtimeContext,
-      workflowId,
-      runId,
-      body: { step, resumeData },
-      tracingOptions
-    });
-    return c2.json({ message: "Workflow run resumed" });
-  } catch (error) {
-    return handleError(error, "Error resuming workflow");
-  }
-}
-async function getWorkflowRunsHandler(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 workflows.getWorkflowRunsHandler({
-      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 getWorkflowRunByIdHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.param("runId");
-    const workflowRun = await workflows.getWorkflowRunByIdHandler({
-      mastra,
-      workflowId,
-      runId
-    });
-    return c2.json(workflowRun);
-  } catch (error) {
-    return handleError(error, "Error getting workflow run");
-  }
-}
-async function getWorkflowRunExecutionResultHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.param("runId");
-    const workflowRunExecutionResult = await workflows.getWorkflowRunExecutionResultHandler({
-      mastra,
-      workflowId,
-      runId
-    });
-    return c2.json(workflowRunExecutionResult);
-  } catch (error) {
-    return handleError(error, "Error getting workflow run execution result");
-  }
-}
-async function cancelWorkflowRunHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.param("runId");
-    const result = await workflows.cancelWorkflowRunHandler({
-      mastra,
-      workflowId,
-      runId
-    });
-    return c2.json(result);
-  } catch (error) {
-    return handleError(error, "Error canceling workflow run");
-  }
-}
-async function sendWorkflowRunEventHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.param("runId");
-    const { event, data } = await c2.req.json();
-    const result = await workflows.sendWorkflowRunEventHandler({
-      mastra,
-      workflowId,
-      runId,
-      event,
-      data
-    });
-    return c2.json(result);
-  } catch (error) {
-    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.error(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/router.ts
-function workflowsRouter(bodyLimitOptions) {
-  const router = new hono.Hono();
-  router.get(
-    "/legacy",
-    w({
-      description: "Get all legacy workflows",
-      tags: ["legacyWorkflows"],
-      responses: {
-        200: {
-          description: "List of all legacy workflows"
-        }
-      }
-    }),
-    getLegacyWorkflowsHandler
-  );
-  router.get(
-    "/legacy/:workflowId",
-    w({
-      description: "Get legacy workflow by ID",
-      tags: ["legacyWorkflows"],
-      parameters: [
-        {
-          name: "workflowId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      responses: {
-        200: {
-          description: "Legacy Workflow details"
-        },
-        404: {
-          description: "Legacy Workflow not found"
-        }
-      }
-    }),
-    getLegacyWorkflowByIdHandler
-  );
-  router.get(
-    "/legacy/:workflowId/runs",
-    w({
-      description: "Get all runs for a legacy workflow",
-      tags: ["legacyWorkflows"],
-      parameters: [
-        {
-          name: "workflowId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        },
-        { name: "fromDate", in: "query", required: false, schema: { type: "string", format: "date-time" } },
-        { name: "toDate", in: "query", required: false, schema: { type: "string", format: "date-time" } },
-        { name: "limit", in: "query", required: false, schema: { type: "number" } },
-        { name: "offset", in: "query", required: false, schema: { type: "number" } },
-        { name: "resourceId", in: "query", required: false, schema: { type: "string" } }
-      ],
-      responses: {
-        200: {
-          description: "List of legacy workflow runs from storage"
-        }
-      }
-    }),
-    getLegacyWorkflowRunsHandler
-  );
-  router.post(
-    "/legacy/:workflowId/resume",
-    w({
-      description: "Resume a suspended legacy workflow step",
-      tags: ["legacyWorkflows"],
-      parameters: [
-        {
-          name: "workflowId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        },
-        {
-          name: "runId",
-          in: "query",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      requestBody: {
-        required: true,
-        content: {
-          "application/json": {
-            schema: {
-              type: "object",
-              properties: {
-                stepId: { type: "string" },
-                context: { type: "object" },
-                tracingOptions: {
-                  type: "object",
-                  description: "Tracing options for the workflow execution",
-                  properties: {
-                    metadata: {
-                      type: "object",
-                      description: "Custom metadata to attach to the trace",
-                      additionalProperties: true
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }),
-    resumeLegacyWorkflowHandler
-  );
-  router.post(
-    "/legacy/:workflowId/resume-async",
-    bodyLimit.bodyLimit(bodyLimitOptions),
-    w({
-      description: "Resume a suspended legacy workflow step",
-      tags: ["legacyWorkflows"],
-      parameters: [
-        {
-          name: "workflowId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        },
-        {
-          name: "runId",
-          in: "query",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      requestBody: {
-        required: true,
-        content: {
-          "application/json": {
-            schema: {
-              type: "object",
-              properties: {
-                stepId: { type: "string" },
-                context: { type: "object" },
-                tracingOptions: {
-                  type: "object",
-                  description: "Tracing options for the workflow execution",
-                  properties: {
-                    metadata: {
-                      type: "object",
-                      description: "Custom metadata to attach to the trace",
-                      additionalProperties: true
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }),
-    resumeAsyncLegacyWorkflowHandler
-  );
-  router.post(
-    "/legacy/:workflowId/create-run",
-    w({
-      description: "Create a new legacy workflow run",
-      tags: ["legacyWorkflows"],
-      parameters: [
-        {
-          name: "workflowId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        },
-        {
-          name: "runId",
-          in: "query",
-          required: false,
-          schema: { type: "string" }
-        }
-      ],
-      responses: {
-        200: {
-          description: "New legacy workflow run created"
-        }
-      }
-    }),
-    createLegacyWorkflowRunHandler
-  );
-  router.post(
-    "/legacy/:workflowId/start-async",
-    bodyLimit.bodyLimit(bodyLimitOptions),
-    w({
-      description: "Execute/Start a legacy workflow",
-      tags: ["legacyWorkflows"],
-      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: {
-                input: { type: "object" }
-              }
-            }
-          }
-        }
-      },
-      responses: {
-        200: {
-          description: "Legacy Workflow execution result"
-        },
-        404: {
-          description: "Legacy Workflow not found"
-        }
-      }
-    }),
-    startAsyncLegacyWorkflowHandler
-  );
-  router.post(
-    "/legacy/:workflowId/start",
-    w({
-      description: "Create and start a new legacy workflow run",
-      tags: ["legacyWorkflows"],
-      parameters: [
-        {
-          name: "workflowId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        },
-        {
-          name: "runId",
-          in: "query",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      requestBody: {
-        required: true,
-        content: {
-          "application/json": {
-            schema: {
-              type: "object",
-              properties: {
-                input: { type: "object" }
-              }
-            }
+      async (stream5) => {
+        try {
+          const result = await workflows.observeStreamLegacyWorkflowHandler({
+            mastra,
+            workflowId,
+            runId
+          });
+          const reader = result.getReader();
+          stream5.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream5.write(JSON.stringify(chunkResult.value) + "");
           }
+        } catch (err) {
+          logger2.error("Error in workflow observe stream: " + (err?.message ?? "Unknown error"));
         }
+        await stream5.close();
       },
-      responses: {
-        200: {
-          description: "Legacy Workflow run started"
-        },
-        404: {
-          description: "Legacy Workflow not found"
-        }
+      async (err) => {
+        logger2.error("Error in workflow observe stream: " + err?.message);
       }
-    }),
-    startLegacyWorkflowRunHandler
-  );
-  router.get(
-    "/legacy/:workflowId/watch",
-    w({
-      description: "Watch legacy workflow transitions in real-time",
-      parameters: [
-        {
-          name: "workflowId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        },
-        {
-          name: "runId",
-          in: "query",
-          required: false,
-          schema: { type: "string" }
-        }
-      ],
-      tags: ["legacyWorkflows"],
-      responses: {
-        200: {
-          description: "Legacy Workflow transitions in real-time"
+    );
+  } catch (error) {
+    return handleError(error, "Error observing workflow stream");
+  }
+}
+async function resumeStreamWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const requestContext = c2.get("requestContext");
+    const logger2 = mastra.getLogger();
+    const workflowId = c2.req.param("workflowId");
+    const { step, resumeData, tracingOptions } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(
+      c2,
+      async (stream5) => {
+        try {
+          const result = await workflows.resumeStreamWorkflowHandler({
+            mastra,
+            workflowId,
+            runId,
+            body: { step, resumeData },
+            requestContext,
+            tracingOptions
+          });
+          const reader = result.getReader();
+          stream5.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream5.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);
       }
-    }),
-    watchLegacyWorkflowHandler
-  );
+    );
+  } catch (error) {
+    return handleError(error, "Error streaming workflow");
+  }
+}
+async function resumeAsyncWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const requestContext = c2.get("requestContext");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    const { step, resumeData, tracingOptions } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    const result = await workflows.resumeAsyncWorkflowHandler({
+      mastra,
+      requestContext,
+      workflowId,
+      runId,
+      body: { step, resumeData },
+      tracingOptions
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error resuming workflow step");
+  }
+}
+async function resumeWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const requestContext = c2.get("requestContext");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    const { step, resumeData, tracingOptions } = await c2.req.json();
+    if (!runId) {
+      throw new httpException.HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    await workflows.resumeWorkflowHandler({
+      mastra,
+      requestContext,
+      workflowId,
+      runId,
+      body: { step, resumeData },
+      tracingOptions
+    });
+    return c2.json({ message: "Workflow run resumed" });
+  } catch (error) {
+    return handleError(error, "Error resuming workflow");
+  }
+}
+async function listWorkflowRunsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const { fromDate, toDate, perPage: perPageRaw, page: pageRaw, resourceId } = c2.req.query();
+    const workflowRuns = await workflows.listWorkflowRunsHandler({
+      mastra,
+      workflowId,
+      fromDate: fromDate ? new Date(fromDate) : void 0,
+      toDate: toDate ? new Date(toDate) : void 0,
+      perPage: perPageRaw !== void 0 ? parsePerPage(perPageRaw) : void 0,
+      page: pageRaw !== void 0 ? parsePage(pageRaw) : void 0,
+      resourceId
+    });
+    return c2.json(workflowRuns);
+  } catch (error) {
+    return handleError(error, "Error getting workflow runs");
+  }
+}
+async function getWorkflowRunByIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.param("runId");
+    const workflowRun = await workflows.getWorkflowRunByIdHandler({
+      mastra,
+      workflowId,
+      runId
+    });
+    return c2.json(workflowRun);
+  } catch (error) {
+    return handleError(error, "Error getting workflow run");
+  }
+}
+async function getWorkflowRunExecutionResultHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.param("runId");
+    const workflowRunExecutionResult = await workflows.getWorkflowRunExecutionResultHandler({
+      mastra,
+      workflowId,
+      runId
+    });
+    return c2.json(workflowRunExecutionResult);
+  } catch (error) {
+    return handleError(error, "Error getting workflow run execution result");
+  }
+}
+async function cancelWorkflowRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.param("runId");
+    const result = await workflows.cancelWorkflowRunHandler({
+      mastra,
+      workflowId,
+      runId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error canceling workflow run");
+  }
+}
+
+// src/server/handlers/routes/workflows/router.ts
+function workflowsRouter(bodyLimitOptions) {
+  const router = new hono.Hono();
   router.get(
     "/",
     w({
@@ -10845,7 +10566,7 @@ function workflowsRouter(bodyLimitOptions) {
         }
       }
     }),
-    getWorkflowsHandler
+    listWorkflowsHandler
   );
   router.get(
     "/:workflowId",
@@ -10874,7 +10595,7 @@ function workflowsRouter(bodyLimitOptions) {
   router.get(
     "/:workflowId/runs",
     w({
-      description: "Get all runs for a workflow",
+      description: "List all runs for a workflow",
       tags: ["workflows"],
       parameters: [
         {
@@ -10895,7 +10616,7 @@ function workflowsRouter(bodyLimitOptions) {
         }
       }
     }),
-    getWorkflowRunsHandler
+    listWorkflowRunsHandler
   );
   router.get(
     "/:workflowId/runs/:runId/execution-result",
@@ -10987,9 +10708,9 @@ function workflowsRouter(bodyLimitOptions) {
                   oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
                 },
                 resumeData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
                   type: "object",
-                  description: "Runtime context for the workflow execution"
+                  description: "Request Context for the workflow execution"
                 }
               }
             }
@@ -11029,9 +10750,9 @@ function workflowsRouter(bodyLimitOptions) {
                   oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
                 },
                 resumeData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
                   type: "object",
-                  description: "Runtime context for the workflow execution"
+                  description: "Request Context for the workflow execution"
                 },
                 tracingOptions: {
                   type: "object",
@@ -11083,9 +10804,9 @@ function workflowsRouter(bodyLimitOptions) {
                   oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
                 },
                 resumeData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
                   type: "object",
-                  description: "Runtime context for the workflow execution"
+                  description: "Request Context for the workflow execution"
                 }
               }
             }
@@ -11121,9 +10842,9 @@ function workflowsRouter(bodyLimitOptions) {
               type: "object",
               properties: {
                 inputData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
                   type: "object",
-                  description: "Runtime context for the workflow execution"
+                  description: "Request Context for the workflow execution"
                 },
                 tracingOptions: {
                   type: "object",
@@ -11209,9 +10930,9 @@ function workflowsRouter(bodyLimitOptions) {
               type: "object",
               properties: {
                 inputData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
                   type: "object",
-                  description: "Runtime context for the workflow execution"
+                  description: "Request Context for the workflow execution"
                 },
                 closeOnSuspend: {
                   type: "boolean",
@@ -11301,9 +11022,9 @@ function workflowsRouter(bodyLimitOptions) {
               type: "object",
               properties: {
                 inputData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
                   type: "object",
-                  description: "Runtime context for the workflow execution"
+                  description: "Request Context for the workflow execution"
                 },
                 closeOnSuspend: {
                   type: "boolean",
@@ -11423,9 +11144,9 @@ function workflowsRouter(bodyLimitOptions) {
               type: "object",
               properties: {
                 inputData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
                   type: "object",
-                  description: "Runtime context for the workflow execution"
+                  description: "Request Context for the workflow execution"
                 },
                 tracingOptions: {
                   type: "object",
@@ -11481,9 +11202,9 @@ function workflowsRouter(bodyLimitOptions) {
               type: "object",
               properties: {
                 inputData: { type: "object" },
-                runtimeContext: {
+                requestContext: {
                   type: "object",
-                  description: "Runtime context for the workflow execution"
+                  description: "Request Context for the workflow execution"
                 },
                 tracingOptions: {
                   type: "object",
@@ -11512,33 +11233,6 @@ function workflowsRouter(bodyLimitOptions) {
     }),
     startWorkflowRunHandler
   );
-  router.get(
-    "/:workflowId/watch",
-    w({
-      description: "Watch workflow transitions in real-time",
-      parameters: [
-        {
-          name: "workflowId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        },
-        {
-          name: "runId",
-          in: "query",
-          required: false,
-          schema: { type: "string" }
-        }
-      ],
-      tags: ["workflows"],
-      responses: {
-        200: {
-          description: "workflow transitions in real-time"
-        }
-      }
-    }),
-    watchWorkflowHandler
-  );
   router.post(
     "/:workflowId/runs/:runId/cancel",
     w({
@@ -11566,41 +11260,6 @@ function workflowsRouter(bodyLimitOptions) {
     }),
     cancelWorkflowRunHandler
   );
-  router.post(
-    "/:workflowId/runs/:runId/send-event",
-    w({
-      description: "Send an event to a workflow run",
-      parameters: [
-        {
-          name: "workflowId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        },
-        {
-          name: "runId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      requestBody: {
-        required: true,
-        content: {
-          "application/json": {
-            schema: { type: "object", properties: { event: { type: "string" }, data: { type: "object" } } }
-          }
-        }
-      },
-      tags: ["workflows"],
-      responses: {
-        200: {
-          description: "workflow run event sent"
-        }
-      }
-    }),
-    sendWorkflowRunEventHandler
-  );
   return router;
 }
 
@@ -11689,7 +11348,7 @@ var html2 = `
     <main>
       <h1>Welcome to Mastra</h1>
       <p class="subtitle">
-        From the team that brought you Gatsby: prototype and productionize AI features with a modern JS/TS stack.
+        Prototype and productionize AI features with a modern JS/TS stack.
       </p>
 
       <a href="https://mastra.ai/docs" class="docs-link">
@@ -11747,36 +11406,17 @@ async function createHonoServer(mastra, options = {
       customRouteAuthConfig.set(routeKey, requiresAuth);
     }
   }
-  app.use("*", async function setTelemetryInfo(c2, next) {
-    const requestId = c2.req.header("x-request-id") ?? crypto.randomUUID();
-    const span = telemetry.Telemetry.getActiveSpan();
-    if (span) {
-      span.setAttribute("http.request_id", requestId);
-      span.updateName(`${c2.req.method} ${c2.req.path}`);
-      const newCtx = telemetry.Telemetry.setBaggage({
-        "http.request_id": { value: requestId }
-      });
-      await new Promise((resolve) => {
-        telemetry.Telemetry.withContext(newCtx, async () => {
-          await next();
-          resolve(true);
-        });
-      });
-    } else {
-      await next();
-    }
-  });
   app.onError((err, c2) => errorHandler(err, c2, options.isDev));
   app.use("*", async function setContext(c2, next) {
-    let runtimeContext$1 = new runtimeContext.RuntimeContext();
+    let requestContext$1 = new requestContext.RequestContext();
     if (c2.req.method === "POST" || c2.req.method === "PUT") {
       const contentType = c2.req.header("content-type");
       if (contentType?.includes("application/json")) {
         try {
           const clonedReq = c2.req.raw.clone();
           const body = await clonedReq.json();
-          if (body.runtimeContext) {
-            runtimeContext$1 = new runtimeContext.RuntimeContext(Object.entries(body.runtimeContext));
+          if (body.requestContext) {
+            requestContext$1 = new requestContext.RequestContext(Object.entries(body.requestContext));
           }
         } catch {
         }
@@ -11784,26 +11424,26 @@ async function createHonoServer(mastra, options = {
     }
     if (c2.req.method === "GET") {
       try {
-        const encodedRuntimeContext = c2.req.query("runtimeContext");
-        if (encodedRuntimeContext) {
-          let parsedRuntimeContext;
+        const encodedRequestContext = c2.req.query("requestContext");
+        if (encodedRequestContext) {
+          let parsedRequestContext;
           try {
-            parsedRuntimeContext = JSON.parse(encodedRuntimeContext);
+            parsedRequestContext = JSON.parse(encodedRequestContext);
           } catch {
             try {
-              const json = Buffer.from(encodedRuntimeContext, "base64").toString("utf-8");
-              parsedRuntimeContext = JSON.parse(json);
+              const json = Buffer.from(encodedRequestContext, "base64").toString("utf-8");
+              parsedRequestContext = JSON.parse(json);
             } catch {
             }
           }
-          if (parsedRuntimeContext && typeof parsedRuntimeContext === "object") {
-            runtimeContext$1 = new runtimeContext.RuntimeContext([...runtimeContext$1.entries(), ...Object.entries(parsedRuntimeContext)]);
+          if (parsedRequestContext && typeof parsedRequestContext === "object") {
+            requestContext$1 = new requestContext.RequestContext([...requestContext$1.entries(), ...Object.entries(parsedRequestContext)]);
           }
         }
       } catch {
       }
     }
-    c2.set("runtimeContext", runtimeContext$1);
+    c2.set("requestContext", requestContext$1);
     c2.set("mastra", mastra);
     c2.set("tools", options.tools);
     c2.set("taskStore", a2aTaskStore);
@@ -11832,6 +11472,19 @@ async function createHonoServer(mastra, options = {
     };
     app.use("*", timeout.timeout(server?.timeout ?? 3 * 60 * 1e3), cors.cors(corsConfig));
   }
+  app.get(
+    "/health",
+    w({
+      description: "Health check endpoint",
+      tags: ["system"],
+      responses: {
+        200: {
+          description: "Service is healthy"
+        }
+      }
+    }),
+    healthHandler
+  );
   app.use("*", authenticationMiddleware);
   app.use("*", authorizationMiddleware);
   const bodyLimitOptions = {
@@ -12037,7 +11690,6 @@ async function createHonoServer(mastra, options = {
   }
   app.route("/api/mcp", mcpRouter(bodyLimitOptions));
   app.route("/api/memory", memoryRoutes(bodyLimitOptions));
-  app.route("/api/telemetry", telemetryRouter());
   app.route("/api/observability", observabilityRouter());
   app.route("/api/workflows", workflowsRouter(bodyLimitOptions));
   app.route("/api/logs", logsRouter());
@@ -12118,10 +11770,6 @@ async function createHonoServer(mastra, options = {
     }
     if (options?.playground) {
       let indexHtml = await promises.readFile(posix.join(process.cwd(), "./playground/index.html"), "utf-8");
-      indexHtml = indexHtml.replace(
-        `'%%MASTRA_TELEMETRY_DISABLED%%'`,
-        `${Boolean(process.env.MASTRA_TELEMETRY_DISABLED)}`
-      );
       const serverOptions = mastra.getServer();
       const port = serverOptions?.port ?? (Number(process.env.PORT) || 4111);
       const hideCloudCta = process.env.MASTRA_HIDE_CLOUD_CTA === "true";