@mastra/server 0.0.0-fix-thread-list-20251105222841 → 0.0.0-fix-issue-10434-concurrent-write-corruption-20251124213939

package/dist/{chunk-QXWWLCTQ.js → chunk-BMKFP3XR.js}

@@ -1,15 +1,18 @@
+import { listWorkflowsResponseSchema, LIST_WORKFLOWS_ROUTE, workflowInfoSchema, GET_WORKFLOW_BY_ID_ROUTE, workflowRunsResponseSchema, listWorkflowRunsQuerySchema, LIST_WORKFLOW_RUNS_ROUTE, workflowRunResponseSchema, GET_WORKFLOW_RUN_BY_ID_ROUTE, workflowExecutionResultSchema, GET_WORKFLOW_RUN_EXECUTION_RESULT_ROUTE, createWorkflowRunResponseSchema, CREATE_WORKFLOW_RUN_ROUTE, streamWorkflowBodySchema, STREAM_WORKFLOW_ROUTE, STREAM_VNEXT_WORKFLOW_ROUTE, startAsyncWorkflowBodySchema, START_ASYNC_WORKFLOW_ROUTE, workflowControlResponseSchema, START_WORKFLOW_RUN_ROUTE, OBSERVE_STREAM_WORKFLOW_ROUTE, OBSERVE_STREAM_VNEXT_WORKFLOW_ROUTE, resumeBodySchema, RESUME_ASYNC_WORKFLOW_ROUTE, RESUME_WORKFLOW_ROUTE, RESUME_STREAM_WORKFLOW_ROUTE, CANCEL_WORKFLOW_RUN_ROUTE, streamLegacyWorkflowBodySchema, STREAM_LEGACY_WORKFLOW_ROUTE, OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE } from './chunk-VIP2H47U.js';
 import { require_token_error } from './chunk-TOCYBDP2.js';
 import { openai } from './chunk-ZULZ2752.js';
 import { createIdGenerator, AISDKError, isAbortError, getErrorMessage, APICallError, delay, safeParseJSON, safeValidateTypes, convertAsyncIteratorToReadableStream, validatorSymbol } from './chunk-RQK4FQUD.js';
-import { getWorkflowByIdHandler, getWorkflowRunByIdHandler, getWorkflowRunExecutionResultHandler, createWorkflowRunHandler, startAsyncWorkflowHandler, startWorkflowRunHandler, streamWorkflowHandler, streamLegacyWorkflowHandler, streamVNextWorkflowHandler, observeStreamLegacyWorkflowHandler, observeStreamWorkflowHandler, observeStreamVNextWorkflowHandler, resumeAsyncWorkflowHandler, resumeWorkflowHandler, resumeStreamWorkflowHandler, listWorkflowRunsHandler, cancelWorkflowRunHandler } from './chunk-TWHS6DKL.js';
-import { WorkflowRegistry, getWorkflowInfo } from './chunk-DNUO33HF.js';
+import { WorkflowRegistry } from './chunk-G7BPNX2V.js';
+import { streamResponseSchema } from './chunk-R4M3BSUG.js';
+import { optionalRunIdSchema, runIdSchema } from './chunk-PKRHEXX7.js';
+import { createRoute } from './chunk-FAQICBMH.js';
 import { handleError } from './chunk-UXGQZUYZ.js';
 import { HTTPException } from './chunk-6QWQZI4Q.js';
 import { __commonJS, __export, __toESM } from './chunk-PR4QN5HX.js';
 import { Agent, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, MessageList } from '@mastra/core/agent';
 import { MastraMemory, MemoryProcessor } from '@mastra/core/memory';
 import { generateEmptyFromSchema } from '@mastra/core/utils';
-import { z, ZodObject, ZodFirstPartyTypeKind } from 'zod';
+import z19, { z, ZodObject, ZodFirstPartyTypeKind } from 'zod';
 import * as z42 from 'zod/v4';
 import { z as z$1 } from 'zod/v4';
 import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind$1 } from 'zod/v3';
@@ -716,24 +719,24 @@ var require_ignore = __commonJS({
 // src/server/handlers/agent-builder.ts
 var agent_builder_exports = {};
 __export(agent_builder_exports, {
-  cancelAgentBuilderActionRunHandler: () => cancelAgentBuilderActionRunHandler,
-  createAgentBuilderActionRunHandler: () => createAgentBuilderActionRunHandler,
-  getAgentBuilderActionByIdHandler: () => getAgentBuilderActionByIdHandler,
-  getAgentBuilderActionRunByIdHandler: () => getAgentBuilderActionRunByIdHandler,
-  getAgentBuilderActionRunExecutionResultHandler: () => getAgentBuilderActionRunExecutionResultHandler,
-  getAgentBuilderActionRunsHandler: () => getAgentBuilderActionRunsHandler,
-  getAgentBuilderActionsHandler: () => getAgentBuilderActionsHandler,
-  observeStreamAgentBuilderActionHandler: () => observeStreamAgentBuilderActionHandler,
-  observeStreamLegacyAgentBuilderActionHandler: () => observeStreamLegacyAgentBuilderActionHandler,
-  observeStreamVNextAgentBuilderActionHandler: () => observeStreamVNextAgentBuilderActionHandler,
-  resumeAgentBuilderActionHandler: () => resumeAgentBuilderActionHandler,
-  resumeAsyncAgentBuilderActionHandler: () => resumeAsyncAgentBuilderActionHandler,
-  resumeStreamAgentBuilderActionHandler: () => resumeStreamAgentBuilderActionHandler,
-  startAgentBuilderActionRunHandler: () => startAgentBuilderActionRunHandler,
-  startAsyncAgentBuilderActionHandler: () => startAsyncAgentBuilderActionHandler,
-  streamAgentBuilderActionHandler: () => streamAgentBuilderActionHandler,
-  streamLegacyAgentBuilderActionHandler: () => streamLegacyAgentBuilderActionHandler,
-  streamVNextAgentBuilderActionHandler: () => streamVNextAgentBuilderActionHandler
+  CANCEL_AGENT_BUILDER_ACTION_RUN_ROUTE: () => CANCEL_AGENT_BUILDER_ACTION_RUN_ROUTE,
+  CREATE_AGENT_BUILDER_ACTION_RUN_ROUTE: () => CREATE_AGENT_BUILDER_ACTION_RUN_ROUTE,
+  GET_AGENT_BUILDER_ACTION_BY_ID_ROUTE: () => GET_AGENT_BUILDER_ACTION_BY_ID_ROUTE,
+  GET_AGENT_BUILDER_ACTION_RUN_BY_ID_ROUTE: () => GET_AGENT_BUILDER_ACTION_RUN_BY_ID_ROUTE,
+  GET_AGENT_BUILDER_ACTION_RUN_EXECUTION_RESULT_ROUTE: () => GET_AGENT_BUILDER_ACTION_RUN_EXECUTION_RESULT_ROUTE,
+  LIST_AGENT_BUILDER_ACTIONS_ROUTE: () => LIST_AGENT_BUILDER_ACTIONS_ROUTE,
+  LIST_AGENT_BUILDER_ACTION_RUNS_ROUTE: () => LIST_AGENT_BUILDER_ACTION_RUNS_ROUTE,
+  OBSERVE_STREAM_AGENT_BUILDER_ACTION_ROUTE: () => OBSERVE_STREAM_AGENT_BUILDER_ACTION_ROUTE,
+  OBSERVE_STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE: () => OBSERVE_STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE,
+  OBSERVE_STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE: () => OBSERVE_STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE,
+  RESUME_AGENT_BUILDER_ACTION_ROUTE: () => RESUME_AGENT_BUILDER_ACTION_ROUTE,
+  RESUME_ASYNC_AGENT_BUILDER_ACTION_ROUTE: () => RESUME_ASYNC_AGENT_BUILDER_ACTION_ROUTE,
+  RESUME_STREAM_AGENT_BUILDER_ACTION_ROUTE: () => RESUME_STREAM_AGENT_BUILDER_ACTION_ROUTE,
+  START_AGENT_BUILDER_ACTION_RUN_ROUTE: () => START_AGENT_BUILDER_ACTION_RUN_ROUTE,
+  START_ASYNC_AGENT_BUILDER_ACTION_ROUTE: () => START_ASYNC_AGENT_BUILDER_ACTION_ROUTE,
+  STREAM_AGENT_BUILDER_ACTION_ROUTE: () => STREAM_AGENT_BUILDER_ACTION_ROUTE,
+  STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE: () => STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE,
+  STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE: () => STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE
 });
 
 // ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Options.js
@@ -13808,7 +13811,7 @@ var updateWorkingMemoryTool = (memoryConfig) => {
     execute: async (inputData, context) => {
       const threadId = context?.agent?.threadId;
       const resourceId = context?.agent?.resourceId;
-      const memory = context?.mastra?.memory || context?.memory;
+      const memory = context?.memory;
       if (!threadId || !memory || !resourceId) {
         throw new Error("Thread ID, Memory instance, and resourceId are required for working memory updates");
       }
@@ -13852,7 +13855,7 @@ var __experimental_updateWorkingMemoryToolVNext = (config) => {
     execute: async (inputData, context) => {
       const threadId = context?.agent?.threadId;
       const resourceId = context?.agent?.resourceId;
-      const memory = context?.mastra?.memory || context?.memory;
+      const memory = context?.memory;
       if (!threadId || !memory || !resourceId) {
         throw new Error("Thread ID, Memory instance, and resourceId are required for working memory updates");
       }
@@ -17725,6 +17728,7 @@ export const weatherAgent = new Agent({
   tools: { weatherTool },
   memory: new Memory({
     storage: new LibSQLStore({
+      id: 'mastra-memory-storage',
       url: 'file:../mastra.db', // ask user what database to use, use this as the default
     }),
   }),
@@ -17892,6 +17896,7 @@ export const mastra = new Mastra({
   workflows: { weatherWorkflow },
   agents: { weatherAgent },
   storage: new LibSQLStore({
+    id: 'mastra-storage',
     // stores observability, evals, ... into memory storage, if it needs to persist, change to file:../mastra.db
     url: ":memory:",
   }),
@@ -19997,6 +20002,7 @@ var AgentBuilder = class extends Agent {
 ${config.instructions}` : "";
     const combinedInstructions = additionalInstructions + AgentBuilderDefaults.DEFAULT_INSTRUCTIONS(config.projectPath);
     const agentConfig = {
+      id: "agent-builder",
       name: "agent-builder",
       description: "An AI agent specialized in generating Mastra agents, tools, and workflows from natural language requirements.",
       instructions: combinedInstructions,
@@ -21863,6 +21869,7 @@ var planningIterationStep = createStep({
     try {
       const model = await resolveModel({ requestContext });
       const planningAgent = new Agent({
+        id: "workflow-planning-agent",
         model,
         instructions: taskPlanningPrompts.planningAgent.instructions({
           storedQAPairs
@@ -22201,7 +22208,7 @@ export const mastra = new Mastra({
     sendEmailWorkflow,      // Use camelCase for keys
     dataProcessingWorkflow
   },
-  storage: new LibSQLStore({ url: 'file:./mastra.db' }), // Required for suspend/resume
+  storage: new LibSQLStore({ id: 'mastra-storage', url: 'file:./mastra.db' }), // Required for suspend/resume
 });
 \`\`\`
 
@@ -22589,6 +22596,7 @@ var workflowResearchStep = createStep({
     try {
       const model = await resolveModel({ requestContext });
       const researchAgent = new Agent({
+        id: "workflow-research-agent",
         model,
         instructions: workflowBuilderPrompts.researchAgent.instructions,
         name: "Workflow Research Agent"
@@ -22909,12 +22917,53 @@ var agentBuilderWorkflows = {
   "merge-template": agentBuilderTemplateWorkflow,
   "workflow-builder": workflowBuilderWorkflow
 };
+var actionIdPathParams = z19.object({
+  actionId: z19.string().describe("Unique identifier for the agent-builder action")
+});
+var actionRunPathParams = z19.object({
+  actionId: z19.string().describe("Unique identifier for the agent-builder action"),
+  runId: z19.string().describe("Unique identifier for the action run")
+});
+var streamAgentBuilderBodySchema = streamWorkflowBodySchema;
+var streamLegacyAgentBuilderBodySchema = streamLegacyWorkflowBodySchema;
+var resumeAgentBuilderBodySchema = resumeBodySchema;
+var startAsyncAgentBuilderBodySchema = startAsyncWorkflowBodySchema;
 
 // src/server/handlers/agent-builder.ts
-function createAgentBuilderWorkflowHandler(workflowHandlerFn, logMessage) {
-  return async (builderArgs) => {
-    const { actionId, ...actionArgs } = builderArgs;
-    const mastra = actionArgs.mastra;
+var LIST_AGENT_BUILDER_ACTIONS_ROUTE = createRoute({
+  method: "GET",
+  path: "/api/agent-builder",
+  responseType: "json",
+  responseSchema: listWorkflowsResponseSchema,
+  summary: "List agent-builder actions",
+  description: "Returns a list of all available agent-builder actions",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      logger.info("Listing agent builder actions");
+      return await LIST_WORKFLOWS_ROUTE.handler(ctx);
+    } catch (error) {
+      logger.error("Error listing agent builder actions", { error });
+      return handleError(error, "Error getting agent builder workflows");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var GET_AGENT_BUILDER_ACTION_BY_ID_ROUTE = createRoute({
+  method: "GET",
+  path: "/api/agent-builder/:actionId",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  responseSchema: workflowInfoSchema,
+  summary: "Get action by ID",
+  description: "Returns details for a specific agent-builder action",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId } = ctx;
     const logger = mastra.getLogger();
     try {
       WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
@@ -22923,112 +22972,526 @@ function createAgentBuilderWorkflowHandler(workflowHandlerFn, logMessage) {
           message: `Invalid agent-builder action: ${actionId}. Valid actions are: ${Object.keys(agentBuilderWorkflows).join(", ")}`
         });
       }
-      logger.info(logMessage, { actionId, ...actionArgs });
-      try {
-        const handlerArgs = {
-          ...actionArgs,
-          workflowId: actionId
-          // Map actionId to workflowId
-        };
-        const result = await workflowHandlerFn(handlerArgs);
-        return result;
-      } finally {
-        WorkflowRegistry.cleanup();
+      logger.info("Getting agent builder action by ID", { actionId });
+      return await GET_WORKFLOW_BY_ID_ROUTE.handler({ ...ctx, workflowId: actionId });
+    } catch (error) {
+      logger.error("Error getting agent builder action by ID", { error, actionId });
+      return handleError(error, "Error getting agent builder action");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var LIST_AGENT_BUILDER_ACTION_RUNS_ROUTE = createRoute({
+  method: "GET",
+  path: "/api/agent-builder/:actionId/runs",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: listWorkflowRunsQuerySchema,
+  responseSchema: workflowRunsResponseSchema,
+  summary: "List action runs",
+  description: "Returns a paginated list of execution runs for the specified action",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
       }
+      logger.info("Listing agent builder action runs", { actionId });
+      return await LIST_WORKFLOW_RUNS_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error(`${logMessage} failed`, {
-        error: errorMessage,
-        stack: error instanceof Error ? error.stack : void 0
+      logger.error("Error listing agent builder action runs", { error, actionId });
+      return handleError(error, "Error getting agent builder action runs");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var GET_AGENT_BUILDER_ACTION_RUN_BY_ID_ROUTE = createRoute({
+  method: "GET",
+  path: "/api/agent-builder/:actionId/runs/:runId",
+  responseType: "json",
+  pathParamSchema: actionRunPathParams,
+  responseSchema: workflowRunResponseSchema,
+  summary: "Get action run by ID",
+  description: "Returns details for a specific action run",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Getting agent builder action run by ID", { actionId, runId });
+      return await GET_WORKFLOW_RUN_BY_ID_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
       });
-      throw error;
+    } catch (error) {
+      logger.error("Error getting agent builder action run", { error, actionId, runId });
+      return handleError(error, "Error getting agent builder action run");
+    } finally {
+      WorkflowRegistry.cleanup();
     }
-  };
-}
-var getAgentBuilderActionsHandler = createAgentBuilderWorkflowHandler(async () => {
-  try {
-    const registryWorkflows = WorkflowRegistry.getAllWorkflows();
-    const _workflows = Object.entries(registryWorkflows).reduce(
-      (acc, [key, workflow]) => {
-        acc[key] = getWorkflowInfo(workflow);
-        return acc;
-      },
-      {}
-    );
-    return _workflows;
-  } catch (error) {
-    return handleError(error, "Error getting agent builder workflows");
   }
-}, "Getting agent builder actions");
-var getAgentBuilderActionByIdHandler = createAgentBuilderWorkflowHandler(
-  getWorkflowByIdHandler,
-  "Getting agent builder action by ID"
-);
-var getAgentBuilderActionRunByIdHandler = createAgentBuilderWorkflowHandler(
-  getWorkflowRunByIdHandler,
-  "Getting agent builder action run by ID"
-);
-var getAgentBuilderActionRunExecutionResultHandler = createAgentBuilderWorkflowHandler(
-  getWorkflowRunExecutionResultHandler,
-  "Getting agent builder action run execution result"
-);
-var createAgentBuilderActionRunHandler = createAgentBuilderWorkflowHandler(
-  createWorkflowRunHandler,
-  "Creating agent builder action run"
-);
-var startAsyncAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  startAsyncWorkflowHandler,
-  "Starting async agent builder action"
-);
-var startAgentBuilderActionRunHandler = createAgentBuilderWorkflowHandler(
-  startWorkflowRunHandler,
-  "Starting agent builder action run"
-);
-var streamAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  streamWorkflowHandler,
-  "Streaming agent builder action"
-);
-var streamLegacyAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  streamLegacyWorkflowHandler,
-  "Streaming legacy agent builder action"
-);
-var streamVNextAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  streamVNextWorkflowHandler,
-  "Streaming VNext agent builder action"
-);
-var observeStreamLegacyAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  observeStreamLegacyWorkflowHandler,
-  "Observing legacy stream for agent builder action"
-);
-var observeStreamAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  observeStreamWorkflowHandler,
-  "Observing stream for agent builder action"
-);
-var observeStreamVNextAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  observeStreamVNextWorkflowHandler,
-  "Observing VNext stream for agent builder action"
-);
-var resumeAsyncAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  resumeAsyncWorkflowHandler,
-  "Resuming async agent builder action"
-);
-var resumeAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  resumeWorkflowHandler,
-  "Resuming agent builder action"
-);
-var resumeStreamAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  resumeStreamWorkflowHandler,
-  "Resuming stream for agent builder action"
-);
-var getAgentBuilderActionRunsHandler = createAgentBuilderWorkflowHandler(
-  listWorkflowRunsHandler,
-  "Getting agent builder action runs"
-);
-var cancelAgentBuilderActionRunHandler = createAgentBuilderWorkflowHandler(
-  cancelWorkflowRunHandler,
-  "Cancelling agent builder action run"
-);
+});
+var GET_AGENT_BUILDER_ACTION_RUN_EXECUTION_RESULT_ROUTE = createRoute({
+  method: "GET",
+  path: "/api/agent-builder/:actionId/runs/:runId/execution-result",
+  responseType: "json",
+  pathParamSchema: actionRunPathParams,
+  responseSchema: workflowExecutionResultSchema,
+  summary: "Get action execution result",
+  description: "Returns the final execution result of a completed action run",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Getting agent builder action run execution result", { actionId, runId });
+      return await GET_WORKFLOW_RUN_EXECUTION_RESULT_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error getting execution result", { error, actionId, runId });
+      return handleError(error, "Error getting agent builder action execution result");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var CREATE_AGENT_BUILDER_ACTION_RUN_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/create-run",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: optionalRunIdSchema,
+  responseSchema: createWorkflowRunResponseSchema,
+  summary: "Create action run",
+  description: "Creates a new action execution instance with an optional custom run ID",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Creating agent builder action run", { actionId, runId });
+      return await CREATE_WORKFLOW_RUN_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error creating agent builder action run", { error, actionId });
+      return handleError(error, "Error creating agent builder action run");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var STREAM_AGENT_BUILDER_ACTION_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/stream",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: runIdSchema,
+  bodySchema: streamAgentBuilderBodySchema,
+  responseSchema: streamResponseSchema,
+  summary: "Stream action execution",
+  description: "Executes an action and streams the results in real-time",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Streaming agent builder action", { actionId, runId });
+      return await STREAM_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error streaming agent builder action", { error, actionId });
+      return handleError(error, "Error streaming agent builder action");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/streamVNext",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: runIdSchema,
+  bodySchema: streamAgentBuilderBodySchema,
+  responseSchema: streamResponseSchema,
+  summary: "Stream action execution (v2)",
+  description: "Executes an action using the v2 streaming API and streams the results in real-time",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Streaming agent builder action (v2)", { actionId, runId });
+      return await STREAM_VNEXT_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error streaming agent builder action (v2)", { error, actionId });
+      return handleError(error, "Error streaming agent builder action");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var START_ASYNC_AGENT_BUILDER_ACTION_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/start-async",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: optionalRunIdSchema,
+  bodySchema: startAsyncAgentBuilderBodySchema,
+  responseSchema: workflowExecutionResultSchema,
+  summary: "Start action asynchronously",
+  description: "Starts an action execution asynchronously without streaming results",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Starting agent builder action asynchronously", { actionId, runId });
+      return await START_ASYNC_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error starting agent builder action asynchronously", { error, actionId });
+      return handleError(error, "Error starting agent builder action");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var START_AGENT_BUILDER_ACTION_RUN_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/start",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: runIdSchema,
+  bodySchema: startAsyncAgentBuilderBodySchema,
+  responseSchema: workflowControlResponseSchema,
+  summary: "Start specific action run",
+  description: "Starts execution of a specific action run by ID",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Starting specific agent builder action run", { actionId, runId });
+      return await START_WORKFLOW_RUN_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error starting agent builder action run", { error, actionId });
+      return handleError(error, "Error starting agent builder action run");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var OBSERVE_STREAM_AGENT_BUILDER_ACTION_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/observe",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: runIdSchema,
+  responseSchema: streamResponseSchema,
+  summary: "Observe action stream",
+  description: "Observes and streams updates from an already running action execution",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Observing agent builder action stream", { actionId, runId });
+      return await OBSERVE_STREAM_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error observing agent builder action stream", { error, actionId });
+      return handleError(error, "Error observing agent builder action stream");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var OBSERVE_STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/observe-streamVNext",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: runIdSchema,
+  responseSchema: streamResponseSchema,
+  summary: "Observe action stream (v2)",
+  description: "Observes and streams updates from an already running action execution using v2 streaming API",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Observing agent builder action stream (v2)", { actionId, runId });
+      return await OBSERVE_STREAM_VNEXT_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error observing agent builder action stream (v2)", { error, actionId });
+      return handleError(error, "Error observing agent builder action stream");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var RESUME_ASYNC_AGENT_BUILDER_ACTION_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/resume-async",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: runIdSchema,
+  bodySchema: resumeAgentBuilderBodySchema,
+  responseSchema: workflowExecutionResultSchema,
+  summary: "Resume action asynchronously",
+  description: "Resumes a suspended action execution asynchronously without streaming",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, step, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Resuming agent builder action asynchronously", { actionId, runId, step });
+      return await RESUME_ASYNC_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error resuming agent builder action asynchronously", { error, actionId });
+      return handleError(error, "Error resuming agent builder action");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var RESUME_AGENT_BUILDER_ACTION_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/resume",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: runIdSchema,
+  bodySchema: resumeAgentBuilderBodySchema,
+  responseSchema: workflowControlResponseSchema,
+  summary: "Resume action",
+  description: "Resumes a suspended action execution from a specific step",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, step, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Resuming agent builder action", { actionId, runId, step });
+      return await RESUME_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error resuming agent builder action", { error, actionId });
+      return handleError(error, "Error resuming agent builder action");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var RESUME_STREAM_AGENT_BUILDER_ACTION_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/resume-stream",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: runIdSchema,
+  bodySchema: resumeAgentBuilderBodySchema,
+  responseSchema: streamResponseSchema,
+  summary: "Resume action stream",
+  description: "Resumes a suspended action execution and continues streaming results",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, step, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Resuming agent builder action stream", { actionId, runId, step });
+      return await RESUME_STREAM_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error resuming agent builder action stream", { error, actionId });
+      return handleError(error, "Error resuming agent builder action stream");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var CANCEL_AGENT_BUILDER_ACTION_RUN_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/runs/:runId/cancel",
+  responseType: "json",
+  pathParamSchema: actionRunPathParams,
+  responseSchema: workflowControlResponseSchema,
+  summary: "Cancel action run",
+  description: "Cancels an in-progress action execution",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Cancelling agent builder action run", { actionId, runId });
+      return await CANCEL_WORKFLOW_RUN_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error cancelling agent builder action run", { error, actionId });
+      return handleError(error, "Error cancelling agent builder action run");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/stream-legacy",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: runIdSchema,
+  bodySchema: streamLegacyAgentBuilderBodySchema,
+  responseSchema: streamResponseSchema,
+  summary: "[DEPRECATED] Stream agent-builder action with legacy format",
+  description: "Legacy endpoint for streaming agent-builder action execution. Use /api/agent-builder/:actionId/stream instead.",
+  tags: ["Agent Builder", "Legacy"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Streaming agent builder action (legacy)", { actionId, runId });
+      return await STREAM_LEGACY_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error streaming agent builder action (legacy)", { error, actionId });
+      return handleError(error, "Error streaming agent builder action");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
+var OBSERVE_STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/observe-stream-legacy",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: runIdSchema,
+  responseSchema: streamResponseSchema,
+  summary: "[DEPRECATED] Observe agent-builder action stream with legacy format",
+  description: "Legacy endpoint for observing agent-builder action stream. Use /api/agent-builder/:actionId/observe instead.",
+  tags: ["Agent Builder", "Legacy"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Observing agent builder action stream (legacy)", { actionId, runId });
+      return await OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error observing agent builder action stream (legacy)", { error, actionId });
+      return handleError(error, "Error observing agent builder action stream");
+    } finally {
+      WorkflowRegistry.cleanup();
+    }
+  }
+});
 
-export { agent_builder_exports, cancelAgentBuilderActionRunHandler, createAgentBuilderActionRunHandler, getAgentBuilderActionByIdHandler, getAgentBuilderActionRunByIdHandler, getAgentBuilderActionRunExecutionResultHandler, getAgentBuilderActionRunsHandler, getAgentBuilderActionsHandler, observeStreamAgentBuilderActionHandler, observeStreamLegacyAgentBuilderActionHandler, observeStreamVNextAgentBuilderActionHandler, resumeAgentBuilderActionHandler, resumeAsyncAgentBuilderActionHandler, resumeStreamAgentBuilderActionHandler, startAgentBuilderActionRunHandler, startAsyncAgentBuilderActionHandler, streamAgentBuilderActionHandler, streamLegacyAgentBuilderActionHandler, streamVNextAgentBuilderActionHandler };
-//# sourceMappingURL=chunk-QXWWLCTQ.js.map
-//# sourceMappingURL=chunk-QXWWLCTQ.js.map
+export { CANCEL_AGENT_BUILDER_ACTION_RUN_ROUTE, CREATE_AGENT_BUILDER_ACTION_RUN_ROUTE, GET_AGENT_BUILDER_ACTION_BY_ID_ROUTE, GET_AGENT_BUILDER_ACTION_RUN_BY_ID_ROUTE, GET_AGENT_BUILDER_ACTION_RUN_EXECUTION_RESULT_ROUTE, LIST_AGENT_BUILDER_ACTIONS_ROUTE, LIST_AGENT_BUILDER_ACTION_RUNS_ROUTE, OBSERVE_STREAM_AGENT_BUILDER_ACTION_ROUTE, OBSERVE_STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE, OBSERVE_STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE, RESUME_AGENT_BUILDER_ACTION_ROUTE, RESUME_ASYNC_AGENT_BUILDER_ACTION_ROUTE, RESUME_STREAM_AGENT_BUILDER_ACTION_ROUTE, START_AGENT_BUILDER_ACTION_RUN_ROUTE, START_ASYNC_AGENT_BUILDER_ACTION_ROUTE, STREAM_AGENT_BUILDER_ACTION_ROUTE, STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE, STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE, agent_builder_exports };
+//# sourceMappingURL=chunk-BMKFP3XR.js.map
+//# sourceMappingURL=chunk-BMKFP3XR.js.map