@mastra/deployer 0.24.0 → 1.0.0-beta.0

package/dist/server/index.js

@@ -1,16 +1,15 @@
-import crypto, { randomUUID } from 'crypto';
 import { readFile } from 'fs/promises';
 import * as https from 'https';
 import { join } from 'path/posix';
 import { createServer } from 'http';
 import { Http2ServerRequest } from 'http2';
 import { Writable, Readable } from 'stream';
+import crypto, { randomUUID } from 'crypto';
 import { getMimeType } from 'hono/utils/mime';
 import { existsSync, createReadStream, lstatSync } from 'fs';
 import { join as join$1 } from 'path';
 import { html } from 'hono/html';
-import { RuntimeContext } from '@mastra/core/runtime-context';
-import { Telemetry } from '@mastra/core/telemetry';
+import { RequestContext } from '@mastra/core/request-context';
 import { Tool } from '@mastra/core/tools';
 import { InMemoryTaskStore } from '@mastra/server/a2a/store';
 import { Hono } from 'hono';
@@ -21,26 +20,24 @@ import { HTTPException } from 'hono/http-exception';
 import { getAgentCardByIdHandler as getAgentCardByIdHandler$1, getAgentExecutionHandler as getAgentExecutionHandler$1 } from '@mastra/server/handlers/a2a';
 import { stream } from 'hono/streaming';
 import { bodyLimit } from 'hono/body-limit';
-import { getAgentBuilderActionsHandler as getAgentBuilderActionsHandler$1, getAgentBuilderActionByIdHandler as getAgentBuilderActionByIdHandler$1, getAgentBuilderActionRunsHandler as getAgentBuilderActionRunsHandler$1, getAgentBuilderActionRunExecutionResultHandler as getAgentBuilderActionRunExecutionResultHandler$1, getAgentBuilderActionRunByIdHandler as getAgentBuilderActionRunByIdHandler$1, resumeAgentBuilderActionHandler as resumeAgentBuilderActionHandler$1, resumeAsyncAgentBuilderActionHandler as resumeAsyncAgentBuilderActionHandler$1, streamAgentBuilderActionHandler as streamAgentBuilderActionHandler$1, streamVNextAgentBuilderActionHandler as streamVNextAgentBuilderActionHandler$1, createAgentBuilderActionRunHandler as createAgentBuilderActionRunHandler$1, startAsyncAgentBuilderActionHandler as startAsyncAgentBuilderActionHandler$1, startAgentBuilderActionRunHandler as startAgentBuilderActionRunHandler$1, watchAgentBuilderActionHandler as watchAgentBuilderActionHandler$1, cancelAgentBuilderActionRunHandler as cancelAgentBuilderActionRunHandler$1, sendAgentBuilderActionRunEventHandler as sendAgentBuilderActionRunEventHandler$1 } from '@mastra/server/handlers/agent-builder';
+import { getAgentBuilderActionsHandler as getAgentBuilderActionsHandler$1, getAgentBuilderActionByIdHandler as getAgentBuilderActionByIdHandler$1, getAgentBuilderActionRunsHandler as getAgentBuilderActionRunsHandler$1, getAgentBuilderActionRunExecutionResultHandler as getAgentBuilderActionRunExecutionResultHandler$1, getAgentBuilderActionRunByIdHandler as getAgentBuilderActionRunByIdHandler$1, resumeAgentBuilderActionHandler as resumeAgentBuilderActionHandler$1, resumeAsyncAgentBuilderActionHandler as resumeAsyncAgentBuilderActionHandler$1, resumeStreamAgentBuilderActionHandler as resumeStreamAgentBuilderActionHandler$1, streamLegacyAgentBuilderActionHandler as streamLegacyAgentBuilderActionHandler$1, observeStreamLegacyAgentBuilderActionHandler as observeStreamLegacyAgentBuilderActionHandler$1, streamAgentBuilderActionHandler as streamAgentBuilderActionHandler$1, observeStreamAgentBuilderActionHandler as observeStreamAgentBuilderActionHandler$1, observeStreamVNextAgentBuilderActionHandler as observeStreamVNextAgentBuilderActionHandler$1, streamVNextAgentBuilderActionHandler as streamVNextAgentBuilderActionHandler$1, createAgentBuilderActionRunHandler as createAgentBuilderActionRunHandler$1, startAsyncAgentBuilderActionHandler as startAsyncAgentBuilderActionHandler$1, startAgentBuilderActionRunHandler as startAgentBuilderActionRunHandler$1, cancelAgentBuilderActionRunHandler as cancelAgentBuilderActionRunHandler$1 } from '@mastra/server/handlers/agent-builder';
 import { Agent } from '@mastra/core/agent';
 import { z } from 'zod';
-import { getAgentToolHandler as getAgentToolHandler$1, executeAgentToolHandler as executeAgentToolHandler$1, getToolsHandler as getToolsHandler$1, getToolByIdHandler as getToolByIdHandler$1, executeToolHandler as executeToolHandler$1 } from '@mastra/server/handlers/tools';
+import { getAgentToolHandler as getAgentToolHandler$1, executeAgentToolHandler as executeAgentToolHandler$1, listToolsHandler as listToolsHandler$1, getToolByIdHandler as getToolByIdHandler$1, executeToolHandler as executeToolHandler$1 } from '@mastra/server/handlers/tools';
 import { MastraError, ErrorCategory, ErrorDomain, getErrorFromUnknown } from '@mastra/core/error';
 import { PROVIDER_REGISTRY, getProviderConfig } from '@mastra/core/llm';
 import { ChunkFrom } from '@mastra/core/stream';
-import { getAgentsHandler as getAgentsHandler$1, getAgentByIdHandler as getAgentByIdHandler$1, getEvalsByAgentIdHandler as getEvalsByAgentIdHandler$1, getLiveEvalsByAgentIdHandler as getLiveEvalsByAgentIdHandler$1, generateLegacyHandler as generateLegacyHandler$1, generateHandler as generateHandler$1, getAgentFromSystem, streamNetworkHandler as streamNetworkHandler$1, streamGenerateHandler as streamGenerateHandler$1, streamGenerateLegacyHandler as streamGenerateLegacyHandler$1, streamUIMessageHandler as streamUIMessageHandler$1, updateAgentModelHandler as updateAgentModelHandler$1, resetAgentModelHandler as resetAgentModelHandler$1, reorderAgentModelListHandler as reorderAgentModelListHandler$1, updateAgentModelInModelListHandler as updateAgentModelInModelListHandler$1, approveToolCallHandler as approveToolCallHandler$1, declineToolCallHandler as declineToolCallHandler$1 } from '@mastra/server/handlers/agents';
+import { listAgentsHandler as listAgentsHandler$1, getAgentByIdHandler as getAgentByIdHandler$1, generateLegacyHandler as generateLegacyHandler$1, generateHandler as generateHandler$1, getAgentFromSystem, streamNetworkHandler as streamNetworkHandler$1, streamGenerateHandler as streamGenerateHandler$1, streamGenerateLegacyHandler as streamGenerateLegacyHandler$1, streamUIMessageHandler as streamUIMessageHandler$1, updateAgentModelHandler as updateAgentModelHandler$1, resetAgentModelHandler as resetAgentModelHandler$1, reorderAgentModelListHandler as reorderAgentModelListHandler$1, updateAgentModelInModelListHandler as updateAgentModelInModelListHandler$1, approveToolCallHandler as approveToolCallHandler$1, declineToolCallHandler as declineToolCallHandler$1 } from '@mastra/server/handlers/agents';
 import { getSpeakersHandler as getSpeakersHandler$1, generateSpeechHandler, getListenerHandler as getListenerHandler$1, transcribeSpeechHandler } from '@mastra/server/handlers/voice';
-import { getLogsHandler as getLogsHandler$1, getLogTransports as getLogTransports$1, getLogsByRunIdHandler as getLogsByRunIdHandler$1 } from '@mastra/server/handlers/logs';
+import { listLogsHandler as listLogsHandler$1, listLogTransports as listLogTransports$1, listLogsByRunIdHandler as listLogsByRunIdHandler$1 } from '@mastra/server/handlers/logs';
 import util from 'util';
 import { Buffer as Buffer$1 } from 'buffer';
-import { getMemoryStatusHandler as getMemoryStatusHandler$1, getThreadsHandler as getThreadsHandler$1, getThreadByIdHandler as getThreadByIdHandler$1, getMessagesHandler as getMessagesHandler$1, createThreadHandler as createThreadHandler$1, updateThreadHandler as updateThreadHandler$1, deleteThreadHandler as deleteThreadHandler$1, saveMessagesHandler as saveMessagesHandler$1, deleteMessagesHandler as deleteMessagesHandler$1, getMemoryConfigHandler as getMemoryConfigHandler$1, getThreadsPaginatedHandler as getThreadsPaginatedHandler$1, getMessagesPaginatedHandler as getMessagesPaginatedHandler$1, searchMemoryHandler as searchMemoryHandler$1, getWorkingMemoryHandler as getWorkingMemoryHandler$1, updateWorkingMemoryHandler as updateWorkingMemoryHandler$1 } from '@mastra/server/handlers/memory';
-import { AISpanType } from '@mastra/core/ai-tracing';
-import { getAITracesPaginatedHandler as getAITracesPaginatedHandler$1, getAITraceHandler as getAITraceHandler$1, getScoresBySpan as getScoresBySpan$1, scoreTracesHandler } from '@mastra/server/handlers/observability';
-import { getScorersHandler as getScorersHandler$1, getScorerHandler as getScorerHandler$1, getScoresByRunIdHandler as getScoresByRunIdHandler$1, getScoresByScorerIdHandler as getScoresByScorerIdHandler$1, getScoresByEntityIdHandler as getScoresByEntityIdHandler$1, saveScoreHandler as saveScoreHandler$1 } from '@mastra/server/handlers/scores';
-import { getTelemetryHandler as getTelemetryHandler$1, storeTelemetryHandler as storeTelemetryHandler$1 } from '@mastra/server/handlers/telemetry';
+import { getMemoryStatusHandler as getMemoryStatusHandler$1, listThreadsHandler as listThreadsHandler$1, getThreadByIdHandler as getThreadByIdHandler$1, listMessagesHandler as listMessagesHandler$1, createThreadHandler as createThreadHandler$1, updateThreadHandler as updateThreadHandler$1, deleteThreadHandler as deleteThreadHandler$1, saveMessagesHandler as saveMessagesHandler$1, deleteMessagesHandler as deleteMessagesHandler$1, getMemoryConfigHandler as getMemoryConfigHandler$1, searchMemoryHandler as searchMemoryHandler$1, getWorkingMemoryHandler as getWorkingMemoryHandler$1, updateWorkingMemoryHandler as updateWorkingMemoryHandler$1 } from '@mastra/server/handlers/memory';
+import { SpanType } from '@mastra/core/observability';
+import { getTracesPaginatedHandler as getTracesPaginatedHandler$1, getTraceHandler as getTraceHandler$1, listScoresBySpan as listScoresBySpan$1, scoreTracesHandler } from '@mastra/server/handlers/observability';
+import { listScorersHandler as listScorersHandler$1, getScorerHandler as getScorerHandler$1, listScoresByRunIdHandler as listScoresByRunIdHandler$1, listScoresByScorerIdHandler as listScoresByScorerIdHandler$1, listScoresByEntityIdHandler as listScoresByEntityIdHandler$1, saveScoreHandler as saveScoreHandler$1 } from '@mastra/server/handlers/scores';
 import { upsertVectors as upsertVectors$1, createIndex as createIndex$1, queryVectors as queryVectors$1, listIndexes as listIndexes$1, describeIndex as describeIndex$1, deleteIndex as deleteIndex$1 } from '@mastra/server/handlers/vector';
-import { getWorkflowsHandler as getWorkflowsHandler$1, getWorkflowByIdHandler as getWorkflowByIdHandler$1, getWorkflowRunsHandler as getWorkflowRunsHandler$1, getWorkflowRunExecutionResultHandler as getWorkflowRunExecutionResultHandler$1, getWorkflowRunByIdHandler as getWorkflowRunByIdHandler$1, resumeWorkflowHandler as resumeWorkflowHandler$1, resumeStreamWorkflowHandler as resumeStreamWorkflowHandler$1, resumeAsyncWorkflowHandler as resumeAsyncWorkflowHandler$1, streamLegacyWorkflowHandler as streamLegacyWorkflowHandler$1, observeStreamLegacyWorkflowHandler as observeStreamLegacyWorkflowHandler$1, streamVNextWorkflowHandler as streamVNextWorkflowHandler$1, observeStreamVNextWorkflowHandler as observeStreamVNextWorkflowHandler$1, createWorkflowRunHandler as createWorkflowRunHandler$1, startAsyncWorkflowHandler as startAsyncWorkflowHandler$1, startWorkflowRunHandler as startWorkflowRunHandler$1, watchWorkflowHandler as watchWorkflowHandler$1, cancelWorkflowRunHandler as cancelWorkflowRunHandler$1, sendWorkflowRunEventHandler as sendWorkflowRunEventHandler$1 } from '@mastra/server/handlers/workflows';
-import { getLegacyWorkflowsHandler as getLegacyWorkflowsHandler$1, getLegacyWorkflowByIdHandler as getLegacyWorkflowByIdHandler$1, getLegacyWorkflowRunsHandler as getLegacyWorkflowRunsHandler$1, resumeLegacyWorkflowHandler as resumeLegacyWorkflowHandler$1, resumeAsyncLegacyWorkflowHandler as resumeAsyncLegacyWorkflowHandler$1, createLegacyWorkflowRunHandler as createLegacyWorkflowRunHandler$1, startAsyncLegacyWorkflowHandler as startAsyncLegacyWorkflowHandler$1, startLegacyWorkflowRunHandler as startLegacyWorkflowRunHandler$1, watchLegacyWorkflowHandler as watchLegacyWorkflowHandler$1 } from '@mastra/server/handlers/legacyWorkflows';
+import { listWorkflowsHandler as listWorkflowsHandler$1, getWorkflowByIdHandler as getWorkflowByIdHandler$1, listWorkflowRunsHandler as listWorkflowRunsHandler$1, getWorkflowRunExecutionResultHandler as getWorkflowRunExecutionResultHandler$1, getWorkflowRunByIdHandler as getWorkflowRunByIdHandler$1, resumeWorkflowHandler as resumeWorkflowHandler$1, resumeStreamWorkflowHandler as resumeStreamWorkflowHandler$1, resumeAsyncWorkflowHandler as resumeAsyncWorkflowHandler$1, streamLegacyWorkflowHandler as streamLegacyWorkflowHandler$1, observeStreamLegacyWorkflowHandler as observeStreamLegacyWorkflowHandler$1, streamVNextWorkflowHandler as streamVNextWorkflowHandler$1, observeStreamVNextWorkflowHandler as observeStreamVNextWorkflowHandler$1, createWorkflowRunHandler as createWorkflowRunHandler$1, startAsyncWorkflowHandler as startAsyncWorkflowHandler$1, startWorkflowRunHandler as startWorkflowRunHandler$1, cancelWorkflowRunHandler as cancelWorkflowRunHandler$1 } from '@mastra/server/handlers/workflows';
 
 // src/server/index.ts
 var RequestError = class extends Error {
@@ -327,13 +324,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 = {};
@@ -598,21 +595,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;
@@ -663,7 +660,6 @@ var serveStatic = (options = { root: "" }) => {
       await options.onNotFound?.(path, c2);
       return next();
     }
-    await options.onFound?.(path, c2);
     const mimeType = getMimeType(path);
     c2.header("Content-Type", mimeType || "application/octet-stream");
     if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
@@ -684,30 +680,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(createReadStream(path)), 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 = createReadStream(path, { 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(createReadStream(path)), 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 = createReadStream(path, { 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, c2);
+    return result;
   };
 };
 var RENDER_TYPE = {
@@ -828,7 +827,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);
@@ -974,18 +973,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 getAgentCardByIdHandler$1({
     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();
@@ -995,7 +994,7 @@ async function getAgentExecutionHandler(c2) {
   const result = await getAgentExecutionHandler$1({
     mastra,
     agentId,
-    runtimeContext,
+    requestContext,
     requestId: randomUUID(),
     method: body.method,
     params: body.params,
@@ -1005,15 +1004,15 @@ async function getAgentExecutionHandler(c2) {
   if (body.method === "message/stream") {
     return 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);
@@ -1153,7 +1152,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();
@@ -1185,7 +1184,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);
@@ -1194,7 +1193,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();
@@ -1210,7 +1209,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);
@@ -1255,7 +1254,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");
@@ -1264,7 +1263,7 @@ function handleClientsRefresh(c2) {
       });
     }
   });
-  return new Response(stream6, {
+  return new Response(stream5, {
     headers: {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -1312,6 +1311,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;
@@ -1473,17 +1477,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 startAsyncAgentBuilderActionHandler$1({
       mastra,
-      runtimeContext,
+      requestContext,
       actionId,
       runId,
-      inputData
+      inputData,
+      tracingOptions
     });
     enableHotReload();
     return c2.json(result);
@@ -1495,73 +1500,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 startAgentBuilderActionRunHandler$1({
       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(400, { message: "runId required to watch action" });
-    }
-    c2.header("Transfer-Encoding", "chunked");
-    return stream(c2, async (stream6) => {
-      try {
-        disableHotReload();
-        const result = await watchAgentBuilderActionHandler$1({
-          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 stream(
       c2,
-      async (stream6) => {
+      async (stream5) => {
         try {
           disableHotReload();
           const result = await streamAgentBuilderActionHandler$1({
@@ -1569,20 +1536,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) => {
@@ -1597,15 +1565,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 stream(
       c2,
-      async (stream6) => {
+      async (stream5) => {
         try {
           disableHotReload();
           const result = await streamVNextAgentBuilderActionHandler$1({
@@ -1613,15 +1581,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"));
@@ -1640,20 +1610,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(400, { message: "runId required to resume action" });
     }
     disableHotReload();
     const result = await resumeAsyncAgentBuilderActionHandler$1({
       mastra,
-      runtimeContext,
+      requestContext,
       actionId,
       runId,
-      body: { step, resumeData }
+      body: { step, resumeData },
+      tracingOptions
     });
     enableHotReload();
     return c2.json(result);
@@ -1665,20 +1636,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(400, { message: "runId required to resume action" });
     }
     disableHotReload();
     await resumeAgentBuilderActionHandler$1({
       mastra,
-      runtimeContext,
+      requestContext,
       actionId,
       runId,
-      body: { step, resumeData }
+      body: { step, resumeData },
+      tracingOptions
     });
     enableHotReload();
     return c2.json({ message: "Action run resumed" });
@@ -1691,14 +1663,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 getAgentBuilderActionRunsHandler$1({
       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);
@@ -1751,22 +1724,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 sendAgentBuilderActionRunEventHandler$1({
-      mastra,
-      actionId,
-      runId,
-      event,
-      data
+    const { inputData, tracingOptions } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    c2.header("Transfer-Encoding", "chunked");
+    return stream(
+      c2,
+      async (stream5) => {
+        try {
+          disableHotReload();
+          const result = await streamLegacyAgentBuilderActionHandler$1({
+            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(400, { message: "runId required to observe stream" });
+    }
+    c2.header("Transfer-Encoding", "chunked");
+    return stream(c2, async (stream5) => {
+      try {
+        disableHotReload();
+        const result = await observeStreamLegacyAgentBuilderActionHandler$1({
+          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(400, { message: "runId required to observe stream" });
+    }
+    c2.header("Transfer-Encoding", "chunked");
+    return stream(c2, async (stream5) => {
+      try {
+        disableHotReload();
+        const result = await observeStreamAgentBuilderActionHandler$1({
+          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(400, { message: "runId required to observe stream" });
+    }
+    c2.header("Transfer-Encoding", "chunked");
+    return stream(c2, async (stream5) => {
+      try {
+        disableHotReload();
+        const result = await observeStreamVNextAgentBuilderActionHandler$1({
+          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(400, { message: "runId required to resume stream" });
+    }
+    c2.header("Transfer-Encoding", "chunked");
+    return stream(
+      c2,
+      async (stream5) => {
+        try {
+          disableHotReload();
+          const result = await resumeStreamAgentBuilderActionHandler$1({
+            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");
   }
 }
 
@@ -1926,9 +2096,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
+                    }
+                  }
                 }
               }
             }
@@ -1969,9 +2150,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
+                    }
+                  }
                 }
               }
             }
@@ -1982,9 +2174,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",
@@ -1995,7 +2188,7 @@ function agentBuilderRouter(bodyLimitOptions) {
         {
           name: "runId",
           in: "query",
-          required: false,
+          required: true,
           schema: { type: "string" }
         }
       ],
@@ -2006,32 +2199,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: "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
+                    }
+                  }
                 }
-              }
+              },
+              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",
@@ -2054,9 +2253,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
+                    }
+                  }
                 }
               }
             }
@@ -2073,14 +2283,12 @@ function agentBuilderRouter(bodyLimitOptions) {
       },
       tags: ["agent-builder"]
     }),
-    streamVNextAgentBuilderActionHandler
+    streamLegacyAgentBuilderActionHandler
   );
   router.post(
-    "/:actionId/create-run",
-    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",
@@ -2091,24 +2299,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(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",
@@ -2131,9 +2341,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
+                    }
+                  }
                 }
               }
             }
@@ -2142,20 +2363,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",
@@ -2170,6 +2421,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: {
@@ -2178,9 +2459,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
+                    }
+                  }
                 }
               }
             }
@@ -2194,14 +2490,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(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",
@@ -2214,27 +2513,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(bodyLimitOptions),
     w({
-      description: "Cancel an agent builder action run",
+      description: "Execute/Start an agent builder action",
+      tags: ["agent-builder"],
       parameters: [
         {
           name: "actionId",
@@ -2244,24 +2538,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",
@@ -2271,7 +2596,7 @@ function agentBuilderRouter(bodyLimitOptions) {
         },
         {
           name: "runId",
-          in: "path",
+          in: "query",
           required: true,
           schema: { type: "string" }
         }
@@ -2280,18 +2605,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;
 }
@@ -2311,26 +2685,6 @@ async function generateSystemPromptHandler(c2) {
     if (!agent) {
       return c2.json({ error: "Agent not found" }, 404);
     }
-    let evalSummary = "";
-    try {
-      const testEvals = await mastra.getStorage()?.getEvalsByAgentName?.(agent.name, "test") || [];
-      const liveEvals = await mastra.getStorage()?.getEvalsByAgentName?.(agent.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:
@@ -2379,24 +2733,24 @@ async function generateSystemPromptHandler(c2) {
             Focus on creating prompts that are clear, actionable, and aligned with the intended use case.
         `;
     const systemPromptAgent = new Agent({
+      id: "system-prompt-enhancer",
       name: "system-prompt-enhancer",
       instructions: ENHANCE_SYSTEM_PROMPT_INSTRUCTIONS,
-      model: agent.llm?.getModel()
+      model: await agent.getModel()
     });
     const result = await systemPromptAgent.generate(
       `
             We need to improve the system prompt. 
             Current: ${instructions}
             ${comment ? `User feedback: ${comment}` : ""}
-            ${evalSummary ? `
-Evaluation Results:
-${evalSummary}` : ""}
         `,
       {
-        output: z.object({
-          new_prompt: z.string(),
-          explanation: z.string()
-        })
+        structuredOutput: {
+          schema: z.object({
+            new_prompt: z.string(),
+            explanation: z.string()
+          })
+        }
       }
     );
     return c2.json(result?.object || {});
@@ -2404,10 +2758,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 getToolsHandler$1({
+    const result = await listToolsHandler$1({
       tools
     });
     return c2.json(result || {});
@@ -2432,7 +2786,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();
@@ -2440,7 +2794,7 @@ function executeToolHandler(tools) {
         mastra,
         toolId,
         data,
-        runtimeContext,
+        requestContext,
         runId
       });
       return c2.json(result);
@@ -2452,14 +2806,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 getAgentToolHandler$1({
       mastra,
       agentId,
       toolId,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -2469,7 +2823,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();
@@ -2478,7 +2832,7 @@ async function executeAgentToolHandler(c2) {
       agentId,
       toolId,
       data,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -2549,10 +2903,10 @@ var vNextBodyOptions = {
   },
   ...sharedBodyOptions
 };
-async function getAgentsHandler(c2) {
-  const serializedAgents = await getAgentsHandler$1({
+async function listAgentsHandler(c2) {
+  const serializedAgents = await listAgentsHandler$1({
     mastra: c2.get("mastra"),
-    runtimeContext: c2.get("runtimeContext")
+    requestContext: c2.get("requestContext")
   });
   return c2.json(serializedAgents);
 }
@@ -2580,48 +2934,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 getAgentByIdHandler$1({
     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 getEvalsByAgentIdHandler$1({
-    mastra,
-    agentId,
-    runtimeContext
-  });
-  return c2.json(result);
-}
-async function getLiveEvalsByAgentIdHandler(c2) {
-  const mastra = c2.get("mastra");
-  const agentId = c2.req.param("agentId");
-  const runtimeContext = c2.get("runtimeContext");
-  const result = await getLiveEvalsByAgentIdHandler$1({
-    mastra,
-    agentId,
-    runtimeContext
-  });
-  return c2.json(result);
-}
 async function 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 generateLegacyHandler$1({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body,
       abortSignal: c2.req.raw.signal
     });
@@ -2634,12 +2966,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 generateHandler$1({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body,
       abortSignal: c2.req.raw.signal
     });
@@ -2652,12 +2984,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 streamGenerateLegacyHandler$1({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body,
       abortSignal: c2.req.raw.signal
     });
@@ -2669,7 +3001,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;
@@ -2677,7 +3009,7 @@ async function streamGenerateHandler(c2) {
     streamResponse = await streamGenerateHandler$1({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body,
       abortSignal: c2.req.raw.signal
     });
@@ -2687,19 +3019,19 @@ async function streamGenerateHandler(c2) {
   c2.header("Transfer-Encoding", "chunked");
   return 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 = {
@@ -2710,11 +3042,11 @@ async function streamGenerateHandler(c2) {
             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);
@@ -2724,14 +3056,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 approveToolCallHandler$1({
       mastra,
-      runtimeContext,
+      requestContext,
       agentId,
       body,
       abortSignal: c2.req.raw.signal
@@ -2742,19 +3074,19 @@ async function approveToolCallHandler(c2) {
   c2.header("Transfer-Encoding", "chunked");
   return 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 = {
@@ -2769,11 +3101,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);
@@ -2783,14 +3115,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 declineToolCallHandler$1({
       mastra,
-      runtimeContext,
+      requestContext,
       agentId,
       body,
       abortSignal: c2.req.raw.signal
@@ -2801,19 +3133,19 @@ async function declineToolCallHandler(c2) {
   c2.header("Transfer-Encoding", "chunked");
   return 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 = {
@@ -2828,11 +3160,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);
@@ -2842,11 +3174,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 getAgentFromSystem({ mastra, agentId });
-  const memory = await agent.getMemory({ runtimeContext });
+  const memory = await agent.getMemory({ requestContext });
   if (!memory) {
     return handleError(
       new MastraError({
@@ -2866,7 +3198,7 @@ async function streamNetworkHandler(c2) {
     streamResponse = await streamNetworkHandler$1({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body
       // abortSignal: c.req.raw.signal,
     });
@@ -2876,19 +3208,19 @@ async function streamNetworkHandler(c2) {
   c2.header("Transfer-Encoding", "chunked");
   return 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 = {
@@ -2903,11 +3235,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);
@@ -2918,12 +3250,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 streamUIMessageHandler$1({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body,
       abortSignal: c2.req.raw.signal
     });
@@ -3032,11 +3364,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 getSpeakersHandler$1({
       mastra,
       agentId,
-      runtimeContext
+      requestContext
     });
     return c2.json(speakers);
   } catch (error) {
@@ -3047,12 +3379,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 generateSpeechHandler({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body: { text: input, speakerId: options?.speakerId }
     });
     c2.header("Content-Type", `audio/${options?.filetype ?? "mp3"}`);
@@ -3066,11 +3398,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 getListenerHandler$1({
       mastra,
       agentId,
-      runtimeContext
+      requestContext
     });
     return c2.json(listeners);
   } catch (error) {
@@ -3081,7 +3413,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");
@@ -3097,7 +3429,7 @@ async function listenHandler(c2) {
     const transcription = await transcribeSpeechHandler({
       mastra,
       agentId,
-      runtimeContext,
+      requestContext,
       body: {
         audioData: Buffer.from(audioData),
         options: parsedOptions
@@ -3123,7 +3455,7 @@ function agentsRouter(bodyLimitOptions) {
         }
       }
     }),
-    getAgentsHandler
+    listAgentsHandler
   );
   router.get(
     "/providers",
@@ -3162,48 +3494,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(bodyLimitOptions),
@@ -3693,7 +3983,7 @@ function agentsRouter(bodyLimitOptions) {
     "/:agentId/stream/vnext/ui",
     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: [
@@ -3731,8 +4021,9 @@ function agentsRouter(bodyLimitOptions) {
     "/:agentId/stream/ui",
     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",
@@ -4414,7 +4705,7 @@ function agentsRouter(bodyLimitOptions) {
               type: "object",
               properties: {
                 data: { type: "object" },
-                runtimeContext: { type: "object" }
+                requestContext: { type: "object" }
               },
               required: ["data"]
             }
@@ -4455,7 +4746,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"]
@@ -4497,7 +4788,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"]
@@ -4637,12 +4928,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 = await getLogsHandler$1({
+    const logs = await listLogsHandler$1({
       mastra,
       transportId,
       params: {
@@ -4659,13 +4950,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 = await getLogsByRunIdHandler$1({
+    const logs = await listLogsByRunIdHandler$1({
       mastra,
       runId,
       transportId,
@@ -4683,10 +4974,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 getLogTransports$1({
+    const result = await listLogTransports$1({
       mastra
     });
     return c2.json(result);
@@ -4753,7 +5044,7 @@ function logsRouter() {
         }
       }
     }),
-    getLogsHandler
+    listLogsHandler
   );
   router.get(
     "/transports",
@@ -4766,7 +5057,7 @@ function logsRouter() {
         }
       }
     }),
-    getLogTransports
+    listLogTransports
   );
   router.get(
     "/:runId",
@@ -4829,7 +5120,7 @@ function logsRouter() {
         }
       }
     }),
-    getLogsByRunIdHandler
+    listLogsByRunIdHandler
   );
   return router;
 }
@@ -6696,11 +6987,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({
@@ -6724,15 +7015,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);
   }
@@ -6753,13 +7046,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(
@@ -6788,11 +7081,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);
   }
@@ -6814,11 +7109,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);
   }
@@ -6838,11 +7133,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);
   }
@@ -6867,11 +7162,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);
   }
@@ -6882,8 +7177,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 });
@@ -7285,7 +7580,7 @@ function mcpRouter(bodyLimitOptions) {
               type: "object",
               properties: {
                 data: { type: "object" },
-                runtimeContext: { type: "object" }
+                requestContext: { type: "object" }
               }
             }
           }
@@ -7315,17 +7610,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 getMemoryStatusHandler$1({
       mastra,
       agentId,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7336,61 +7652,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 getMemoryConfigHandler$1({
       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 getThreadsHandler$1({
-      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 getThreadsPaginatedHandler$1({
+    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 listThreadsHandler$1({
       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) {
@@ -7398,12 +7704,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 getThreadByIdHandler$1({
       mastra,
       agentId,
       threadId,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7415,12 +7721,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 saveMessagesHandler$1({
       mastra,
       agentId,
       body,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7432,12 +7738,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 createThreadHandler$1({
       mastra,
       agentId,
       body,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7450,13 +7756,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 updateThreadHandler$1({
       mastra,
       agentId,
       threadId,
       body,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7468,57 +7774,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 deleteThreadHandler$1({
       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 getMessagesHandler$1({
-      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 getMessagesPaginatedHandler$1({
+    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 listMessagesHandler$1({
       mastra,
+      agentId,
       threadId,
       resourceId,
-      format,
-      selectBy
+      page,
+      perPage,
+      orderBy,
+      include,
+      filter,
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7531,13 +7821,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 updateWorkingMemoryHandler$1({
       mastra,
       agentId,
       threadId,
       body,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7550,13 +7840,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 getWorkingMemoryHandler$1({
       mastra,
       agentId,
       threadId,
       resourceId,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7572,7 +7862,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 searchMemoryHandler$1({
       mastra,
       agentId,
@@ -7581,7 +7871,7 @@ async function searchMemoryHandler(c2) {
       threadId,
       limit,
       memoryConfig,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7592,14 +7882,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 deleteMessagesHandler$1({
       mastra,
       agentId,
       messageIds,
-      runtimeContext
+      requestContext
     });
     return c2.json(result);
   } catch (error) {
@@ -7649,6 +7939,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",
@@ -7678,7 +7982,7 @@ function memoryRoutes(bodyLimitOptions) {
         }
       }
     }),
-    getThreadsHandler
+    listThreadsHandler
   );
   router.get(
     "/network/threads/:threadId",
@@ -7713,14 +8017,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",
@@ -7729,20 +8036,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",
@@ -8108,55 +8480,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"],
@@ -8174,18 +8497,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",
@@ -8214,7 +8537,7 @@ function memoryRoutes(bodyLimitOptions) {
         }
       }
     }),
-    getThreadsPaginatedHandler
+    listThreadsHandler
   );
   router.get(
     "/threads/:threadId",
@@ -8248,58 +8571,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"
           }
@@ -8314,34 +8603,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: {
-            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}]}'
+            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"
         }
       }
     }),
-    getMessagesPaginatedHandler
+    listMessagesHandler
   );
   router.get(
     "/search",
@@ -8779,23 +9101,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 getAITraceHandler$1({
+    const trace = await getTraceHandler$1({
       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();
@@ -8806,7 +9128,7 @@ async function getAITracesPaginatedHandler(c2) {
     const filters = {};
     if (name) filters.name = name;
     if (spanType) {
-      if (Object.values(AISpanType).includes(spanType)) {
+      if (Object.values(SpanType).includes(spanType)) {
         filters.spanType = spanType;
       } else {
         return c2.json({ error: "Invalid spanType" }, 400);
@@ -8830,7 +9152,7 @@ async function getAITracesPaginatedHandler(c2) {
     if (start || end) {
       pagination.dateRange = { start, end };
     }
-    const result = await getAITracesPaginatedHandler$1({
+    const result = await getTracesPaginatedHandler$1({
       mastra,
       body: {
         pagination,
@@ -8839,7 +9161,7 @@ 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) {
@@ -8855,7 +9177,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");
@@ -8863,7 +9185,7 @@ async function getScoresBySpan(c2) {
   const perPage = parseInt(c2.req.query("perPage") || "10");
   const pagination = { page, perPage };
   try {
-    const scores = await getScoresBySpan$1({
+    const scores = await listScoresBySpan$1({
       mastra,
       traceId,
       spanId,
@@ -8881,7 +9203,7 @@ function observabilityRouter() {
   router.get(
     "/traces",
     w({
-      description: "Get paginated list of AI traces",
+      description: "Get paginated list of traces",
       tags: ["observability"],
       parameters: [
         {
@@ -8929,19 +9251,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: [
         {
@@ -8954,7 +9276,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"
@@ -8964,7 +9286,7 @@ function observabilityRouter() {
         }
       }
     }),
-    getAITraceHandler
+    getTraceHandler
   );
   router.get(
     "/traces/:traceId/:spanId/scores",
@@ -9007,7 +9329,7 @@ function observabilityRouter() {
         }
       }
     }),
-    getScoresBySpan
+    listScoresBySpan
   );
   router.post(
     "/traces/score",
@@ -9130,36 +9452,36 @@ function observabilityRouter() {
   );
   return router;
 }
-async function getScorersHandler(c2) {
+async function listScorersHandler(c2) {
   try {
-    const scorers = await getScorersHandler$1({
+    const scorers = await listScorersHandler$1({
       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 getScorerHandler$1({
     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 = await getScoresByRunIdHandler$1({
+    const scores = await listScoresByRunIdHandler$1({
       mastra,
       runId,
       pagination
@@ -9169,16 +9491,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 = await getScoresByScorerIdHandler$1({
+    const scores = await listScoresByScorerIdHandler$1({
       mastra,
       scorerId,
       pagination,
@@ -9190,15 +9512,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 = await getScoresByEntityIdHandler$1({
+    const scores = await listScoresByEntityIdHandler$1({
       mastra,
       entityId,
       entityType,
@@ -9237,7 +9559,7 @@ function scoresRouter(bodyLimitOptions) {
         }
       }
     }),
-    getScorersHandler
+    listScorersHandler
   );
   router.get(
     "/scorers/:scorerId",
@@ -9285,7 +9607,7 @@ function scoresRouter(bodyLimitOptions) {
         }
       }
     }),
-    getScoresByRunIdHandler
+    listScoresByRunIdHandler
   );
   router.get(
     "/scorer/:scorerId",
@@ -9320,7 +9642,7 @@ function scoresRouter(bodyLimitOptions) {
         }
       }
     }),
-    getScoresByScorerIdHandler
+    listScoresByScorerIdHandler
   );
   router.get(
     "/entity/:entityType/:entityId",
@@ -9363,7 +9685,7 @@ function scoresRouter(bodyLimitOptions) {
         }
       }
     }),
-    getScoresByEntityIdHandler
+    listScoresByEntityIdHandler
   );
   router.post(
     "/",
@@ -9389,7 +9711,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" }
@@ -9412,73 +9734,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 getTelemetryHandler$1({
-      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 storeTelemetryHandler$1({ 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();
-  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();
   router.get(
@@ -9492,7 +9747,7 @@ function toolsRouter(bodyLimitOptions, tools) {
         }
       }
     }),
-    getToolsHandler
+    listToolsHandler
   );
   router.get(
     "/:toolId",
@@ -9546,7 +9801,7 @@ function toolsRouter(bodyLimitOptions, tools) {
               type: "object",
               properties: {
                 data: { type: "object" },
-                runtimeContext: { type: "object" }
+                requestContext: { type: "object" }
               },
               required: ["data"]
             }
@@ -9880,10 +10135,10 @@ function vectorRouter(bodyLimitOptions) {
   );
   return router;
 }
-async function getWorkflowsHandler(c2) {
+async function listWorkflowsHandler(c2) {
   try {
     const mastra = c2.get("mastra");
-    const workflows = await getWorkflowsHandler$1({
+    const workflows = await listWorkflowsHandler$1({
       mastra
     });
     return c2.json(workflows);
@@ -9922,13 +10177,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 startAsyncWorkflowHandler$1({
       mastra,
-      runtimeContext,
+      requestContext,
       workflowId,
       runId,
       inputData,
@@ -9942,13 +10197,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 startWorkflowRunHandler$1({
       mastra,
-      runtimeContext,
+      requestContext,
       workflowId,
       runId,
       inputData,
@@ -9959,49 +10214,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(400, { message: "runId required to watch workflow" });
-    }
-    c2.header("Transfer-Encoding", "chunked");
-    return stream(
-      c2,
-      async (stream6) => {
-        try {
-          const result = await watchWorkflowHandler$1({
-            mastra,
-            workflowId,
-            runId
-          });
-          const reader = result.getReader();
-          stream6.onAbort(() => {
-            void reader.cancel("request aborted");
-          });
-          let chunkResult;
-          while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
-          }
-        } catch (err) {
-          logger2.error("Error in watch stream: " + (err?.message ?? "Unknown error"));
-        }
-      },
-      async (err) => {
-        logger2.error("Error in watch stream: " + err?.message);
-      }
-    );
-  } catch (error) {
-    return handleError(error, "Error watching workflow");
-  }
-}
 async function 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();
@@ -10009,24 +10225,24 @@ async function streamVNextWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream6) => {
+      async (stream5) => {
         try {
           const result = await streamVNextWorkflowHandler$1({
             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"));
@@ -10049,7 +10265,7 @@ async function observeStreamVNextWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream6) => {
+      async (stream5) => {
         try {
           const result = await observeStreamVNextWorkflowHandler$1({
             mastra,
@@ -10057,12 +10273,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"));
@@ -10079,7 +10295,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();
@@ -10087,28 +10303,28 @@ async function streamLegacyWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream6) => {
+      async (stream5) => {
         try {
           const result = await streamLegacyWorkflowHandler$1({
             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);
@@ -10130,684 +10346,189 @@ async function observeStreamLegacyWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream6) => {
-        try {
-          const result = await observeStreamLegacyWorkflowHandler$1({
-            mastra,
-            workflowId,
-            runId
-          });
-          const reader = result.getReader();
-          stream6.onAbort(() => {
-            void reader.cancel("request aborted");
-          });
-          let chunkResult;
-          while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
-          }
-        } catch (err) {
-          logger2.error("Error in 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 stream(
-      c2,
-      async (stream6) => {
-        try {
-          const result = await resumeStreamWorkflowHandler$1({
-            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(400, { message: "runId required to resume workflow" });
-    }
-    const result = await resumeAsyncWorkflowHandler$1({
-      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(400, { message: "runId required to resume workflow" });
-    }
-    await resumeWorkflowHandler$1({
-      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 getWorkflowRunsHandler$1({
-      mastra,
-      workflowId,
-      fromDate: fromDate ? new Date(fromDate) : void 0,
-      toDate: toDate ? new Date(toDate) : void 0,
-      limit: limit ? Number(limit) : void 0,
-      offset: offset ? Number(offset) : void 0,
-      resourceId
-    });
-    return c2.json(workflowRuns);
-  } catch (error) {
-    return handleError(error, "Error getting workflow runs");
-  }
-}
-async function getWorkflowRunByIdHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.param("runId");
-    const workflowRun = await getWorkflowRunByIdHandler$1({
-      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 getWorkflowRunExecutionResultHandler$1({
-      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 cancelWorkflowRunHandler$1({
-      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 sendWorkflowRunEventHandler$1({
-      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 getLegacyWorkflowsHandler$1({
-      mastra
-    });
-    return c2.json(workflows);
-  } catch (error) {
-    return handleError(error, "Error getting workflows");
-  }
-}
-async function getLegacyWorkflowByIdHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const workflow = await getLegacyWorkflowByIdHandler$1({
-      mastra,
-      workflowId
-    });
-    return c2.json(workflow);
-  } catch (error) {
-    return handleError(error, "Error getting workflow");
-  }
-}
-async function startAsyncLegacyWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
-    const workflowId = c2.req.param("workflowId");
-    const triggerData = await c2.req.json();
-    const runId = c2.req.query("runId");
-    const result = await startAsyncLegacyWorkflowHandler$1({
-      mastra,
-      runtimeContext,
-      workflowId,
-      runId,
-      triggerData
-    });
-    return c2.json(result);
-  } catch (error) {
-    return handleError(error, "Error executing workflow");
-  }
-}
-async function createLegacyWorkflowRunHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const prevRunId = c2.req.query("runId");
-    const result = await createLegacyWorkflowRunHandler$1({
-      mastra,
-      workflowId,
-      runId: prevRunId
-    });
-    return c2.json(result);
-  } catch (e2) {
-    return handleError(e2, "Error creating run");
-  }
-}
-async function startLegacyWorkflowRunHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
-    const workflowId = c2.req.param("workflowId");
-    const triggerData = await c2.req.json();
-    const runId = c2.req.query("runId");
-    await startLegacyWorkflowRunHandler$1({
-      mastra,
-      runtimeContext,
-      workflowId,
-      runId,
-      triggerData
-    });
-    return c2.json({ message: "Workflow run started" });
-  } catch (e2) {
-    return handleError(e2, "Error starting workflow run");
-  }
-}
-function watchLegacyWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const logger2 = mastra.getLogger();
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.query("runId");
-    if (!runId) {
-      throw new HTTPException(400, { message: "runId required to watch workflow" });
-    }
-    return stream(
-      c2,
-      async (stream6) => {
-        try {
-          const result = await watchLegacyWorkflowHandler$1({
-            mastra,
-            workflowId,
-            runId
-          });
-          stream6.onAbort(() => {
-            if (!result.locked) {
-              return result.cancel();
-            }
-          });
-          for await (const chunk of result) {
-            await stream6.write(chunk.toString() + "");
-          }
-        } catch (err) {
-          console.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(400, { message: "runId required to resume workflow" });
-    }
-    const result = await resumeAsyncLegacyWorkflowHandler$1({
-      mastra,
-      runtimeContext,
-      workflowId,
-      runId,
-      body: { stepId, context }
-    });
-    return c2.json(result);
-  } catch (error) {
-    return handleError(error, "Error resuming workflow step");
-  }
-}
-async function resumeLegacyWorkflowHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const runtimeContext = c2.get("runtimeContext");
-    const workflowId = c2.req.param("workflowId");
-    const runId = c2.req.query("runId");
-    const { stepId, context } = await c2.req.json();
-    if (!runId) {
-      throw new HTTPException(400, { message: "runId required to resume workflow" });
-    }
-    await resumeLegacyWorkflowHandler$1({
-      mastra,
-      runtimeContext,
-      workflowId,
-      runId,
-      body: { stepId, context }
-    });
-    return c2.json({ message: "Workflow run resumed" });
-  } catch (error) {
-    return handleError(error, "Error resuming workflow");
-  }
-}
-async function getLegacyWorkflowRunsHandler(c2) {
-  try {
-    const mastra = c2.get("mastra");
-    const workflowId = c2.req.param("workflowId");
-    const { fromDate, toDate, limit, offset, resourceId } = c2.req.query();
-    const workflowRuns = await getLegacyWorkflowRunsHandler$1({
-      mastra,
-      workflowId,
-      fromDate: fromDate ? new Date(fromDate) : void 0,
-      toDate: toDate ? new Date(toDate) : void 0,
-      limit: limit ? Number(limit) : void 0,
-      offset: offset ? Number(offset) : void 0,
-      resourceId
-    });
-    return c2.json(workflowRuns);
-  } catch (error) {
-    return handleError(error, "Error getting workflow runs");
-  }
-}
-
-// src/server/handlers/routes/workflows/router.ts
-function workflowsRouter(bodyLimitOptions) {
-  const router = new 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(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(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 observeStreamLegacyWorkflowHandler$1({
+            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 stream(
+      c2,
+      async (stream5) => {
+        try {
+          const result = await resumeStreamWorkflowHandler$1({
+            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(400, { message: "runId required to resume workflow" });
+    }
+    const result = await resumeAsyncWorkflowHandler$1({
+      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(400, { message: "runId required to resume workflow" });
+    }
+    await resumeWorkflowHandler$1({
+      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 listWorkflowRunsHandler$1({
+      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 getWorkflowRunByIdHandler$1({
+      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 getWorkflowRunExecutionResultHandler$1({
+      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 cancelWorkflowRunHandler$1({
+      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();
   router.get(
     "/",
     w({
@@ -10819,7 +10540,7 @@ function workflowsRouter(bodyLimitOptions) {
         }
       }
     }),
-    getWorkflowsHandler
+    listWorkflowsHandler
   );
   router.get(
     "/:workflowId",
@@ -10848,7 +10569,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: [
         {
@@ -10869,7 +10590,7 @@ function workflowsRouter(bodyLimitOptions) {
         }
       }
     }),
-    getWorkflowRunsHandler
+    listWorkflowRunsHandler
   );
   router.get(
     "/:workflowId/runs/:runId/execution-result",
@@ -10961,9 +10682,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"
                 }
               }
             }
@@ -11003,9 +10724,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",
@@ -11057,9 +10778,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"
                 }
               }
             }
@@ -11095,9 +10816,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",
@@ -11183,9 +10904,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",
@@ -11275,9 +10996,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",
@@ -11397,9 +11118,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",
@@ -11455,9 +11176,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",
@@ -11486,33 +11207,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({
@@ -11540,41 +11234,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;
 }
 
@@ -11663,7 +11322,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">
@@ -11721,36 +11380,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") ?? randomUUID();
-    const span = Telemetry.getActiveSpan();
-    if (span) {
-      span.setAttribute("http.request_id", requestId);
-      span.updateName(`${c2.req.method} ${c2.req.path}`);
-      const newCtx = Telemetry.setBaggage({
-        "http.request_id": { value: requestId }
-      });
-      await new Promise((resolve) => {
-        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 = new RuntimeContext();
+    let requestContext = new 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 = new RuntimeContext(Object.entries(body.runtimeContext));
+          if (body.requestContext) {
+            requestContext = new RequestContext(Object.entries(body.requestContext));
           }
         } catch {
         }
@@ -11758,26 +11398,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 = new RuntimeContext([...runtimeContext.entries(), ...Object.entries(parsedRuntimeContext)]);
+          if (parsedRequestContext && typeof parsedRequestContext === "object") {
+            requestContext = new RequestContext([...requestContext.entries(), ...Object.entries(parsedRequestContext)]);
           }
         }
       } catch {
       }
     }
-    c2.set("runtimeContext", runtimeContext);
+    c2.set("requestContext", requestContext);
     c2.set("mastra", mastra);
     c2.set("tools", options.tools);
     c2.set("taskStore", a2aTaskStore);
@@ -11806,6 +11446,19 @@ async function createHonoServer(mastra, options = {
     };
     app.use("*", timeout(server?.timeout ?? 3 * 60 * 1e3), 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 = {
@@ -12011,7 +11664,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());
@@ -12092,10 +11744,6 @@ async function createHonoServer(mastra, options = {
     }
     if (options?.playground) {
       let indexHtml = await readFile(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";