@mastra/server 0.0.0-vnextWorkflows-20250422142014 → 0.0.0-workflow-deno-20250616130925

package/dist/{chunk-4B7OUZXW.js → chunk-CLYX4KLH.js}

@@ -1,25 +1,26 @@
-import { stringify, esm_default } from './chunk-OMN3UI6X.js';
-import { handleError } from './chunk-3AHQ5RGN.js';
-import { __export, HTTPException } from './chunk-TRDNDNGQ.js';
-import { ReadableStream } from 'node:stream/web';
+import { stringify, esm_default } from './chunk-TGJMNUYJ.js';
+import { handleError } from './chunk-M5ABIP7D.js';
+import { HTTPException } from './chunk-NYN7KFXL.js';
+import { __export } from './chunk-MLKGABMK.js';
+import { ReadableStream } from 'stream/web';
 
-// src/server/handlers/workflows.ts
-var workflows_exports = {};
-__export(workflows_exports, {
-  createRunHandler: () => createRunHandler,
-  getWorkflowByIdHandler: () => getWorkflowByIdHandler,
-  getWorkflowRunHandler: () => getWorkflowRunHandler,
-  getWorkflowRunsHandler: () => getWorkflowRunsHandler,
-  getWorkflowsHandler: () => getWorkflowsHandler,
-  resumeAsyncWorkflowHandler: () => resumeAsyncWorkflowHandler,
-  resumeWorkflowHandler: () => resumeWorkflowHandler,
-  startAsyncWorkflowHandler: () => startAsyncWorkflowHandler,
-  startWorkflowRunHandler: () => startWorkflowRunHandler,
-  watchWorkflowHandler: () => watchWorkflowHandler
+// src/server/handlers/legacyWorkflows.ts
+var legacyWorkflows_exports = {};
+__export(legacyWorkflows_exports, {
+  createLegacyWorkflowRunHandler: () => createLegacyWorkflowRunHandler,
+  getLegacyWorkflowByIdHandler: () => getLegacyWorkflowByIdHandler,
+  getLegacyWorkflowRunHandler: () => getLegacyWorkflowRunHandler,
+  getLegacyWorkflowRunsHandler: () => getLegacyWorkflowRunsHandler,
+  getLegacyWorkflowsHandler: () => getLegacyWorkflowsHandler,
+  resumeAsyncLegacyWorkflowHandler: () => resumeAsyncLegacyWorkflowHandler,
+  resumeLegacyWorkflowHandler: () => resumeLegacyWorkflowHandler,
+  startAsyncLegacyWorkflowHandler: () => startAsyncLegacyWorkflowHandler,
+  startLegacyWorkflowRunHandler: () => startLegacyWorkflowRunHandler,
+  watchLegacyWorkflowHandler: () => watchLegacyWorkflowHandler
 });
-async function getWorkflowsHandler({ mastra }) {
+async function getLegacyWorkflowsHandler({ mastra }) {
   try {
-    const workflows = mastra.getWorkflows({ serialized: false });
+    const workflows = mastra.legacy_getWorkflows({ serialized: false });
     const _workflows = Object.entries(workflows).reduce((acc, [key, workflow]) => {
       if (workflow.isNested) return acc;
       acc[key] = {
@@ -32,7 +33,9 @@ async function getWorkflowsHandler({ mastra }) {
         steps: Object.entries(workflow.steps).reduce((acc2, [key2, step]) => {
           const _step = step;
           acc2[key2] = {
-            ..._step,
+            id: _step.id,
+            description: _step.description,
+            workflowId: _step.workflowId,
             inputSchema: _step.inputSchema ? stringify(esm_default(_step.inputSchema)) : void 0,
             outputSchema: _step.outputSchema ? stringify(esm_default(_step.outputSchema)) : void 0
           };
@@ -46,12 +49,12 @@ async function getWorkflowsHandler({ mastra }) {
     throw new HTTPException(500, { message: error?.message || "Error getting workflows" });
   }
 }
-async function getWorkflowByIdHandler({ mastra, workflowId }) {
+async function getLegacyWorkflowByIdHandler({ mastra, workflowId }) {
   try {
     if (!workflowId) {
       throw new HTTPException(400, { message: "Workflow ID is required" });
     }
-    const workflow = mastra.getWorkflow(workflowId);
+    const workflow = mastra.legacy_getWorkflow(workflowId);
     if (!workflow) {
       throw new HTTPException(404, { message: "Workflow not found" });
     }
@@ -65,7 +68,9 @@ async function getWorkflowByIdHandler({ mastra, workflowId }) {
       steps: Object.entries(workflow.steps).reduce((acc, [key, step]) => {
         const _step = step;
         acc[key] = {
-          ..._step,
+          id: _step.id,
+          description: _step.description,
+          workflowId: _step.workflowId,
           inputSchema: _step.inputSchema ? stringify(esm_default(_step.inputSchema)) : void 0,
           outputSchema: _step.outputSchema ? stringify(esm_default(_step.outputSchema)) : void 0
         };
@@ -76,9 +81,9 @@ async function getWorkflowByIdHandler({ mastra, workflowId }) {
     throw new HTTPException(500, { message: error?.message || "Error getting workflow" });
   }
 }
-async function startAsyncWorkflowHandler({
+async function startAsyncLegacyWorkflowHandler({
   mastra,
-  container,
+  runtimeContext,
   workflowId,
   runId,
   triggerData
@@ -87,32 +92,32 @@ async function startAsyncWorkflowHandler({
     if (!workflowId) {
       throw new HTTPException(400, { message: "Workflow ID is required" });
     }
-    const workflow = mastra.getWorkflow(workflowId);
+    const workflow = mastra.legacy_getWorkflow(workflowId);
     if (!workflow) {
       throw new HTTPException(404, { message: "Workflow not found" });
     }
     if (!runId) {
-      const { start } = workflow.createRun();
-      const result2 = await start({
+      const newRun = workflow.createRun();
+      const result2 = await newRun.start({
         triggerData,
-        container
+        runtimeContext
       });
       return result2;
     }
-    const run = workflow.getRun(runId);
+    const run = workflow.getMemoryRun(runId);
     if (!run) {
       throw new HTTPException(404, { message: "Workflow run not found" });
     }
     const result = await run.start({
       triggerData,
-      container
+      runtimeContext
     });
     return result;
   } catch (error) {
     throw new HTTPException(500, { message: error?.message || "Error executing workflow" });
   }
 }
-async function getWorkflowRunHandler({
+async function getLegacyWorkflowRunHandler({
   mastra,
   workflowId,
   runId
@@ -124,11 +129,11 @@ async function getWorkflowRunHandler({
     if (!runId) {
       throw new HTTPException(400, { message: "Run ID is required" });
     }
-    const workflow = mastra.getWorkflow(workflowId);
+    const workflow = mastra.legacy_getWorkflow(workflowId);
     if (!workflow) {
       throw new HTTPException(404, { message: "Workflow not found" });
     }
-    const run = workflow.getRun(runId);
+    const run = await workflow.getRun(runId);
     if (!run) {
       throw new HTTPException(404, { message: "Workflow run not found" });
     }
@@ -137,7 +142,7 @@ async function getWorkflowRunHandler({
     throw new HTTPException(500, { message: error?.message || "Error getting workflow run" });
   }
 }
-async function createRunHandler({
+async function createLegacyWorkflowRunHandler({
   mastra,
   workflowId,
   runId: prevRunId
@@ -146,19 +151,19 @@ async function createRunHandler({
     if (!workflowId) {
       throw new HTTPException(400, { message: "Workflow ID is required" });
     }
-    const workflow = mastra.getWorkflow(workflowId);
+    const workflow = mastra.legacy_getWorkflow(workflowId);
     if (!workflow) {
       throw new HTTPException(404, { message: "Workflow not found" });
     }
-    const { runId } = workflow.createRun({ runId: prevRunId });
-    return { runId };
+    const newRun = workflow.createRun({ runId: prevRunId });
+    return { runId: newRun.runId };
   } catch (error) {
     throw new HTTPException(500, { message: error?.message || "Error creating workflow run" });
   }
 }
-async function startWorkflowRunHandler({
+async function startLegacyWorkflowRunHandler({
   mastra,
-  container,
+  runtimeContext,
   workflowId,
   runId,
   triggerData
@@ -170,21 +175,21 @@ async function startWorkflowRunHandler({
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to start run" });
     }
-    const workflow = mastra.getWorkflow(workflowId);
-    const run = workflow.getRun(runId);
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    const run = workflow.getMemoryRun(runId);
     if (!run) {
       throw new HTTPException(404, { message: "Workflow run not found" });
     }
-    await run.start({
+    void run.start({
       triggerData,
-      container
+      runtimeContext
     });
     return { message: "Workflow run started" };
   } catch (e) {
     return handleError(e, "Error starting workflow run");
   }
 }
-async function watchWorkflowHandler({
+async function watchLegacyWorkflowHandler({
   mastra,
   workflowId,
   runId
@@ -196,8 +201,8 @@ async function watchWorkflowHandler({
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to watch workflow" });
     }
-    const workflow = mastra.getWorkflow(workflowId);
-    const run = workflow.getRun(runId);
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    const run = workflow.getMemoryRun(runId);
     if (!run) {
       throw new HTTPException(404, { message: "Workflow run not found" });
     }
@@ -213,8 +218,10 @@ async function watchWorkflowHandler({
             asyncRef = null;
           }
           asyncRef = setImmediate(() => {
-            if (!workflow.getRun(runId2)) {
+            const runDone = Object.values(activePathsObj).every((value) => value.status !== "executing");
+            if (runDone) {
               controller.close();
+              unwatch?.();
             }
           });
         });
@@ -228,12 +235,12 @@ async function watchWorkflowHandler({
     return handleError(error, "Error watching workflow");
   }
 }
-async function resumeAsyncWorkflowHandler({
+async function resumeAsyncLegacyWorkflowHandler({
   mastra,
   workflowId,
   runId,
   body,
-  container
+  runtimeContext
 }) {
   try {
     if (!workflowId) {
@@ -242,27 +249,27 @@ async function resumeAsyncWorkflowHandler({
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to resume workflow" });
     }
-    const workflow = mastra.getWorkflow(workflowId);
-    const run = workflow.getRun(runId);
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    const run = workflow.getMemoryRun(runId);
     if (!run) {
       throw new HTTPException(404, { message: "Workflow run not found" });
     }
     const result = await run.resume({
       stepId: body.stepId,
       context: body.context,
-      container
+      runtimeContext
     });
     return result;
   } catch (error) {
     return handleError(error, "Error resuming workflow step");
   }
 }
-async function resumeWorkflowHandler({
+async function resumeLegacyWorkflowHandler({
   mastra,
   workflowId,
   runId,
   body,
-  container
+  runtimeContext
 }) {
   try {
     if (!workflowId) {
@@ -271,28 +278,36 @@ async function resumeWorkflowHandler({
     if (!runId) {
       throw new HTTPException(400, { message: "runId required to resume workflow" });
     }
-    const workflow = mastra.getWorkflow(workflowId);
-    const run = workflow.getRun(runId);
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    const run = workflow.getMemoryRun(runId);
     if (!run) {
       throw new HTTPException(404, { message: "Workflow run not found" });
     }
-    await run.resume({
+    void run.resume({
       stepId: body.stepId,
       context: body.context,
-      container
+      runtimeContext
     });
     return { message: "Workflow run resumed" };
   } catch (error) {
     return handleError(error, "Error resuming workflow");
   }
 }
-async function getWorkflowRunsHandler({ mastra, workflowId }) {
+async function getLegacyWorkflowRunsHandler({
+  mastra,
+  workflowId,
+  fromDate,
+  toDate,
+  limit,
+  offset,
+  resourceId
+}) {
   try {
     if (!workflowId) {
       throw new HTTPException(400, { message: "Workflow ID is required" });
     }
-    const workflow = mastra.getWorkflow(workflowId);
-    const workflowRuns = await workflow.getWorkflowRuns() || {
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    const workflowRuns = await workflow.getWorkflowRuns({ fromDate, toDate, limit, offset, resourceId }) || {
       runs: [],
       total: 0
     };
@@ -302,4 +317,4 @@ async function getWorkflowRunsHandler({ mastra, workflowId }) {
   }
 }
 
-export { createRunHandler, getWorkflowByIdHandler, getWorkflowRunHandler, getWorkflowRunsHandler, getWorkflowsHandler, resumeAsyncWorkflowHandler, resumeWorkflowHandler, startAsyncWorkflowHandler, startWorkflowRunHandler, watchWorkflowHandler, workflows_exports };
+export { createLegacyWorkflowRunHandler, getLegacyWorkflowByIdHandler, getLegacyWorkflowRunHandler, getLegacyWorkflowRunsHandler, getLegacyWorkflowsHandler, legacyWorkflows_exports, resumeAsyncLegacyWorkflowHandler, resumeLegacyWorkflowHandler, startAsyncLegacyWorkflowHandler, startLegacyWorkflowRunHandler, watchLegacyWorkflowHandler };

package/dist/chunk-CMMOIUFC.cjs

@@ -0,0 +1,114 @@
+'use strict';
+
+var chunk57CJTIPW_cjs = require('./chunk-57CJTIPW.cjs');
+var chunk64U3UDTH_cjs = require('./chunk-64U3UDTH.cjs');
+var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
+var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
+var stream = require('stream');
+
+// src/server/handlers/voice.ts
+var voice_exports = {};
+chunk75ZPJI57_cjs.__export(voice_exports, {
+  generateSpeechHandler: () => generateSpeechHandler,
+  getListenerHandler: () => getListenerHandler,
+  getSpeakersHandler: () => getSpeakersHandler,
+  transcribeSpeechHandler: () => transcribeSpeechHandler
+});
+async function getSpeakersHandler({ mastra, agentId }) {
+  try {
+    if (!agentId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent ID is required" });
+    }
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    if (!agent.voice) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const speakers = await agent.voice.getSpeakers();
+    return speakers;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting speakers");
+  }
+}
+async function generateSpeechHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    if (!agentId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent ID is required" });
+    }
+    chunk57CJTIPW_cjs.validateBody({
+      text: body?.text
+    });
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    if (!agent.voice) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const audioStream = await agent.voice.speak(body.text, { speaker: body.speakerId });
+    if (!audioStream) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: "Failed to generate speech" });
+    }
+    return audioStream;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error generating speech");
+  }
+}
+async function transcribeSpeechHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    if (!agentId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent ID is required" });
+    }
+    if (!body?.audioData) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Audio data is required" });
+    }
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    if (!agent.voice) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const audioStream = new stream.Readable();
+    audioStream.push(body.audioData);
+    audioStream.push(null);
+    const text = await agent.voice.listen(audioStream, body.options);
+    return { text };
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error transcribing speech");
+  }
+}
+async function getListenerHandler({ mastra, agentId }) {
+  try {
+    if (!agentId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent ID is required" });
+    }
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    if (!agent.voice) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const listeners = await agent.voice.getListener();
+    return listeners;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting listeners");
+  }
+}
+
+exports.generateSpeechHandler = generateSpeechHandler;
+exports.getListenerHandler = getListenerHandler;
+exports.getSpeakersHandler = getSpeakersHandler;
+exports.transcribeSpeechHandler = transcribeSpeechHandler;
+exports.voice_exports = voice_exports;

package/dist/{chunk-3RVHWGWO.js → chunk-CP55EVBK.js}

@@ -1,12 +1,14 @@
-import { validateBody } from './chunk-L7XE5QTW.js';
-import { handleError } from './chunk-3AHQ5RGN.js';
-import { __export, HTTPException } from './chunk-TRDNDNGQ.js';
+import { validateBody } from './chunk-H5PTF3Y4.js';
+import { handleError } from './chunk-M5ABIP7D.js';
+import { HTTPException } from './chunk-NYN7KFXL.js';
+import { __export } from './chunk-MLKGABMK.js';
 import { Readable } from 'stream';
 
 // src/server/handlers/voice.ts
 var voice_exports = {};
 __export(voice_exports, {
   generateSpeechHandler: () => generateSpeechHandler,
+  getListenerHandler: () => getListenerHandler,
   getSpeakersHandler: () => getSpeakersHandler,
   transcribeSpeechHandler: () => transcribeSpeechHandler
 });
@@ -38,9 +40,7 @@ async function generateSpeechHandler({
       throw new HTTPException(400, { message: "Agent ID is required" });
     }
     validateBody({
-      text: void 0,
-      speakerId: void 0,
-      ...body
+      text: body?.text
     });
     const agent = mastra.getAgent(agentId);
     if (!agent) {
@@ -53,12 +53,7 @@ async function generateSpeechHandler({
     if (!audioStream) {
       throw new HTTPException(500, { message: "Failed to generate speech" });
     }
-    const chunks = [];
-    for await (const chunk of audioStream) {
-      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
-    const audioData = Buffer.concat(chunks);
-    return { audioData };
+    return audioStream;
   } catch (error) {
     return handleError(error, "Error generating speech");
   }
@@ -91,5 +86,23 @@ async function transcribeSpeechHandler({
     return handleError(error, "Error transcribing speech");
   }
 }
+async function getListenerHandler({ mastra, agentId }) {
+  try {
+    if (!agentId) {
+      throw new HTTPException(400, { message: "Agent ID is required" });
+    }
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
+    if (!agent.voice) {
+      throw new HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const listeners = await agent.voice.getListener();
+    return listeners;
+  } catch (error) {
+    return handleError(error, "Error getting listeners");
+  }
+}
 
-export { generateSpeechHandler, getSpeakersHandler, transcribeSpeechHandler, voice_exports };
+export { generateSpeechHandler, getListenerHandler, getSpeakersHandler, transcribeSpeechHandler, voice_exports };