@mastra/server 0.0.0-error-handler-fix-20251020202607 → 0.0.0-export-agent-memory-from-local-studio-20251112153946

package/dist/{chunk-DB63UMTV.js → chunk-ZJ6KEY6H.js}

@@ -1,8 +1,8 @@
-import { getWorkflowInfo, WorkflowRegistry } from './chunk-YWOK4F5A.js';
-import { handleError } from './chunk-CY4TP3FK.js';
-import { HTTPException } from './chunk-MMROOK5J.js';
+import { getWorkflowInfo, WorkflowRegistry } from './chunk-D7T74TVR.js';
+import { handleError } from './chunk-UXGQZUYZ.js';
+import { HTTPException } from './chunk-6QWQZI4Q.js';
 import { __export } from './chunk-PR4QN5HX.js';
-import { ReadableStream, TransformStream } from 'stream/web';
+import { TransformStream, ReadableStream } from 'stream/web';
 
 // src/server/handlers/workflows.ts
 var workflows_exports = {};
@@ -12,23 +12,23 @@ __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] = getWorkflowInfo(workflow);
       return acc;
@@ -38,7 +38,7 @@ async function getWorkflowsHandler({ mastra }) {
     return handleError(error, "Error getting workflows");
   }
 }
-async function getWorkflowsFromSystem({ mastra, workflowId }) {
+async function listWorkflowsFromSystem({ mastra, workflowId }) {
   const logger = mastra.getLogger();
   if (!workflowId) {
     throw new HTTPException(400, { message: "Workflow ID is required" });
@@ -47,18 +47,18 @@ async function getWorkflowsFromSystem({ mastra, workflowId }) {
   workflow = 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;
@@ -80,7 +80,7 @@ async function getWorkflowByIdHandler({ mastra, workflowId }) {
     if (!workflowId) {
       throw new HTTPException(400, { message: "Workflow ID is required" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
       throw new HTTPException(404, { message: "Workflow not found" });
     }
@@ -101,7 +101,7 @@ async function getWorkflowRunByIdHandler({
     if (!runId) {
       throw new HTTPException(400, { message: "Run ID is required" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
       throw new HTTPException(404, { message: "Workflow not found" });
     }
@@ -148,11 +148,11 @@ async function createWorkflowRunHandler({
     if (!workflowId) {
       throw new HTTPException(400, { message: "Workflow ID is required" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
       throw new 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 handleError(error, "Error creating workflow run");
@@ -160,7 +160,7 @@ async function createWorkflowRunHandler({
 }
 async function startAsyncWorkflowHandler({
   mastra,
-  runtimeContext,
+  requestContext,
   workflowId,
   runId,
   inputData,
@@ -170,14 +170,14 @@ async function startAsyncWorkflowHandler({
     if (!workflowId) {
       throw new HTTPException(400, { message: "Workflow ID is required" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
       throw new 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;
@@ -187,7 +187,7 @@ async function startAsyncWorkflowHandler({
 }
 async function startWorkflowRunHandler({
   mastra,
-  runtimeContext,
+  requestContext,
   workflowId,
   runId,
   inputData,
@@ -200,7 +200,7 @@ async function startWorkflowRunHandler({
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to start run" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
       throw new HTTPException(404, { message: "Workflow not found" });
     }
@@ -208,10 +208,10 @@ async function startWorkflowRunHandler({
     if (!run) {
       throw new 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" };
@@ -219,64 +219,19 @@ async function startWorkflowRunHandler({
     return handleError(e, "Error starting workflow run");
   }
 }
-async function watchWorkflowHandler({
+async function streamWorkflowHandler({
   mastra,
+  requestContext,
   workflowId,
   runId,
-  eventType = "watch"
+  inputData,
+  tracingOptions
 }) {
-  try {
-    if (!workflowId) {
-      throw new HTTPException(400, { message: "Workflow ID is required" });
-    }
-    if (!runId) {
-      throw new HTTPException(400, { message: "runId required to watch workflow" });
-    }
-    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, resourceId: run.resourceId });
-    let unwatch;
-    let asyncRef = null;
-    const stream = new ReadableStream({
-      start(controller) {
-        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 = eventType === "watch" ? payload.workflowState.status !== "running" : type === "finish";
-            if (runDone) {
-              controller.close();
-              unwatch?.();
-            }
-          });
-        }, eventType);
-      },
-      cancel() {
-        if (asyncRef) {
-          clearImmediate(asyncRef);
-          asyncRef = null;
-        }
-        unwatch?.();
-      }
-    });
-    return stream;
-  } catch (error) {
-    return handleError(error, "Error watching workflow");
-  }
+  return streamVNextWorkflowHandler({ mastra, workflowId, runId, inputData, requestContext, tracingOptions });
 }
-async function streamWorkflowHandler({
+async function streamLegacyWorkflowHandler({
   mastra,
-  runtimeContext,
+  requestContext,
   workflowId,
   runId,
   inputData,
@@ -289,15 +244,15 @@ async function streamWorkflowHandler({
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to resume workflow" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
       throw new HTTPException(404, { message: "Workflow not found" });
     }
     const serverCache = mastra.getServerCache();
-    const run = await workflow.createRunAsync({ runId });
-    const result = run.stream({
+    const run = await workflow.createRun({ runId });
+    const result = run.streamLegacy({
       inputData,
-      runtimeContext,
+      requestContext,
       onChunk: async (chunk) => {
         if (serverCache) {
           const cacheKey = runId;
@@ -311,7 +266,7 @@ async function streamWorkflowHandler({
     return handleError(error, "Error executing workflow");
   }
 }
-async function observeStreamWorkflowHandler({
+async function observeStreamLegacyWorkflowHandler({
   mastra,
   workflowId,
   runId
@@ -323,7 +278,7 @@ async function observeStreamWorkflowHandler({
     if (!runId) {
       throw new 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 HTTPException(404, { message: "Workflow not found" });
     }
@@ -331,7 +286,7 @@ async function observeStreamWorkflowHandler({
     if (!run) {
       throw new 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 HTTPException(500, { message: "Server cache not found" });
@@ -343,15 +298,22 @@ async function observeStreamWorkflowHandler({
       await writer.write(chunk);
     }
     writer.releaseLock();
-    const result = _run.observeStream();
+    const result = _run.observeStreamLegacy();
     return result.stream?.pipeThrough(transformStream);
   } catch (error) {
     return handleError(error, "Error observing workflow stream");
   }
 }
+async function observeStreamWorkflowHandler({
+  mastra,
+  workflowId,
+  runId
+}) {
+  return observeStreamVNextWorkflowHandler({ mastra, workflowId, runId });
+}
 async function streamVNextWorkflowHandler({
   mastra,
-  runtimeContext,
+  requestContext,
   workflowId,
   runId,
   inputData,
@@ -365,25 +327,30 @@ async function streamVNextWorkflowHandler({
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to stream workflow" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
       throw new HTTPException(404, { message: "Workflow not found" });
     }
     const serverCache = mastra.getServerCache();
-    const run = await workflow.createRunAsync({ runId });
-    const result = run.streamVNext({
+    const run = await workflow.createRun({ runId });
+    const result = run.stream({
       inputData,
-      runtimeContext,
+      requestContext,
       closeOnSuspend,
-      onChunk: async (chunk) => {
-        if (serverCache) {
-          const cacheKey = runId;
-          await serverCache.listPush(cacheKey, chunk);
-        }
-      },
       tracingOptions
     });
-    return result;
+    return result.fullStream.pipeThrough(
+      new TransformStream({
+        transform(chunk, controller) {
+          if (serverCache) {
+            const cacheKey = runId;
+            serverCache.listPush(cacheKey, chunk).catch(() => {
+            });
+          }
+          controller.enqueue(chunk);
+        }
+      })
+    );
   } catch (error) {
     return handleError(error, "Error streaming workflow");
   }
@@ -400,7 +367,7 @@ async function observeStreamVNextWorkflowHandler({
     if (!runId) {
       throw new 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 HTTPException(404, { message: "Workflow not found" });
     }
@@ -408,7 +375,7 @@ async function observeStreamVNextWorkflowHandler({
     if (!run) {
       throw new 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 HTTPException(500, { message: "Server cache not found" });
@@ -421,7 +388,7 @@ async function observeStreamVNextWorkflowHandler({
             controller.enqueue(chunk);
           }
         };
-        const liveStream = _run.observeStreamVNext();
+        const liveStream = _run.observeStream();
         const reader = liveStream.getReader();
         const pump = async () => {
           try {
@@ -456,7 +423,7 @@ async function resumeAsyncWorkflowHandler({
   workflowId,
   runId,
   body,
-  runtimeContext,
+  requestContext,
   tracingOptions
 }) {
   try {
@@ -466,10 +433,7 @@ async function resumeAsyncWorkflowHandler({
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to resume workflow" });
     }
-    if (!body.step) {
-      throw new HTTPException(400, { message: "step required to resume workflow" });
-    }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
       throw new HTTPException(404, { message: "Workflow not found" });
     }
@@ -477,11 +441,11 @@ async function resumeAsyncWorkflowHandler({
     if (!run) {
       throw new 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;
@@ -494,7 +458,7 @@ async function resumeWorkflowHandler({
   workflowId,
   runId,
   body,
-  runtimeContext,
+  requestContext,
   tracingOptions
 }) {
   try {
@@ -504,10 +468,7 @@ async function resumeWorkflowHandler({
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to resume workflow" });
     }
-    if (!body.step) {
-      throw new HTTPException(400, { message: "step required to resume workflow" });
-    }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
       throw new HTTPException(404, { message: "Workflow not found" });
     }
@@ -515,11 +476,11 @@ async function resumeWorkflowHandler({
     if (!run) {
       throw new 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" };
@@ -532,7 +493,7 @@ async function resumeStreamWorkflowHandler({
   workflowId,
   runId,
   body,
-  runtimeContext,
+  requestContext,
   tracingOptions
 }) {
   try {
@@ -542,10 +503,7 @@ async function resumeStreamWorkflowHandler({
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to resume workflow" });
     }
-    if (!body.step) {
-      throw new HTTPException(400, { message: "step required to resume workflow" });
-    }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
       throw new HTTPException(404, { message: "Workflow not found" });
     }
@@ -553,43 +511,54 @@ async function resumeStreamWorkflowHandler({
     if (!run) {
       throw new 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.resumeStreamVNext({
+    const stream = _run.resumeStream({
       step: body.step,
       resumeData: body.resumeData,
-      runtimeContext,
-      tracingOptions,
-      onChunk: async (chunk) => {
-        if (serverCache) {
-          const cacheKey = runId;
-          await serverCache.listPush(cacheKey, chunk);
+      requestContext,
+      tracingOptions
+    }).fullStream.pipeThrough(
+      new TransformStream({
+        transform(chunk, controller) {
+          if (serverCache) {
+            const cacheKey = runId;
+            serverCache.listPush(cacheKey, chunk).catch(() => {
+            });
+          }
+          controller.enqueue(chunk);
         }
-      }
-    });
+      })
+    );
     return stream;
   } catch (error) {
     return 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 HTTPException(400, { message: "Workflow ID is required" });
     }
-    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    if (perPage !== void 0 && perPage !== false && (!Number.isInteger(perPage) || perPage <= 0)) {
+      throw new HTTPException(400, { message: "perPage must be a positive integer or false" });
+    }
+    if (page !== void 0 && (!Number.isInteger(page) || page < 0)) {
+      throw new HTTPException(400, { message: "page must be a non-negative integer" });
+    }
+    const { workflow } = await listWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
       throw new 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
     };
@@ -610,7 +579,7 @@ async function cancelWorkflowRunHandler({
     if (!runId) {
       throw new 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 HTTPException(404, { message: "Workflow not found" });
     }
@@ -618,43 +587,14 @@ async function cancelWorkflowRunHandler({
     if (!run) {
       throw new 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 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, resourceId: run.resourceId });
-    await _run.sendEvent(event, data);
-    return { message: "Workflow run event sent" };
-  } catch (error) {
-    return handleError(error, "Error sending workflow run event");
-  }
-}
 
-export { cancelWorkflowRunHandler, createWorkflowRunHandler, getWorkflowByIdHandler, getWorkflowRunByIdHandler, getWorkflowRunExecutionResultHandler, getWorkflowRunsHandler, getWorkflowsHandler, observeStreamVNextWorkflowHandler, observeStreamWorkflowHandler, resumeAsyncWorkflowHandler, resumeStreamWorkflowHandler, resumeWorkflowHandler, sendWorkflowRunEventHandler, startAsyncWorkflowHandler, startWorkflowRunHandler, streamVNextWorkflowHandler, streamWorkflowHandler, watchWorkflowHandler, workflows_exports };
-//# sourceMappingURL=chunk-DB63UMTV.js.map
-//# sourceMappingURL=chunk-DB63UMTV.js.map
+export { cancelWorkflowRunHandler, createWorkflowRunHandler, getWorkflowByIdHandler, getWorkflowRunByIdHandler, getWorkflowRunExecutionResultHandler, listWorkflowRunsHandler, listWorkflowsHandler, observeStreamLegacyWorkflowHandler, observeStreamVNextWorkflowHandler, observeStreamWorkflowHandler, resumeAsyncWorkflowHandler, resumeStreamWorkflowHandler, resumeWorkflowHandler, startAsyncWorkflowHandler, startWorkflowRunHandler, streamLegacyWorkflowHandler, streamVNextWorkflowHandler, streamWorkflowHandler, workflows_exports };
+//# sourceMappingURL=chunk-ZJ6KEY6H.js.map
+//# sourceMappingURL=chunk-ZJ6KEY6H.js.map