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

package/dist/server/index.cjs

@@ -21,8 +21,9 @@ var timeout = require('hono/timeout');
 var httpException = require('hono/http-exception');
 var a2a = require('@mastra/server/handlers/a2a');
 var streaming = require('hono/streaming');
-var agents = require('@mastra/server/handlers/agents');
 var bodyLimit = require('hono/body-limit');
+var agentBuilder = require('@mastra/server/handlers/agent-builder');
+var agents = require('@mastra/server/handlers/agents');
 var agent = require('@mastra/core/agent');
 var zod = require('zod');
 var tools$1 = require('@mastra/server/handlers/tools');
@@ -287,13 +288,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);
@@ -560,18 +561,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;
@@ -660,10 +661,10 @@ var serveStatic = (options = { root: "" }) => {
       end = size - 1;
     }
     const chunksize = end - start + 1;
-    const stream6 = fs.createReadStream(path$1, { start, end });
+    const stream7 = fs.createReadStream(path$1, { start, end });
     c2.header("Content-Length", chunksize.toString());
     c2.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-    return c2.body(createStreamBody(stream6), 206);
+    return c2.body(createStreamBody(stream7), 206);
   };
 };
 var RENDER_TYPE = {
@@ -961,15 +962,15 @@ async function getAgentExecutionHandler(c2) {
   if (body.method === "message/stream") {
     return streaming.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);
@@ -1169,80 +1170,927 @@ var authorizationMiddleware = async (c2, next) => {
       if (isAuthorized) {
         return next();
       }
-      return c2.json({ error: "Access denied" }, 403);
-    } catch (err) {
-      console.error(err);
-      return c2.json({ error: "Authorization error" }, 500);
-    }
-  }
-  if ("rules" in authConfig && authConfig.rules && authConfig.rules.length > 0) {
-    const isAuthorized = await checkRules(authConfig.rules, path, method, user);
-    if (isAuthorized) {
-      return next();
-    }
-    return c2.json({ error: "Access denied" }, 403);
-  }
-  if (defaultAuthConfig.rules && defaultAuthConfig.rules.length > 0) {
-    const isAuthorized = await checkRules(defaultAuthConfig.rules, path, method, user);
-    if (isAuthorized) {
-      return next();
-    }
-  }
-  return c2.json({ error: "Access denied" }, 403);
-};
-
-// src/server/handlers/client.ts
-var clients = /* @__PURE__ */ new Set();
-function handleClientsRefresh(c2) {
-  const stream6 = new ReadableStream({
-    start(controller) {
-      clients.add(controller);
-      controller.enqueue("data: connected\n\n");
-      c2.req.raw.signal.addEventListener("abort", () => {
-        clients.delete(controller);
-      });
-    }
-  });
-  return new Response(stream6, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-      "Access-Control-Allow-Origin": "*"
-    }
-  });
-}
-function handleTriggerClientsRefresh(c2) {
-  clients.forEach((controller) => {
-    try {
-      controller.enqueue("data: refresh\n\n");
-    } catch {
-      clients.delete(controller);
-    }
-  });
-  return c2.json({ success: true, clients: clients.size });
-}
-function handleError(error, defaultMessage) {
-  const apiError = error;
-  throw new httpException.HTTPException(apiError.status || 500, {
-    message: apiError.message || defaultMessage,
-    cause: apiError.cause
-  });
-}
-function errorHandler(err, c2, isDev) {
-  if (err instanceof httpException.HTTPException) {
-    if (isDev) {
-      return c2.json({ error: err.message, cause: err.cause, stack: err.stack }, err.status);
-    }
-    return c2.json({ error: err.message }, err.status);
-  }
-  console.error(err);
-  return c2.json({ error: "Internal Server Error" }, 500);
-}
-
-// src/server/handlers/root.ts
-async function rootHandler(c2) {
-  return c2.text("Hello to the Mastra API!");
+      return c2.json({ error: "Access denied" }, 403);
+    } catch (err) {
+      console.error(err);
+      return c2.json({ error: "Authorization error" }, 500);
+    }
+  }
+  if ("rules" in authConfig && authConfig.rules && authConfig.rules.length > 0) {
+    const isAuthorized = await checkRules(authConfig.rules, path, method, user);
+    if (isAuthorized) {
+      return next();
+    }
+    return c2.json({ error: "Access denied" }, 403);
+  }
+  if (defaultAuthConfig.rules && defaultAuthConfig.rules.length > 0) {
+    const isAuthorized = await checkRules(defaultAuthConfig.rules, path, method, user);
+    if (isAuthorized) {
+      return next();
+    }
+  }
+  return c2.json({ error: "Access denied" }, 403);
+};
+
+// src/server/handlers/client.ts
+var clients = /* @__PURE__ */ new Set();
+function handleClientsRefresh(c2) {
+  const stream7 = new ReadableStream({
+    start(controller) {
+      clients.add(controller);
+      controller.enqueue("data: connected\n\n");
+      c2.req.raw.signal.addEventListener("abort", () => {
+        clients.delete(controller);
+      });
+    }
+  });
+  return new Response(stream7, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "Access-Control-Allow-Origin": "*"
+    }
+  });
+}
+function handleTriggerClientsRefresh(c2) {
+  clients.forEach((controller) => {
+    try {
+      controller.enqueue("data: refresh\n\n");
+    } catch {
+      clients.delete(controller);
+    }
+  });
+  return c2.json({ success: true, clients: clients.size });
+}
+function handleError(error, defaultMessage) {
+  const apiError = error;
+  throw new httpException.HTTPException(apiError.status || 500, {
+    message: apiError.message || defaultMessage,
+    cause: apiError.cause
+  });
+}
+function errorHandler(err, c2, isDev) {
+  if (err instanceof httpException.HTTPException) {
+    if (isDev) {
+      return c2.json({ error: err.message, cause: err.cause, stack: err.stack }, err.status);
+    }
+    return c2.json({ error: err.message }, err.status);
+  }
+  console.error(err);
+  return c2.json({ error: "Internal Server Error" }, 500);
+}
+
+// src/server/handlers/root.ts
+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 agentBuilder.getAgentBuilderActionsHandler({
+      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 agentBuilder.getAgentBuilderActionByIdHandler({
+      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 agentBuilder.createAgentBuilderActionRunHandler({
+      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 agentBuilder.startAsyncAgentBuilderActionHandler({
+      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 agentBuilder.startAgentBuilderActionRunHandler({
+      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.HTTPException(400, { message: "runId required to watch action" });
+    }
+    c2.header("Transfer-Encoding", "chunked");
+    return streaming.stream(c2, async (stream7) => {
+      try {
+        const result = await agentBuilder.watchAgentBuilderActionHandler({
+          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 streaming.stream(
+      c2,
+      async (stream7) => {
+        try {
+          const result = await agentBuilder.streamAgentBuilderActionHandler({
+            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 streaming.stream(
+      c2,
+      async (stream7) => {
+        try {
+          const result = await agentBuilder.streamVNextAgentBuilderActionHandler({
+            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.HTTPException(400, { message: "runId required to resume action" });
+    }
+    const result = await agentBuilder.resumeAsyncAgentBuilderActionHandler({
+      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.HTTPException(400, { message: "runId required to resume action" });
+    }
+    await agentBuilder.resumeAgentBuilderActionHandler({
+      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 agentBuilder.getAgentBuilderActionRunsHandler({
+      mastra,
+      actionId,
+      fromDate: fromDate ? new Date(fromDate) : void 0,
+      toDate: toDate ? new Date(toDate) : void 0,
+      limit: limit ? Number(limit) : void 0,
+      offset: offset ? Number(offset) : void 0,
+      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 agentBuilder.getAgentBuilderActionRunByIdHandler({
+      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 agentBuilder.getAgentBuilderActionRunExecutionResultHandler({
+      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 agentBuilder.cancelAgentBuilderActionRunHandler({
+      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 agentBuilder.sendAgentBuilderActionRunEventHandler({
+      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.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.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.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.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",
@@ -1345,6 +2193,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 agents.generateLegacyHandler({
+      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");
@@ -1381,6 +2247,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 agents.streamGenerateLegacyHandler({
+      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");
@@ -1409,7 +2293,7 @@ async function streamVNextGenerateHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const streamResponse = await agents.streamVNextGenerateHandler({
             mastra,
@@ -1419,20 +2303,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);
@@ -1680,6 +2564,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 tools$1.getAgentToolHandler({
+      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");
@@ -1854,6 +2755,57 @@ function agentsRouter(bodyLimitOptions) {
     }),
     getLiveEvalsByAgentIdHandler
   );
+  router.post(
+    "/:agentId/generate-legacy",
+    bodyLimit.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.bodyLimit(bodyLimitOptions),
@@ -1979,6 +2931,57 @@ function agentsRouter(bodyLimitOptions) {
     }),
     streamVNextGenerateHandler
   );
+  router.post(
+    "/:agentId/stream-legacy",
+    bodyLimit.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.bodyLimit(bodyLimitOptions),
@@ -2600,6 +3603,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.bodyLimit(bodyLimitOptions),
@@ -7030,7 +8063,7 @@ async function streamGenerateVNextNetworkHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await vNextNetwork.streamGenerateVNextNetworkHandler({
             mastra,
@@ -7039,12 +8072,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"));
@@ -7085,7 +8118,7 @@ async function loopStreamVNextNetworkHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await vNextNetwork.loopStreamVNextNetworkHandler({
             mastra,
@@ -7094,12 +8127,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"));
@@ -8485,7 +9518,7 @@ function watchWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await workflows.watchWorkflowHandler({
             mastra,
@@ -8493,12 +9526,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"));
@@ -8523,7 +9556,7 @@ async function streamWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await workflows.streamWorkflowHandler({
             mastra,
@@ -8533,17 +9566,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);
@@ -8564,7 +9597,7 @@ async function streamVNextWorkflowHandler(c2) {
     c2.header("Transfer-Encoding", "chunked");
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await workflows.streamVNextWorkflowHandler({
             mastra,
@@ -8574,12 +9607,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"));
@@ -8807,20 +9840,20 @@ function watchLegacyWorkflowHandler(c2) {
     }
     return streaming.stream(
       c2,
-      async (stream6) => {
+      async (stream7) => {
         try {
           const result = await legacyWorkflows.watchLegacyWorkflowHandler({
             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);
@@ -10120,6 +11153,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) {