@mastra/deployer 0.15.3-alpha.2 → 0.15.3-alpha.4

package/dist/server/index.js

@@ -19,11 +19,12 @@ import { timeout } from 'hono/timeout';
 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 { getAgentsHandler as getAgentsHandler$1, getAgentByIdHandler as getAgentByIdHandler$1, getEvalsByAgentIdHandler as getEvalsByAgentIdHandler$1, getLiveEvalsByAgentIdHandler as getLiveEvalsByAgentIdHandler$1, generateHandler as generateHandler$1, generateVNextHandler as generateVNextHandler$1, streamVNextGenerateHandler as streamVNextGenerateHandler$1, streamGenerateHandler as streamGenerateHandler$1, streamVNextUIMessageHandler as streamVNextUIMessageHandler$1, updateAgentModelHandler as updateAgentModelHandler$1 } from '@mastra/server/handlers/agents';
 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 { getAgentsHandler as getAgentsHandler$1, getAgentByIdHandler as getAgentByIdHandler$1, getEvalsByAgentIdHandler as getEvalsByAgentIdHandler$1, getLiveEvalsByAgentIdHandler as getLiveEvalsByAgentIdHandler$1, generateLegacyHandler as generateLegacyHandler$1, generateHandler as generateHandler$1, generateVNextHandler as generateVNextHandler$1, streamVNextGenerateHandler as streamVNextGenerateHandler$1, streamGenerateLegacyHandler as streamGenerateLegacyHandler$1, streamGenerateHandler as streamGenerateHandler$1, streamVNextUIMessageHandler as streamVNextUIMessageHandler$1, updateAgentModelHandler as updateAgentModelHandler$1 } from '@mastra/server/handlers/agents';
 import { Agent } from '@mastra/core/agent';
 import { z } from 'zod';
-import { executeAgentToolHandler as executeAgentToolHandler$1, getToolsHandler as getToolsHandler$1, getToolByIdHandler as getToolByIdHandler$1, executeToolHandler as executeToolHandler$1 } from '@mastra/server/handlers/tools';
+import { 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 { getSpeakersHandler as getSpeakersHandler$1, generateSpeechHandler, getListenerHandler as getListenerHandler$1, transcribeSpeechHandler } from '@mastra/server/handlers/voice';
 import { getLogsHandler as getLogsHandler$1, getLogTransports as getLogTransports$1, getLogsByRunIdHandler as getLogsByRunIdHandler$1 } from '@mastra/server/handlers/logs';
 import util from 'util';
@@ -280,13 +281,13 @@ var Response2 = class _Response {
 });
 Object.setPrototypeOf(Response2, GlobalResponse);
 Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
-function writeFromReadableStream(stream6, writable) {
-  if (stream6.locked) {
+function writeFromReadableStream(stream7, writable) {
+  if (stream7.locked) {
     throw new TypeError("ReadableStream is locked.");
   } else if (writable.destroyed) {
     return;
   }
-  const reader = stream6.getReader();
+  const reader = stream7.getReader();
   const handleError2 = () => {
   };
   writable.on("error", handleError2);
@@ -553,18 +554,18 @@ var ENCODINGS = {
   gzip: ".gz"
 };
 var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
-var createStreamBody = (stream6) => {
+var createStreamBody = (stream7) => {
   const body = new ReadableStream({
     start(controller) {
-      stream6.on("data", (chunk) => {
+      stream7.on("data", (chunk) => {
         controller.enqueue(chunk);
       });
-      stream6.on("end", () => {
+      stream7.on("end", () => {
         controller.close();
       });
     },
     cancel() {
-      stream6.destroy();
+      stream7.destroy();
     }
   });
   return body;
@@ -653,10 +654,10 @@ var serveStatic = (options = { root: "" }) => {
       end = size - 1;
     }
     const chunksize = end - start + 1;
-    const stream6 = createReadStream(path, { start, end });
+    const stream7 = 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);
+    return c2.body(createStreamBody(stream7), 206);
   };
 };
 var RENDER_TYPE = {
@@ -954,15 +955,15 @@ async function getAgentExecutionHandler(c2) {
   if (body.method === "message/stream") {
     return stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             if (!result.locked) {
               return result.cancel();
             }
           });
           for await (const chunk of result) {
-            await stream6.write(JSON.stringify(chunk) + "");
+            await stream7.write(JSON.stringify(chunk) + "");
           }
         } catch (err) {
           logger2.error("Error in message/stream stream: " + err?.message);
@@ -1187,7 +1188,7 @@ var authorizationMiddleware = async (c2, next) => {
 // src/server/handlers/client.ts
 var clients = /* @__PURE__ */ new Set();
 function handleClientsRefresh(c2) {
-  const stream6 = new ReadableStream({
+  const stream7 = new ReadableStream({
     start(controller) {
       clients.add(controller);
       controller.enqueue("data: connected\n\n");
@@ -1196,7 +1197,7 @@ function handleClientsRefresh(c2) {
       });
     }
   });
-  return new Response(stream6, {
+  return new Response(stream7, {
     headers: {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -1237,6 +1238,853 @@ function errorHandler(err, c2, isDev) {
 async function rootHandler(c2) {
   return c2.text("Hello to the Mastra API!");
 }
+async function getAgentBuilderActionsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actions = await getAgentBuilderActionsHandler$1({
+      mastra
+    });
+    return c2.json(actions);
+  } catch (error) {
+    return handleError(error, "Error getting agent builder actions");
+  }
+}
+async function getAgentBuilderActionByIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actionId = c2.req.param("actionId");
+    const action = await getAgentBuilderActionByIdHandler$1({
+      mastra,
+      actionId
+    });
+    return c2.json(action);
+  } catch (error) {
+    return handleError(error, "Error getting agent builder action by ID");
+  }
+}
+async function createAgentBuilderActionRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.query("runId");
+    const result = await createAgentBuilderActionRunHandler$1({
+      mastra,
+      actionId,
+      runId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error creating agent builder action run");
+  }
+}
+async function startAsyncAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const actionId = c2.req.param("actionId");
+    const { inputData } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    const result = await startAsyncAgentBuilderActionHandler$1({
+      mastra,
+      runtimeContext,
+      actionId,
+      runId,
+      inputData
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error starting async agent builder action");
+  }
+}
+async function startAgentBuilderActionRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const actionId = c2.req.param("actionId");
+    const { inputData } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    const result = await startAgentBuilderActionRunHandler$1({
+      mastra,
+      runtimeContext,
+      actionId,
+      runId,
+      inputData
+    });
+    return c2.json(result);
+  } 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 (stream7) => {
+      try {
+        const result = await watchAgentBuilderActionHandler$1({
+          mastra,
+          actionId,
+          runId,
+          eventType
+        });
+        const reader = result.getReader();
+        stream7.onAbort(() => {
+          void reader.cancel("request aborted");
+        });
+        let chunkResult;
+        while ((chunkResult = await reader.read()) && !chunkResult.done) {
+          await stream7.write(JSON.stringify(chunkResult.value) + "");
+        }
+      } catch (err) {
+        logger2.error("Error in watch stream: " + (err?.message ?? "Unknown error"));
+      }
+    });
+  } catch (error) {
+    return handleError(error, "Error watching agent builder action");
+  }
+}
+async function streamAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const logger2 = mastra.getLogger();
+    const actionId = c2.req.param("actionId");
+    const { inputData } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    c2.header("Transfer-Encoding", "chunked");
+    return stream(
+      c2,
+      async (stream7) => {
+        try {
+          const result = await streamAgentBuilderActionHandler$1({
+            mastra,
+            actionId,
+            runId,
+            inputData,
+            runtimeContext
+          });
+          const reader = result.stream.getReader();
+          stream7.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
+          }
+        } catch (err) {
+          logger2.error("Error in action stream: " + (err?.message ?? "Unknown error"));
+        }
+        await stream7.close();
+      },
+      async (err) => {
+        logger2.error("Error in action stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error streaming agent builder action");
+  }
+}
+async function streamVNextAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const logger2 = mastra.getLogger();
+    const actionId = c2.req.param("actionId");
+    const { inputData } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    c2.header("Transfer-Encoding", "chunked");
+    return stream(
+      c2,
+      async (stream7) => {
+        try {
+          const result = await streamVNextAgentBuilderActionHandler$1({
+            mastra,
+            actionId,
+            runId,
+            inputData,
+            runtimeContext
+          });
+          const reader = result.getReader();
+          stream7.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
+          }
+        } catch (err) {
+          logger2.error("Error in action VNext stream: " + (err?.message ?? "Unknown error"));
+        }
+      },
+      async (err) => {
+        logger2.error("Error in action VNext stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error streaming VNext agent builder action");
+  }
+}
+async function resumeAsyncAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.query("runId");
+    const { step, resumeData } = await c2.req.json();
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to resume action" });
+    }
+    const result = await resumeAsyncAgentBuilderActionHandler$1({
+      mastra,
+      runtimeContext,
+      actionId,
+      runId,
+      body: { step, resumeData }
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error resuming async agent builder action");
+  }
+}
+async function resumeAgentBuilderActionHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.query("runId");
+    const { step, resumeData } = await c2.req.json();
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to resume action" });
+    }
+    await resumeAgentBuilderActionHandler$1({
+      mastra,
+      runtimeContext,
+      actionId,
+      runId,
+      body: { step, resumeData }
+    });
+    return c2.json({ message: "Action run resumed" });
+  } catch (error) {
+    return handleError(error, "Error resuming agent builder action");
+  }
+}
+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 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,
+      resourceId
+    });
+    return c2.json(runs);
+  } catch (error) {
+    return handleError(error, "Error getting agent builder action runs");
+  }
+}
+async function getAgentBuilderActionRunByIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.param("runId");
+    const run = await getAgentBuilderActionRunByIdHandler$1({
+      mastra,
+      actionId,
+      runId
+    });
+    return c2.json(run);
+  } catch (error) {
+    return handleError(error, "Error getting agent builder action run by ID");
+  }
+}
+async function getAgentBuilderActionRunExecutionResultHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.param("runId");
+    const result = await getAgentBuilderActionRunExecutionResultHandler$1({
+      mastra,
+      actionId,
+      runId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting agent builder action run execution result");
+  }
+}
+async function cancelAgentBuilderActionRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const actionId = c2.req.param("actionId");
+    const runId = c2.req.param("runId");
+    const result = await cancelAgentBuilderActionRunHandler$1({
+      mastra,
+      actionId,
+      runId
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error cancelling agent builder action run");
+  }
+}
+async function sendAgentBuilderActionRunEventHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    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
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error sending agent builder action run event");
+  }
+}
+
+// src/server/handlers/routes/agent-builder/router.ts
+function agentBuilderRouter(bodyLimitOptions) {
+  const router = new Hono();
+  router.get(
+    "/",
+    w({
+      description: "Get all agent builder actions",
+      tags: ["agent-builder"],
+      responses: {
+        200: {
+          description: "List of all agent builder actions"
+        }
+      }
+    }),
+    getAgentBuilderActionsHandler
+  );
+  router.get(
+    "/:actionId",
+    w({
+      description: "Get agent builder action by ID",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Agent builder action details"
+        },
+        404: {
+          description: "Agent builder action not found"
+        }
+      }
+    }),
+    getAgentBuilderActionByIdHandler
+  );
+  router.get(
+    "/:actionId/runs",
+    w({
+      description: "Get all runs for an agent builder action",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          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 agent builder action runs from storage"
+        }
+      }
+    }),
+    getAgentBuilderActionRunsHandler
+  );
+  router.get(
+    "/:actionId/runs/:runId/execution-result",
+    w({
+      description: "Get execution result for an agent builder action run",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Agent builder action run execution result"
+        },
+        404: {
+          description: "Agent builder action run execution result not found"
+        }
+      }
+    }),
+    getAgentBuilderActionRunExecutionResultHandler
+  );
+  router.get(
+    "/:actionId/runs/:runId",
+    w({
+      description: "Get agent builder action run by ID",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Agent builder action run by ID"
+        },
+        404: {
+          description: "Agent builder action run not found"
+        }
+      }
+    }),
+    getAgentBuilderActionRunByIdHandler
+  );
+  router.post(
+    "/:actionId/resume",
+    w({
+      description: "Resume a suspended agent builder action step",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          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: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                resumeData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the agent builder action execution"
+                }
+              },
+              required: ["step"]
+            }
+          }
+        }
+      }
+    }),
+    resumeAgentBuilderActionHandler
+  );
+  router.post(
+    "/:actionId/resume-async",
+    bodyLimit(bodyLimitOptions),
+    w({
+      description: "Resume a suspended agent builder action step",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          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: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                resumeData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the agent builder action execution"
+                }
+              },
+              required: ["step"]
+            }
+          }
+        }
+      }
+    }),
+    resumeAsyncAgentBuilderActionHandler
+  );
+  router.post(
+    "/:actionId/stream",
+    w({
+      description: "Stream agent builder action in real-time",
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the agent builder action execution"
+                }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "agent builder action run started"
+        },
+        404: {
+          description: "agent builder action not found"
+        }
+      },
+      tags: ["agent-builder"]
+    }),
+    streamAgentBuilderActionHandler
+  );
+  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: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the agent builder action execution"
+                }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "agent builder action run started"
+        },
+        404: {
+          description: "agent builder action not found"
+        }
+      },
+      tags: ["agent-builder"]
+    }),
+    streamVNextAgentBuilderActionHandler
+  );
+  router.post(
+    "/:actionId/create-run",
+    bodyLimit(bodyLimitOptions),
+    w({
+      description: "Create a new agent builder action run",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "New agent builder action run created"
+        }
+      }
+    }),
+    createAgentBuilderActionRunHandler
+  );
+  router.post(
+    "/:actionId/start-async",
+    bodyLimit(bodyLimitOptions),
+    w({
+      description: "Execute/Start an agent builder action",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the agent builder action execution"
+                }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "agent builder action execution result"
+        },
+        404: {
+          description: "agent builder action not found"
+        }
+      }
+    }),
+    startAsyncAgentBuilderActionHandler
+  );
+  router.post(
+    "/:actionId/start",
+    w({
+      description: "Create and start a new agent builder action run",
+      tags: ["agent-builder"],
+      parameters: [
+        {
+          name: "actionId",
+          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: {
+                inputData: { type: "object" },
+                runtimeContext: {
+                  type: "object",
+                  description: "Runtime context for the agent builder action execution"
+                }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "agent builder action run started"
+        },
+        404: {
+          description: "agent builder action not found"
+        }
+      }
+    }),
+    startAgentBuilderActionRunHandler
+  );
+  router.get(
+    "/:actionId/watch",
+    w({
+      description: "Watch agent builder action transitions in real-time",
+      parameters: [
+        {
+          name: "actionId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          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"
+        }
+      }
+    }),
+    watchAgentBuilderActionHandler
+  );
+  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 cancelled"
+        }
+      }
+    }),
+    cancelAgentBuilderActionRunHandler
+  );
+  router.post(
+    "/:actionId/runs/:runId/send-event",
+    w({
+      description: "Send an event to an agent builder action run",
+      parameters: [
+        {
+          name: "actionId",
+          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: ["agent-builder"],
+      responses: {
+        200: {
+          description: "agent builder action run event sent"
+        }
+      }
+    }),
+    sendAgentBuilderActionRunEventHandler
+  );
+  return router;
+}
 var AllowedProviderKeys = {
   openai: "OPENAI_API_KEY",
   xai: "XAI_API_KEY",
@@ -1338,6 +2186,24 @@ async function getLiveEvalsByAgentIdHandler(c2) {
   });
   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 body = await c2.req.json();
+    const result = await generateLegacyHandler$1({
+      mastra,
+      agentId,
+      runtimeContext,
+      body,
+      abortSignal: c2.req.raw.signal
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error generating from agent");
+  }
+}
 async function generateHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -1374,6 +2240,24 @@ async function generateVNextHandler(c2) {
     return handleError(error, "Error generating vnext from agent");
   }
 }
+async function streamGenerateLegacyHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const agentId = c2.req.param("agentId");
+    const runtimeContext = c2.get("runtimeContext");
+    const body = await c2.req.json();
+    const streamResponse = await streamGenerateLegacyHandler$1({
+      mastra,
+      agentId,
+      runtimeContext,
+      body,
+      abortSignal: c2.req.raw.signal
+    });
+    return streamResponse;
+  } catch (error) {
+    return handleError(error, "Error streaming from agent");
+  }
+}
 async function streamGenerateHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -1402,7 +2286,7 @@ async function streamVNextGenerateHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const streamResponse = await streamVNextGenerateHandler$1({
             mastra,
@@ -1412,20 +2296,20 @@ async function streamVNextGenerateHandler(c2) {
             abortSignal: c2.req.raw.signal
           });
           const reader = streamResponse.fullStream.getReader();
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(`data: ${JSON.stringify(chunkResult.value)}
+            await stream7.write(`data: ${JSON.stringify(chunkResult.value)}
 
 `);
           }
-          await stream6.write("data: [DONE]\n\n");
+          await stream7.write("data: [DONE]\n\n");
         } catch (err) {
           logger2.error("Error in streamVNext generate: " + (err?.message ?? "Unknown error"));
         }
-        await stream6.close();
+        await stream7.close();
       },
       async (err) => {
         logger2.error("Error in watch stream: " + err?.message);
@@ -1673,6 +2557,23 @@ function executeToolHandler(tools) {
     }
   };
 }
+async function getAgentToolHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const runtimeContext = c2.get("runtimeContext");
+    const agentId = c2.req.param("agentId");
+    const toolId = c2.req.param("toolId");
+    const result = await getAgentToolHandler$1({
+      mastra,
+      agentId,
+      toolId,
+      runtimeContext
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error getting agent tool");
+  }
+}
 async function executeAgentToolHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -1847,6 +2748,57 @@ function agentsRouter(bodyLimitOptions) {
     }),
     getLiveEvalsByAgentIdHandler
   );
+  router.post(
+    "/:agentId/generate-legacy",
+    bodyLimit(bodyLimitOptions),
+    w({
+      description: "Generate a response from an agent",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                messages: {
+                  type: "array",
+                  items: { type: "object" }
+                },
+                threadId: { type: "string" },
+                resourceId: { type: "string", description: "The resource ID for the conversation" },
+                resourceid: {
+                  type: "string",
+                  description: "The resource ID for the conversation (deprecated, use resourceId instead)",
+                  deprecated: true
+                },
+                runId: { type: "string" },
+                output: { type: "object" }
+              },
+              required: ["messages"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Generated response"
+        },
+        404: {
+          description: "Agent not found"
+        }
+      }
+    }),
+    generateLegacyHandler
+  );
   router.post(
     "/:agentId/generate",
     bodyLimit(bodyLimitOptions),
@@ -1972,6 +2924,57 @@ function agentsRouter(bodyLimitOptions) {
     }),
     streamVNextGenerateHandler
   );
+  router.post(
+    "/:agentId/stream-legacy",
+    bodyLimit(bodyLimitOptions),
+    w({
+      description: "Stream a response from an agent",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                messages: {
+                  type: "array",
+                  items: { type: "object" }
+                },
+                threadId: { type: "string" },
+                resourceId: { type: "string", description: "The resource ID for the conversation" },
+                resourceid: {
+                  type: "string",
+                  description: "The resource ID for the conversation (deprecated, use resourceId instead)",
+                  deprecated: true
+                },
+                runId: { type: "string" },
+                output: { type: "object" }
+              },
+              required: ["messages"]
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Streamed response"
+        },
+        404: {
+          description: "Agent not found"
+        }
+      }
+    }),
+    streamGenerateLegacyHandler
+  );
   router.post(
     "/:agentId/stream",
     bodyLimit(bodyLimitOptions),
@@ -2593,6 +3596,36 @@ function agentsRouter(bodyLimitOptions) {
     }),
     listenHandler
   );
+  router.get(
+    "/:agentId/tools/:toolId",
+    w({
+      description: "Get agent tool by ID",
+      tags: ["agents"],
+      parameters: [
+        {
+          name: "agentId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "toolId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Tool details"
+        },
+        404: {
+          description: "Tool or agent not found"
+        }
+      }
+    }),
+    getAgentToolHandler
+  );
   router.post(
     "/:agentId/tools/:toolId/execute",
     bodyLimit(bodyLimitOptions),
@@ -7023,7 +8056,7 @@ async function streamGenerateVNextNetworkHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await streamGenerateVNextNetworkHandler$1({
             mastra,
@@ -7032,12 +8065,12 @@ async function streamGenerateVNextNetworkHandler(c2) {
             body
           });
           const reader = result.stream.getReader();
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           mastra.getLogger().error("Error in network stream: " + (err?.message ?? "Unknown error"));
@@ -7078,7 +8111,7 @@ async function loopStreamVNextNetworkHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await loopStreamVNextNetworkHandler$1({
             mastra,
@@ -7087,12 +8120,12 @@ async function loopStreamVNextNetworkHandler(c2) {
             body
           });
           const reader = result.stream.getReader();
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           mastra.getLogger().error("Error in network loop stream: " + (err?.message ?? "Unknown error"));
@@ -8478,7 +9511,7 @@ function watchWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await watchWorkflowHandler$1({
             mastra,
@@ -8486,12 +9519,12 @@ function watchWorkflowHandler(c2) {
             runId
           });
           const reader = result.getReader();
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           logger2.error("Error in watch stream: " + (err?.message ?? "Unknown error"));
@@ -8516,7 +9549,7 @@ async function streamWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await streamWorkflowHandler$1({
             mastra,
@@ -8526,17 +9559,17 @@ async function streamWorkflowHandler(c2) {
             runtimeContext
           });
           const reader = result.stream.getReader();
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           logger2.error("Error in workflow stream: " + (err?.message ?? "Unknown error"));
         }
-        await stream6.close();
+        await stream7.close();
       },
       async (err) => {
         logger2.error("Error in workflow stream: " + err?.message);
@@ -8557,7 +9590,7 @@ async function streamVNextWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await streamVNextWorkflowHandler$1({
             mastra,
@@ -8567,12 +9600,12 @@ async function streamVNextWorkflowHandler(c2) {
             runtimeContext
           });
           const reader = result.getReader();
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             void reader.cancel("request aborted");
           });
           let chunkResult;
           while ((chunkResult = await reader.read()) && !chunkResult.done) {
-            await stream6.write(JSON.stringify(chunkResult.value) + "");
+            await stream7.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
           logger2.error("Error in workflow VNext stream: " + (err?.message ?? "Unknown error"));
@@ -8800,20 +9833,20 @@ function watchLegacyWorkflowHandler(c2) {
     }
     return stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await watchLegacyWorkflowHandler$1({
             mastra,
             workflowId,
             runId
           });
-          stream6.onAbort(() => {
+          stream7.onAbort(() => {
             if (!result.locked) {
               return result.cancel();
             }
           });
           for await (const chunk of result) {
-            await stream6.write(chunk.toString() + "");
+            await stream7.write(chunk.toString() + "");
           }
         } catch (err) {
           console.log(err);
@@ -10113,6 +11146,7 @@ async function createHonoServer(mastra, options = {
   app.route("/api/workflows", workflowsRouter(bodyLimitOptions));
   app.route("/api/logs", logsRouter());
   app.route("/api/scores", scoresRouter(bodyLimitOptions));
+  app.route("/api/agent-builder", agentBuilderRouter(bodyLimitOptions));
   app.route("/api/tools", toolsRouter(bodyLimitOptions, options.tools));
   app.route("/api/vector", vectorRouter(bodyLimitOptions));
   if (options?.isDev || server?.build?.openAPIDocs || server?.build?.swaggerUI) {