@mastra/server 0.0.0-agui-20250501182100 → 0.0.0-ai-v5-20250625014956

package/dist/{chunk-Y3SV5XK4.js → chunk-WC7U7A6Y.js}

@@ -1,7 +1,10 @@
-import { stringify, esm_default } from './chunk-OMN3UI6X.js';
-import { validateBody } from './chunk-L7XE5QTW.js';
-import { handleError } from './chunk-3AHQ5RGN.js';
-import { __export, HTTPException } from './chunk-TRDNDNGQ.js';
+import { stringify, esm_default } from './chunk-TGJMNUYJ.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 { createV4CompatibleResponse } from '@mastra/core/agent';
+import { RuntimeContext } from '@mastra/core/runtime-context';
 
 // src/server/handlers/agents.ts
 var agents_exports = {};
@@ -21,6 +24,8 @@ async function getAgentsHandler({ mastra, runtimeContext }) {
         const instructions = await agent.getInstructions({ runtimeContext });
         const tools = await agent.getTools({ runtimeContext });
         const llm = await agent.getLLM({ runtimeContext });
+        const defaultGenerateOptions = await agent.getDefaultGenerateOptions({ runtimeContext });
+        const defaultStreamOptions = await agent.getDefaultStreamOptions({ runtimeContext });
         const serializedAgentTools = Object.entries(tools || {}).reduce((acc, [key, tool]) => {
           const _tool = tool;
           acc[key] = {
@@ -30,13 +35,33 @@ async function getAgentsHandler({ mastra, runtimeContext }) {
           };
           return acc;
         }, {});
+        let serializedAgentWorkflows = {};
+        if ("getWorkflows" in agent) {
+          const logger = mastra.getLogger();
+          try {
+            const workflows = await agent.getWorkflows({ runtimeContext });
+            serializedAgentWorkflows = Object.entries(workflows || {}).reduce((acc, [key, workflow]) => {
+              return {
+                ...acc,
+                [key]: {
+                  name: workflow.name
+                }
+              };
+            }, {});
+          } catch (error) {
+            logger.error("Error getting workflows for agent", { agentName: agent.name, error });
+          }
+        }
         return {
           id,
           name: agent.name,
           instructions,
           tools: serializedAgentTools,
+          workflows: serializedAgentWorkflows,
           provider: llm?.getProvider(),
-          modelId: llm?.getModelId()
+          modelId: llm?.getModelId(),
+          defaultGenerateOptions,
+          defaultStreamOptions
         };
       })
     );
@@ -52,7 +77,8 @@ async function getAgentsHandler({ mastra, runtimeContext }) {
 async function getAgentByIdHandler({
   mastra,
   runtimeContext,
-  agentId
+  agentId,
+  isPlayground = false
 }) {
   try {
     const agent = mastra.getAgent(agentId);
@@ -69,14 +95,59 @@ async function getAgentByIdHandler({
       };
       return acc;
     }, {});
-    const instructions = await agent.getInstructions({ runtimeContext });
+    let serializedAgentWorkflows = {};
+    if ("getWorkflows" in agent) {
+      const logger = mastra.getLogger();
+      try {
+        const workflows = await agent.getWorkflows({ runtimeContext });
+        serializedAgentWorkflows = Object.entries(workflows || {}).reduce((acc, [key, workflow]) => {
+          return {
+            ...acc,
+            [key]: {
+              name: workflow.name,
+              steps: Object.entries(workflow.steps).reduce((acc2, [key2, step]) => {
+                return {
+                  ...acc2,
+                  [key2]: {
+                    id: step.id,
+                    description: step.description
+                  }
+                };
+              }, {})
+            }
+          };
+        }, {});
+      } catch (error) {
+        logger.error("Error getting workflows for agent", { agentName: agent.name, error });
+      }
+    }
+    let proxyRuntimeContext = runtimeContext;
+    if (isPlayground) {
+      proxyRuntimeContext = new Proxy(runtimeContext, {
+        get(target, prop) {
+          if (prop === "get") {
+            return function(key) {
+              const value = target.get(key);
+              return value ?? `<${key}>`;
+            };
+          }
+          return Reflect.get(target, prop);
+        }
+      });
+    }
+    const instructions = await agent.getInstructions({ runtimeContext: proxyRuntimeContext });
     const llm = await agent.getLLM({ runtimeContext });
+    const defaultGenerateOptions = await agent.getDefaultGenerateOptions({ runtimeContext: proxyRuntimeContext });
+    const defaultStreamOptions = await agent.getDefaultStreamOptions({ runtimeContext: proxyRuntimeContext });
     return {
       name: agent.name,
       instructions,
       tools: serializedAgentTools,
+      workflows: serializedAgentWorkflows,
       provider: llm?.getProvider(),
-      modelId: llm?.getModelId()
+      modelId: llm?.getModelId(),
+      defaultGenerateOptions,
+      defaultStreamOptions
     };
   } catch (error) {
     return handleError(error, "Error getting agent");
@@ -131,14 +202,18 @@ async function generateHandler({
     if (!agent) {
       throw new HTTPException(404, { message: "Agent not found" });
     }
-    const { messages, resourceId, resourceid, ...rest } = body;
+    const { messages, resourceId, resourceid, runtimeContext: agentRuntimeContext, ...rest } = body;
     const finalResourceId = resourceId ?? resourceid;
+    const finalRuntimeContext = new RuntimeContext([
+      ...Array.from(runtimeContext.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
     validateBody({ messages });
     const result = await agent.generate(messages, {
       ...rest,
       // @ts-expect-error TODO fix types
       resourceId: finalResourceId,
-      runtimeContext
+      runtimeContext: finalRuntimeContext
     });
     return result;
   } catch (error) {
@@ -156,22 +231,34 @@ async function streamGenerateHandler({
     if (!agent) {
       throw new HTTPException(404, { message: "Agent not found" });
     }
-    const { messages, resourceId, resourceid, ...rest } = body;
-    const finalResourceId = resourceId ?? resourceid;
+    const { messages, resourceId, runtimeContext: agentRuntimeContext, ...rest } = body;
+    const finalRuntimeContext = new RuntimeContext([
+      ...Array.from(runtimeContext.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
     validateBody({ messages });
     const streamResult = await agent.stream(messages, {
       ...rest,
       // @ts-expect-error TODO fix types
-      resourceId: finalResourceId,
-      runtimeContext
+      resourceId,
+      runtimeContext: finalRuntimeContext
     });
-    const streamResponse = rest.output ? streamResult.toTextStreamResponse() : streamResult.toDataStreamResponse({
-      sendUsage: true,
+    const headers = {
+      "Transfer-Encoding": "chunked"
+    };
+    if (rest.output) {
+      return streamResult.toTextStreamResponse({ headers });
+    }
+    const useV4Compat = mastra.getAiSdkCompatMode() === "v4";
+    const uiMessageStream = streamResult.toUIMessageStreamResponse({
+      headers,
       sendReasoning: true,
-      getErrorMessage: (error) => {
+      sendSources: true,
+      onError: (error) => {
         return `An error occurred while processing your request. ${error instanceof Error ? error.message : JSON.stringify(error)}`;
       }
     });
+    const streamResponse = useV4Compat ? createV4CompatibleResponse(uiMessageStream.body) : uiMessageStream;
     return streamResponse;
   } catch (error) {
     throw new HTTPException(error?.status ?? 500, { message: error?.message ?? "Error streaming from agent" });

package/dist/chunk-WE32JG64.cjs

@@ -0,0 +1,332 @@
+'use strict';
+
+var chunkASKESBJW_cjs = require('./chunk-ASKESBJW.cjs');
+var chunk64U3UDTH_cjs = require('./chunk-64U3UDTH.cjs');
+var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
+var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
+var web = require('stream/web');
+
+// src/server/handlers/legacyWorkflows.ts
+var legacyWorkflows_exports = {};
+chunk75ZPJI57_cjs.__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 getLegacyWorkflowsHandler({ mastra }) {
+  try {
+    const workflows = mastra.legacy_getWorkflows({ serialized: false });
+    const _workflows = Object.entries(workflows).reduce((acc, [key, workflow]) => {
+      if (workflow.isNested) return acc;
+      acc[key] = {
+        stepGraph: workflow.stepGraph,
+        stepSubscriberGraph: workflow.stepSubscriberGraph,
+        serializedStepGraph: workflow.serializedStepGraph,
+        serializedStepSubscriberGraph: workflow.serializedStepSubscriberGraph,
+        name: workflow.name,
+        triggerSchema: workflow.triggerSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(workflow.triggerSchema)) : void 0,
+        steps: Object.entries(workflow.steps).reduce((acc2, [key2, step]) => {
+          const _step = step;
+          acc2[key2] = {
+            id: _step.id,
+            description: _step.description,
+            workflowId: _step.workflowId,
+            inputSchema: _step.inputSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(_step.inputSchema)) : void 0,
+            outputSchema: _step.outputSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(_step.outputSchema)) : void 0
+          };
+          return acc2;
+        }, {})
+      };
+      return acc;
+    }, {});
+    return _workflows;
+  } catch (error) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error getting workflows" });
+  }
+}
+async function getLegacyWorkflowByIdHandler({ mastra, workflowId }) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    if (!workflow) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+    }
+    return {
+      stepGraph: workflow.stepGraph,
+      stepSubscriberGraph: workflow.stepSubscriberGraph,
+      serializedStepGraph: workflow.serializedStepGraph,
+      serializedStepSubscriberGraph: workflow.serializedStepSubscriberGraph,
+      name: workflow.name,
+      triggerSchema: workflow.triggerSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(workflow.triggerSchema)) : void 0,
+      steps: Object.entries(workflow.steps).reduce((acc, [key, step]) => {
+        const _step = step;
+        acc[key] = {
+          id: _step.id,
+          description: _step.description,
+          workflowId: _step.workflowId,
+          inputSchema: _step.inputSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(_step.inputSchema)) : void 0,
+          outputSchema: _step.outputSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(_step.outputSchema)) : void 0
+        };
+        return acc;
+      }, {})
+    };
+  } catch (error) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error getting workflow" });
+  }
+}
+async function startAsyncLegacyWorkflowHandler({
+  mastra,
+  runtimeContext,
+  workflowId,
+  runId,
+  triggerData
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    if (!workflow) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+    }
+    if (!runId) {
+      const newRun = workflow.createRun();
+      const result2 = await newRun.start({
+        triggerData,
+        runtimeContext
+      });
+      return result2;
+    }
+    const run = workflow.getMemoryRun(runId);
+    if (!run) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    const result = await run.start({
+      triggerData,
+      runtimeContext
+    });
+    return result;
+  } catch (error) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error executing workflow" });
+  }
+}
+async function getLegacyWorkflowRunHandler({
+  mastra,
+  workflowId,
+  runId
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Run ID is required" });
+    }
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    if (!workflow) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+    }
+    const run = await workflow.getRun(runId);
+    if (!run) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    return run;
+  } catch (error) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error getting workflow run" });
+  }
+}
+async function createLegacyWorkflowRunHandler({
+  mastra,
+  workflowId,
+  runId: prevRunId
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    if (!workflow) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+    }
+    const newRun = workflow.createRun({ runId: prevRunId });
+    return { runId: newRun.runId };
+  } catch (error) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error creating workflow run" });
+  }
+}
+async function startLegacyWorkflowRunHandler({
+  mastra,
+  runtimeContext,
+  workflowId,
+  runId,
+  triggerData
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to start run" });
+    }
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    const run = workflow.getMemoryRun(runId);
+    if (!run) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    void run.start({
+      triggerData,
+      runtimeContext
+    });
+    return { message: "Workflow run started" };
+  } catch (e) {
+    return chunk64U3UDTH_cjs.handleError(e, "Error starting workflow run");
+  }
+}
+async function watchLegacyWorkflowHandler({
+  mastra,
+  workflowId,
+  runId
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to watch workflow" });
+    }
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    const run = workflow.getMemoryRun(runId);
+    if (!run) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    let unwatch;
+    let asyncRef = null;
+    const stream = new web.ReadableStream({
+      start(controller) {
+        unwatch = run.watch(({ activePaths, runId: runId2, timestamp, results }) => {
+          const activePathsObj = Object.fromEntries(activePaths);
+          controller.enqueue(JSON.stringify({ activePaths: activePathsObj, runId: runId2, timestamp, results }));
+          if (asyncRef) {
+            clearImmediate(asyncRef);
+            asyncRef = null;
+          }
+          asyncRef = setImmediate(() => {
+            const runDone = Object.values(activePathsObj).every((value) => value.status !== "executing");
+            if (runDone) {
+              controller.close();
+              unwatch?.();
+            }
+          });
+        });
+      },
+      cancel() {
+        unwatch?.();
+      }
+    });
+    return stream;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error watching workflow");
+  }
+}
+async function resumeAsyncLegacyWorkflowHandler({
+  mastra,
+  workflowId,
+  runId,
+  body,
+  runtimeContext
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    const run = workflow.getMemoryRun(runId);
+    if (!run) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    const result = await run.resume({
+      stepId: body.stepId,
+      context: body.context,
+      runtimeContext
+    });
+    return result;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error resuming workflow step");
+  }
+}
+async function resumeLegacyWorkflowHandler({
+  mastra,
+  workflowId,
+  runId,
+  body,
+  runtimeContext
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    const run = workflow.getMemoryRun(runId);
+    if (!run) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    void run.resume({
+      stepId: body.stepId,
+      context: body.context,
+      runtimeContext
+    });
+    return { message: "Workflow run resumed" };
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error resuming workflow");
+  }
+}
+async function getLegacyWorkflowRunsHandler({
+  mastra,
+  workflowId,
+  fromDate,
+  toDate,
+  limit,
+  offset,
+  resourceId
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    const workflow = mastra.legacy_getWorkflow(workflowId);
+    const workflowRuns = await workflow.getWorkflowRuns({ fromDate, toDate, limit, offset, resourceId }) || {
+      runs: [],
+      total: 0
+    };
+    return workflowRuns;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting workflow runs");
+  }
+}
+
+exports.createLegacyWorkflowRunHandler = createLegacyWorkflowRunHandler;
+exports.getLegacyWorkflowByIdHandler = getLegacyWorkflowByIdHandler;
+exports.getLegacyWorkflowRunHandler = getLegacyWorkflowRunHandler;
+exports.getLegacyWorkflowRunsHandler = getLegacyWorkflowRunsHandler;
+exports.getLegacyWorkflowsHandler = getLegacyWorkflowsHandler;
+exports.legacyWorkflows_exports = legacyWorkflows_exports;
+exports.resumeAsyncLegacyWorkflowHandler = resumeAsyncLegacyWorkflowHandler;
+exports.resumeLegacyWorkflowHandler = resumeLegacyWorkflowHandler;
+exports.startAsyncLegacyWorkflowHandler = startAsyncLegacyWorkflowHandler;
+exports.startLegacyWorkflowRunHandler = startLegacyWorkflowRunHandler;
+exports.watchLegacyWorkflowHandler = watchLegacyWorkflowHandler;

package/dist/chunk-WJY57THV.cjs

@@ -0,0 +1,118 @@
+'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" });
+    }
+    const voice = await agent.getVoice();
+    if (!voice) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const speakers = await 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" });
+    }
+    const voice = await agent.getVoice();
+    if (!voice) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const audioStream = await 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" });
+    }
+    const voice = await agent.getVoice();
+    if (!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 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" });
+    }
+    const voice = await agent.getVoice();
+    if (!voice) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const listeners = await 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;