@mastra/server 0.0.0-playground-studio-cloud-20251031080052 → 0.0.0-playground-studio-again-20251114102707

package/dist/{chunk-B7QWVGQQ.cjs → chunk-X3MICMI2.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunkCJFKRVED_cjs = require('./chunk-CJFKRVED.cjs');
-var chunkRE4RPXT2_cjs = require('./chunk-RE4RPXT2.cjs');
-var chunk7NADHFD2_cjs = require('./chunk-7NADHFD2.cjs');
+var chunkW2KMU354_cjs = require('./chunk-W2KMU354.cjs');
+var chunkV5WWQN7P_cjs = require('./chunk-V5WWQN7P.cjs');
+var chunk64ITUOXI_cjs = require('./chunk-64ITUOXI.cjs');
 var chunkO7I5CWRX_cjs = require('./chunk-O7I5CWRX.cjs');
 var web = require('stream/web');
 
@@ -14,55 +14,53 @@ chunkO7I5CWRX_cjs.__export(workflows_exports, {
   getWorkflowByIdHandler: () => getWorkflowByIdHandler,
   getWorkflowRunByIdHandler: () => getWorkflowRunByIdHandler,
   getWorkflowRunExecutionResultHandler: () => getWorkflowRunExecutionResultHandler,
-  getWorkflowRunsHandler: () => getWorkflowRunsHandler,
-  getWorkflowsHandler: () => getWorkflowsHandler,
+  listWorkflowRunsHandler: () => listWorkflowRunsHandler,
+  listWorkflowsHandler: () => listWorkflowsHandler,
   observeStreamLegacyWorkflowHandler: () => observeStreamLegacyWorkflowHandler,
   observeStreamVNextWorkflowHandler: () => observeStreamVNextWorkflowHandler,
   observeStreamWorkflowHandler: () => observeStreamWorkflowHandler,
   resumeAsyncWorkflowHandler: () => resumeAsyncWorkflowHandler,
   resumeStreamWorkflowHandler: () => resumeStreamWorkflowHandler,
   resumeWorkflowHandler: () => resumeWorkflowHandler,
-  sendWorkflowRunEventHandler: () => sendWorkflowRunEventHandler,
   startAsyncWorkflowHandler: () => startAsyncWorkflowHandler,
   startWorkflowRunHandler: () => startWorkflowRunHandler,
   streamLegacyWorkflowHandler: () => streamLegacyWorkflowHandler,
   streamVNextWorkflowHandler: () => streamVNextWorkflowHandler,
-  streamWorkflowHandler: () => streamWorkflowHandler,
-  watchWorkflowHandler: () => watchWorkflowHandler
+  streamWorkflowHandler: () => streamWorkflowHandler
 });
-async function getWorkflowsHandler({ mastra }) {
+async function listWorkflowsHandler({ mastra }) {
   try {
-    const workflows = mastra.getWorkflows({ serialized: false });
+    const workflows = mastra.listWorkflows({ serialized: false });
     const _workflows = Object.entries(workflows).reduce((acc, [key, workflow]) => {
-      acc[key] = chunkCJFKRVED_cjs.getWorkflowInfo(workflow);
+      acc[key] = chunkW2KMU354_cjs.getWorkflowInfo(workflow);
       return acc;
     }, {});
     return _workflows;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting workflows");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error getting workflows");
   }
 }
-async function getWorkflowsFromSystem({ mastra, workflowId }) {
+async function listWorkflowsFromSystem({ mastra, workflowId }) {
   const logger = mastra.getLogger();
   if (!workflowId) {
-    throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
   }
   let workflow;
-  workflow = chunkCJFKRVED_cjs.WorkflowRegistry.getWorkflow(workflowId);
+  workflow = chunkW2KMU354_cjs.WorkflowRegistry.getWorkflow(workflowId);
   if (!workflow) {
     try {
-      workflow = mastra.getWorkflow(workflowId);
+      workflow = mastra.getWorkflowById(workflowId);
     } catch (error) {
       logger.debug("Error getting workflow, searching agents for workflow", error);
     }
   }
   if (!workflow) {
     logger.debug("Workflow not found, searching agents for workflow", { workflowId });
-    const agents = mastra.getAgents();
+    const agents = mastra.listAgents();
     if (Object.keys(agents || {}).length) {
       for (const [_, agent] of Object.entries(agents)) {
         try {
-          const workflows = await agent.getWorkflows();
+          const workflows = await agent.listWorkflows();
           if (workflows[workflowId]) {
             workflow = workflows[workflowId];
             break;
@@ -75,22 +73,22 @@ async function getWorkflowsFromSystem({ mastra, workflowId }) {
     }
   }
   if (!workflow) {
-    throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+    throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
   }
   return { workflow };
 }
 async function getWorkflowByIdHandler({ mastra, workflowId }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
-    return chunkCJFKRVED_cjs.getWorkflowInfo(workflow);
+    return chunkW2KMU354_cjs.getWorkflowInfo(workflow);
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting workflow");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error getting workflow");
   }
 }
 async function getWorkflowRunByIdHandler({
@@ -100,22 +98,22 @@ async function getWorkflowRunByIdHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Run ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Run ID is required" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow run not found" });
     }
     return run;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting workflow run");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error getting workflow run");
   }
 }
 async function getWorkflowRunExecutionResultHandler({
@@ -125,22 +123,22 @@ async function getWorkflowRunExecutionResultHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Run ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Run ID is required" });
     }
     const workflow = mastra.getWorkflow(workflowId);
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const executionResult = await workflow.getWorkflowRunExecutionResult(runId);
     if (!executionResult) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow run execution result not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow run execution result not found" });
     }
     return executionResult;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting workflow run execution result");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error getting workflow run execution result");
   }
 }
 async function createWorkflowRunHandler({
@@ -150,21 +148,21 @@ async function createWorkflowRunHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
-    const run = await workflow.createRunAsync({ runId: prevRunId });
+    const run = await workflow.createRun({ runId: prevRunId });
     return { runId: run.runId };
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error creating workflow run");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error creating workflow run");
   }
 }
 async function startAsyncWorkflowHandler({
   mastra,
-  runtimeContext,
+  requestContext,
   workflowId,
   runId,
   inputData,
@@ -172,26 +170,26 @@ async function startAsyncWorkflowHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
-    const _run = await workflow.createRunAsync({ runId });
+    const _run = await workflow.createRun({ runId });
     const result = await _run.start({
       inputData,
-      runtimeContext,
+      requestContext,
       tracingOptions
     });
     return result;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error starting async workflow");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error starting async workflow");
   }
 }
 async function startWorkflowRunHandler({
   mastra,
-  runtimeContext,
+  requestContext,
   workflowId,
   runId,
   inputData,
@@ -199,116 +197,43 @@ async function startWorkflowRunHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "runId required to start run" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "runId required to start run" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow run not found" });
     }
-    const _run = await workflow.createRunAsync({ runId, resourceId: run.resourceId });
+    const _run = await workflow.createRun({ runId, resourceId: run.resourceId });
     void _run.start({
       inputData,
-      runtimeContext,
+      requestContext,
       tracingOptions
     });
     return { message: "Workflow run started" };
   } catch (e) {
-    return chunkRE4RPXT2_cjs.handleError(e, "Error starting workflow run");
-  }
-}
-async function watchWorkflowHandler({
-  mastra,
-  workflowId,
-  runId,
-  eventType = "watch"
-}) {
-  try {
-    if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
-    }
-    if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "runId required to watch workflow" });
-    }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
-    if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
-    }
-    const run = await workflow.getWorkflowRunById(runId);
-    if (!run) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow run not found" });
-    }
-    const _run = await workflow.createRunAsync({ runId, resourceId: run.resourceId });
-    let unwatch;
-    let asyncRef = null;
-    const stream = new web.ReadableStream({
-      start(controller) {
-        if (eventType === "watch") {
-          unwatch = _run.watch((event) => {
-            const { type, payload, eventTimestamp } = event;
-            controller.enqueue(JSON.stringify({ type, payload, eventTimestamp, runId }));
-            if (asyncRef) {
-              clearImmediate(asyncRef);
-              asyncRef = null;
-            }
-            asyncRef = setImmediate(async () => {
-              const runDone = payload.workflowState?.status !== "running";
-              if (runDone) {
-                controller.close();
-                unwatch?.();
-              }
-            });
-          }, eventType);
-        } else {
-          unwatch = _run.watch((event) => {
-            const { type, payload } = event;
-            controller.enqueue(JSON.stringify({ type, payload, runId }));
-            if (asyncRef) {
-              clearImmediate(asyncRef);
-              asyncRef = null;
-            }
-            asyncRef = setImmediate(async () => {
-              const runDone = type === "workflow-finish";
-              if (runDone) {
-                controller.close();
-                unwatch?.();
-              }
-            });
-          }, eventType);
-        }
-      },
-      cancel() {
-        if (asyncRef) {
-          clearImmediate(asyncRef);
-          asyncRef = null;
-        }
-        unwatch?.();
-      }
-    });
-    return stream;
-  } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error watching workflow");
+    return chunkV5WWQN7P_cjs.handleError(e, "Error starting workflow run");
   }
 }
 async function streamWorkflowHandler({
   mastra,
-  runtimeContext,
+  requestContext,
   workflowId,
   runId,
   inputData,
   tracingOptions
 }) {
-  return streamVNextWorkflowHandler({ mastra, workflowId, runId, inputData, runtimeContext, tracingOptions });
+  return streamVNextWorkflowHandler({ mastra, workflowId, runId, inputData, requestContext, tracingOptions });
 }
 async function streamLegacyWorkflowHandler({
   mastra,
-  runtimeContext,
+  requestContext,
   workflowId,
   runId,
   inputData,
@@ -316,20 +241,20 @@ async function streamLegacyWorkflowHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "runId required to resume workflow" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "runId required to resume workflow" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const serverCache = mastra.getServerCache();
-    const run = await workflow.createRunAsync({ runId });
+    const run = await workflow.createRun({ runId });
     const result = run.streamLegacy({
       inputData,
-      runtimeContext,
+      requestContext,
       onChunk: async (chunk) => {
         if (serverCache) {
           const cacheKey = runId;
@@ -340,7 +265,7 @@ async function streamLegacyWorkflowHandler({
     });
     return result;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error executing workflow");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error executing workflow");
   }
 }
 async function observeStreamLegacyWorkflowHandler({
@@ -350,23 +275,23 @@ async function observeStreamLegacyWorkflowHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "runId required to observe workflow stream" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "runId required to observe workflow stream" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow run not found" });
     }
-    const _run = await workflow.createRunAsync({ runId, resourceId: run.resourceId });
+    const _run = await workflow.createRun({ runId, resourceId: run.resourceId });
     const serverCache = mastra.getServerCache();
     if (!serverCache) {
-      throw new chunk7NADHFD2_cjs.HTTPException(500, { message: "Server cache not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Server cache not found" });
     }
     const transformStream = new web.TransformStream();
     const writer = transformStream.writable.getWriter();
@@ -378,7 +303,7 @@ async function observeStreamLegacyWorkflowHandler({
     const result = _run.observeStreamLegacy();
     return result.stream?.pipeThrough(transformStream);
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error observing workflow stream");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error observing workflow stream");
   }
 }
 async function observeStreamWorkflowHandler({
@@ -390,7 +315,7 @@ async function observeStreamWorkflowHandler({
 }
 async function streamVNextWorkflowHandler({
   mastra,
-  runtimeContext,
+  requestContext,
   workflowId,
   runId,
   inputData,
@@ -399,20 +324,20 @@ async function streamVNextWorkflowHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "runId required to stream workflow" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "runId required to stream workflow" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const serverCache = mastra.getServerCache();
-    const run = await workflow.createRunAsync({ runId });
+    const run = await workflow.createRun({ runId });
     const result = run.stream({
       inputData,
-      runtimeContext,
+      requestContext,
       closeOnSuspend,
       tracingOptions
     });
@@ -429,7 +354,7 @@ async function streamVNextWorkflowHandler({
       })
     );
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error streaming workflow");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error streaming workflow");
   }
 }
 async function observeStreamVNextWorkflowHandler({
@@ -439,23 +364,23 @@ async function observeStreamVNextWorkflowHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "runId required to observe workflow stream" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "runId required to observe workflow stream" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow run not found" });
     }
-    const _run = await workflow.createRunAsync({ runId, resourceId: run.resourceId });
+    const _run = await workflow.createRun({ runId, resourceId: run.resourceId });
     const serverCache = mastra.getServerCache();
     if (!serverCache) {
-      throw new chunk7NADHFD2_cjs.HTTPException(500, { message: "Server cache not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Server cache not found" });
     }
     const cachedRunChunks = await serverCache.listFromTo(runId, 0);
     const combinedStream = new web.ReadableStream({
@@ -492,7 +417,7 @@ async function observeStreamVNextWorkflowHandler({
     });
     return combinedStream;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error observing workflow stream");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error observing workflow stream");
   }
 }
 async function resumeAsyncWorkflowHandler({
@@ -500,37 +425,34 @@ async function resumeAsyncWorkflowHandler({
   workflowId,
   runId,
   body,
-  runtimeContext,
+  requestContext,
   tracingOptions
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "runId required to resume workflow" });
-    }
-    if (!body.step) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "step required to resume workflow" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "runId required to resume workflow" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow run not found" });
     }
-    const _run = await workflow.createRunAsync({ runId, resourceId: run.resourceId });
+    const _run = await workflow.createRun({ runId, resourceId: run.resourceId });
     const result = await _run.resume({
       step: body.step,
       resumeData: body.resumeData,
-      runtimeContext,
+      requestContext,
       tracingOptions
     });
     return result;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error resuming workflow step");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error resuming workflow step");
   }
 }
 async function resumeWorkflowHandler({
@@ -538,37 +460,34 @@ async function resumeWorkflowHandler({
   workflowId,
   runId,
   body,
-  runtimeContext,
+  requestContext,
   tracingOptions
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "runId required to resume workflow" });
-    }
-    if (!body.step) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "step required to resume workflow" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "runId required to resume workflow" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow run not found" });
     }
-    const _run = await workflow.createRunAsync({ runId, resourceId: run.resourceId });
+    const _run = await workflow.createRun({ runId, resourceId: run.resourceId });
     void _run.resume({
       step: body.step,
       resumeData: body.resumeData,
-      runtimeContext,
+      requestContext,
       tracingOptions
     });
     return { message: "Workflow run resumed" };
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error resuming workflow");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error resuming workflow");
   }
 }
 async function resumeStreamWorkflowHandler({
@@ -576,33 +495,30 @@ async function resumeStreamWorkflowHandler({
   workflowId,
   runId,
   body,
-  runtimeContext,
+  requestContext,
   tracingOptions
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "runId required to resume workflow" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "runId required to resume workflow" });
     }
-    if (!body.step) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "step required to resume workflow" });
-    }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow run not found" });
     }
-    const _run = await workflow.createRunAsync({ runId, resourceId: run.resourceId });
+    const _run = await workflow.createRun({ runId, resourceId: run.resourceId });
     const serverCache = mastra.getServerCache();
     const stream = _run.resumeStream({
       step: body.step,
       resumeData: body.resumeData,
-      runtimeContext,
+      requestContext,
       tracingOptions
     }).fullStream.pipeThrough(
       new web.TransformStream({
@@ -618,33 +534,39 @@ async function resumeStreamWorkflowHandler({
     );
     return stream;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error resuming workflow");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error resuming workflow");
   }
 }
-async function getWorkflowRunsHandler({
+async function listWorkflowRunsHandler({
   mastra,
   workflowId,
   fromDate,
   toDate,
-  limit,
-  offset,
+  perPage,
+  page,
   resourceId
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (perPage !== void 0 && perPage !== false && (!Number.isInteger(perPage) || perPage <= 0)) {
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "perPage must be a positive integer or false" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    if (page !== void 0 && (!Number.isInteger(page) || page < 0)) {
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "page must be a non-negative integer" });
+    }
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
-    const workflowRuns = await workflow.getWorkflowRuns({ fromDate, toDate, limit, offset, resourceId }) || {
+    const workflowRuns = await workflow.listWorkflowRuns({ fromDate, toDate, perPage, page, resourceId }) || {
       runs: [],
       total: 0
     };
     return workflowRuns;
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error getting workflow runs");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error getting workflow runs");
   }
 }
 async function cancelWorkflowRunHandler({
@@ -654,53 +576,24 @@ async function cancelWorkflowRunHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "runId required to cancel workflow run" });
+      throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "runId required to cancel workflow run" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk64ITUOXI_cjs.HTTPException(404, { message: "Workflow run not found" });
     }
-    const _run = await workflow.createRunAsync({ runId, resourceId: run.resourceId });
+    const _run = await workflow.createRun({ runId, resourceId: run.resourceId });
     await _run.cancel();
     return { message: "Workflow run cancelled" };
   } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error canceling workflow run");
-  }
-}
-async function sendWorkflowRunEventHandler({
-  mastra,
-  workflowId,
-  runId,
-  event,
-  data
-}) {
-  try {
-    if (!workflowId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "Workflow ID is required" });
-    }
-    if (!runId) {
-      throw new chunk7NADHFD2_cjs.HTTPException(400, { message: "runId required to send workflow run event" });
-    }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
-    if (!workflow) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow not found" });
-    }
-    const run = await workflow.getWorkflowRunById(runId);
-    if (!run) {
-      throw new chunk7NADHFD2_cjs.HTTPException(404, { message: "Workflow run not found" });
-    }
-    const _run = await workflow.createRunAsync({ runId, resourceId: run.resourceId });
-    await _run.sendEvent(event, data);
-    return { message: "Workflow run event sent" };
-  } catch (error) {
-    return chunkRE4RPXT2_cjs.handleError(error, "Error sending workflow run event");
+    return chunkV5WWQN7P_cjs.handleError(error, "Error canceling workflow run");
   }
 }
 
@@ -709,21 +602,19 @@ exports.createWorkflowRunHandler = createWorkflowRunHandler;
 exports.getWorkflowByIdHandler = getWorkflowByIdHandler;
 exports.getWorkflowRunByIdHandler = getWorkflowRunByIdHandler;
 exports.getWorkflowRunExecutionResultHandler = getWorkflowRunExecutionResultHandler;
-exports.getWorkflowRunsHandler = getWorkflowRunsHandler;
-exports.getWorkflowsHandler = getWorkflowsHandler;
+exports.listWorkflowRunsHandler = listWorkflowRunsHandler;
+exports.listWorkflowsHandler = listWorkflowsHandler;
 exports.observeStreamLegacyWorkflowHandler = observeStreamLegacyWorkflowHandler;
 exports.observeStreamVNextWorkflowHandler = observeStreamVNextWorkflowHandler;
 exports.observeStreamWorkflowHandler = observeStreamWorkflowHandler;
 exports.resumeAsyncWorkflowHandler = resumeAsyncWorkflowHandler;
 exports.resumeStreamWorkflowHandler = resumeStreamWorkflowHandler;
 exports.resumeWorkflowHandler = resumeWorkflowHandler;
-exports.sendWorkflowRunEventHandler = sendWorkflowRunEventHandler;
 exports.startAsyncWorkflowHandler = startAsyncWorkflowHandler;
 exports.startWorkflowRunHandler = startWorkflowRunHandler;
 exports.streamLegacyWorkflowHandler = streamLegacyWorkflowHandler;
 exports.streamVNextWorkflowHandler = streamVNextWorkflowHandler;
 exports.streamWorkflowHandler = streamWorkflowHandler;
-exports.watchWorkflowHandler = watchWorkflowHandler;
 exports.workflows_exports = workflows_exports;
-//# sourceMappingURL=chunk-B7QWVGQQ.cjs.map
-//# sourceMappingURL=chunk-B7QWVGQQ.cjs.map
+//# sourceMappingURL=chunk-X3MICMI2.cjs.map
+//# sourceMappingURL=chunk-X3MICMI2.cjs.map