@mastra/server 0.0.0-tool-call-parts-20250630193309 → 0.0.0-transpile-packages-20250730132657

package/dist/{chunk-72LOJGUV.js → chunk-T7HAZC2E.js}

@@ -1,12 +1,13 @@
-import { stringify, esm_default } from './chunk-MEGCYGBU.js';
-import { handleError } from './chunk-M5ABIP7D.js';
-import { HTTPException } from './chunk-NYN7KFXL.js';
+import { stringify, esm_default } from './chunk-36BLNJHS.js';
+import { handleError } from './chunk-LF7P5PLR.js';
+import { HTTPException } from './chunk-LCM566I4.js';
 import { __export } from './chunk-MLKGABMK.js';
 import { ReadableStream } from 'stream/web';
 
 // src/server/handlers/workflows.ts
 var workflows_exports = {};
 __export(workflows_exports, {
+  cancelWorkflowRunHandler: () => cancelWorkflowRunHandler,
   createWorkflowRunHandler: () => createWorkflowRunHandler,
   getWorkflowByIdHandler: () => getWorkflowByIdHandler,
   getWorkflowRunByIdHandler: () => getWorkflowRunByIdHandler,
@@ -15,11 +16,32 @@ __export(workflows_exports, {
   getWorkflowsHandler: () => getWorkflowsHandler,
   resumeAsyncWorkflowHandler: () => resumeAsyncWorkflowHandler,
   resumeWorkflowHandler: () => resumeWorkflowHandler,
+  sendWorkflowRunEventHandler: () => sendWorkflowRunEventHandler,
   startAsyncWorkflowHandler: () => startAsyncWorkflowHandler,
   startWorkflowRunHandler: () => startWorkflowRunHandler,
+  streamVNextWorkflowHandler: () => streamVNextWorkflowHandler,
   streamWorkflowHandler: () => streamWorkflowHandler,
   watchWorkflowHandler: () => watchWorkflowHandler
 });
+function getSteps(steps, path) {
+  return Object.entries(steps).reduce((acc, [key, step]) => {
+    const fullKey = path ? `${path}.${key}` : key;
+    acc[fullKey] = {
+      id: step.id,
+      description: step.description,
+      inputSchema: step.inputSchema ? stringify(esm_default(step.inputSchema)) : void 0,
+      outputSchema: step.outputSchema ? stringify(esm_default(step.outputSchema)) : void 0,
+      resumeSchema: step.resumeSchema ? stringify(esm_default(step.resumeSchema)) : void 0,
+      suspendSchema: step.suspendSchema ? stringify(esm_default(step.suspendSchema)) : void 0,
+      isWorkflow: step.component === "WORKFLOW"
+    };
+    if (step.component === "WORKFLOW" && step.steps) {
+      const nestedSteps = getSteps(step.steps, fullKey) || {};
+      acc = { ...acc, ...nestedSteps };
+    }
+    return acc;
+  }, {});
+}
 async function getWorkflowsHandler({ mastra }) {
   try {
     const workflows = mastra.getWorkflows({ serialized: false });
@@ -38,6 +60,7 @@ async function getWorkflowsHandler({ mastra }) {
           };
           return acc2;
         }, {}),
+        allSteps: getSteps(workflow.steps) || {},
         stepGraph: workflow.serializedStepGraph,
         inputSchema: workflow.inputSchema ? stringify(esm_default(workflow.inputSchema)) : void 0,
         outputSchema: workflow.outputSchema ? stringify(esm_default(workflow.outputSchema)) : void 0
@@ -46,7 +69,7 @@ async function getWorkflowsHandler({ mastra }) {
     }, {});
     return _workflows;
   } catch (error) {
-    throw new HTTPException(500, { message: error?.message || "Error getting workflows" });
+    return handleError(error, "Error getting workflows");
   }
 }
 async function getWorkflowsFromSystem({ mastra, workflowId }) {
@@ -104,6 +127,7 @@ async function getWorkflowByIdHandler({ mastra, workflowId }) {
         };
         return acc;
       }, {}),
+      allSteps: getSteps(workflow.steps) || {},
       name: workflow.name,
       description: workflow.description,
       stepGraph: workflow.serializedStepGraph,
@@ -111,7 +135,7 @@ async function getWorkflowByIdHandler({ mastra, workflowId }) {
       outputSchema: workflow.outputSchema ? stringify(esm_default(workflow.outputSchema)) : void 0
     };
   } catch (error) {
-    throw new HTTPException(500, { message: error?.message || "Error getting workflow" });
+    return handleError(error, "Error getting workflow");
   }
 }
 async function getWorkflowRunByIdHandler({
@@ -136,7 +160,7 @@ async function getWorkflowRunByIdHandler({
     }
     return run;
   } catch (error) {
-    throw new HTTPException(500, { message: error?.message || "Error getting workflow run" });
+    return handleError(error, "Error getting workflow run");
   }
 }
 async function getWorkflowRunExecutionResultHandler({
@@ -161,9 +185,7 @@ async function getWorkflowRunExecutionResultHandler({
     }
     return executionResult;
   } catch (error) {
-    throw new HTTPException(500, {
-      message: error?.message || "Error getting workflow run execution result"
-    });
+    return handleError(error, "Error getting workflow run execution result");
   }
 }
 async function createWorkflowRunHandler({
@@ -182,7 +204,7 @@ async function createWorkflowRunHandler({
     const run = await workflow.createRunAsync({ runId: prevRunId });
     return { runId: run.runId };
   } catch (error) {
-    throw new HTTPException(500, { message: error?.message || "Error creating workflow run" });
+    return handleError(error, "Error creating workflow run");
   }
 }
 async function startAsyncWorkflowHandler({
@@ -207,7 +229,7 @@ async function startAsyncWorkflowHandler({
     });
     return result;
   } catch (error) {
-    throw new HTTPException(500, { message: error?.message || "Error executing workflow" });
+    return handleError(error, "Error starting async workflow");
   }
 }
 async function startWorkflowRunHandler({
@@ -319,6 +341,34 @@ async function streamWorkflowHandler({
     return handleError(error, "Error executing workflow");
   }
 }
+async function streamVNextWorkflowHandler({
+  mastra,
+  runtimeContext,
+  workflowId,
+  runId,
+  inputData
+}) {
+  try {
+    if (!workflowId) {
+      throw new HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to stream workflow" });
+    }
+    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    if (!workflow) {
+      throw new HTTPException(404, { message: "Workflow not found" });
+    }
+    const run = await workflow.createRunAsync({ runId });
+    const result = run.streamVNext({
+      inputData,
+      runtimeContext
+    });
+    return result;
+  } catch (error) {
+    return handleError(error, "Error streaming workflow");
+  }
+}
 async function resumeAsyncWorkflowHandler({
   mastra,
   workflowId,
@@ -417,5 +467,61 @@ async function getWorkflowRunsHandler({
     return handleError(error, "Error getting workflow runs");
   }
 }
+async function cancelWorkflowRunHandler({
+  mastra,
+  workflowId,
+  runId
+}) {
+  try {
+    if (!workflowId) {
+      throw new HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to cancel workflow run" });
+    }
+    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    if (!workflow) {
+      throw new HTTPException(404, { message: "Workflow not found" });
+    }
+    const run = await workflow.getWorkflowRunById(runId);
+    if (!run) {
+      throw new HTTPException(404, { message: "Workflow run not found" });
+    }
+    const _run = await workflow.createRunAsync({ runId });
+    await _run.cancel();
+    return { message: "Workflow run cancelled" };
+  } catch (error) {
+    return handleError(error, "Error canceling workflow run");
+  }
+}
+async function sendWorkflowRunEventHandler({
+  mastra,
+  workflowId,
+  runId,
+  event,
+  data
+}) {
+  try {
+    if (!workflowId) {
+      throw new HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to send workflow run event" });
+    }
+    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    if (!workflow) {
+      throw new HTTPException(404, { message: "Workflow not found" });
+    }
+    const run = await workflow.getWorkflowRunById(runId);
+    if (!run) {
+      throw new HTTPException(404, { message: "Workflow run not found" });
+    }
+    const _run = await workflow.createRunAsync({ runId });
+    await _run.sendEvent(event, data);
+    return { message: "Workflow run event sent" };
+  } catch (error) {
+    return handleError(error, "Error sending workflow run event");
+  }
+}
 
-export { createWorkflowRunHandler, getWorkflowByIdHandler, getWorkflowRunByIdHandler, getWorkflowRunExecutionResultHandler, getWorkflowRunsHandler, getWorkflowsHandler, resumeAsyncWorkflowHandler, resumeWorkflowHandler, startAsyncWorkflowHandler, startWorkflowRunHandler, streamWorkflowHandler, watchWorkflowHandler, workflows_exports };
+export { cancelWorkflowRunHandler, createWorkflowRunHandler, getWorkflowByIdHandler, getWorkflowRunByIdHandler, getWorkflowRunExecutionResultHandler, getWorkflowRunsHandler, getWorkflowsHandler, resumeAsyncWorkflowHandler, resumeWorkflowHandler, sendWorkflowRunEventHandler, startAsyncWorkflowHandler, startWorkflowRunHandler, streamVNextWorkflowHandler, streamWorkflowHandler, watchWorkflowHandler, workflows_exports };