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

package/dist/{chunk-L3VURYKY.cjs → chunk-B2PAS2IB.cjs}

@@ -1,14 +1,15 @@
 'use strict';
 
 var chunkLI436ITD_cjs = require('./chunk-LI436ITD.cjs');
-var chunk64U3UDTH_cjs = require('./chunk-64U3UDTH.cjs');
-var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
+var chunkPZQDCRPV_cjs = require('./chunk-PZQDCRPV.cjs');
+var chunk2KZFMI6P_cjs = require('./chunk-2KZFMI6P.cjs');
 var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
 var web = require('stream/web');
 
 // src/server/handlers/workflows.ts
 var workflows_exports = {};
 chunk75ZPJI57_cjs.__export(workflows_exports, {
+  cancelWorkflowRunHandler: () => cancelWorkflowRunHandler,
   createWorkflowRunHandler: () => createWorkflowRunHandler,
   getWorkflowByIdHandler: () => getWorkflowByIdHandler,
   getWorkflowRunByIdHandler: () => getWorkflowRunByIdHandler,
@@ -17,11 +18,31 @@ chunk75ZPJI57_cjs.__export(workflows_exports, {
   getWorkflowsHandler: () => getWorkflowsHandler,
   resumeAsyncWorkflowHandler: () => resumeAsyncWorkflowHandler,
   resumeWorkflowHandler: () => resumeWorkflowHandler,
+  sendWorkflowRunEventHandler: () => sendWorkflowRunEventHandler,
   startAsyncWorkflowHandler: () => startAsyncWorkflowHandler,
   startWorkflowRunHandler: () => startWorkflowRunHandler,
   streamWorkflowHandler: () => streamWorkflowHandler,
   watchWorkflowHandler: () => watchWorkflowHandler
 });
+function getSteps(steps, path) {
+  return Object.entries(steps).reduce((acc, [key, step]) => {
+    const fullKey = path ? `${path}.${key}` : key;
+    acc[fullKey] = {
+      id: step.id,
+      description: step.description,
+      inputSchema: step.inputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(step.inputSchema)) : void 0,
+      outputSchema: step.outputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(step.outputSchema)) : void 0,
+      resumeSchema: step.resumeSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(step.resumeSchema)) : void 0,
+      suspendSchema: step.suspendSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(step.suspendSchema)) : void 0,
+      isWorkflow: step.component === "WORKFLOW"
+    };
+    if (step.component === "WORKFLOW" && step.steps) {
+      const nestedSteps = getSteps(step.steps, fullKey) || {};
+      acc = { ...acc, ...nestedSteps };
+    }
+    return acc;
+  }, {});
+}
 async function getWorkflowsHandler({ mastra }) {
   try {
     const workflows = mastra.getWorkflows({ serialized: false });
@@ -40,6 +61,7 @@ async function getWorkflowsHandler({ mastra }) {
           };
           return acc2;
         }, {}),
+        allSteps: getSteps(workflow.steps) || {},
         stepGraph: workflow.serializedStepGraph,
         inputSchema: workflow.inputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(workflow.inputSchema)) : void 0,
         outputSchema: workflow.outputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(workflow.outputSchema)) : void 0
@@ -48,13 +70,13 @@ async function getWorkflowsHandler({ mastra }) {
     }, {});
     return _workflows;
   } catch (error) {
-    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error getting workflows" });
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting workflows");
   }
 }
 async function getWorkflowsFromSystem({ mastra, workflowId }) {
   const logger = mastra.getLogger();
   if (!workflowId) {
-    throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
   }
   let workflow;
   try {
@@ -81,18 +103,18 @@ async function getWorkflowsFromSystem({ mastra, workflowId }) {
     }
   }
   if (!workflow) {
-    throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+    throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
   }
   return { workflow };
 }
 async function getWorkflowByIdHandler({ mastra, workflowId }) {
   try {
     if (!workflowId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     return {
       steps: Object.entries(workflow.steps).reduce((acc, [key, step]) => {
@@ -106,6 +128,7 @@ async function getWorkflowByIdHandler({ mastra, workflowId }) {
         };
         return acc;
       }, {}),
+      allSteps: getSteps(workflow.steps) || {},
       name: workflow.name,
       description: workflow.description,
       stepGraph: workflow.serializedStepGraph,
@@ -113,7 +136,7 @@ async function getWorkflowByIdHandler({ mastra, workflowId }) {
       outputSchema: workflow.outputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(workflow.outputSchema)) : void 0
     };
   } catch (error) {
-    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error getting workflow" });
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting workflow");
   }
 }
 async function getWorkflowRunByIdHandler({
@@ -123,22 +146,22 @@ async function getWorkflowRunByIdHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Run ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Run ID is required" });
     }
     const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk2KZFMI6P_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" });
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting workflow run");
   }
 }
 async function getWorkflowRunExecutionResultHandler({
@@ -148,24 +171,22 @@ async function getWorkflowRunExecutionResultHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Run ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Run ID is required" });
     }
     const workflow = mastra.getWorkflow(workflowId);
     if (!workflow) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const executionResult = await workflow.getWorkflowRunExecutionResult(runId);
     if (!executionResult) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run execution result not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow run execution result not found" });
     }
     return executionResult;
   } catch (error) {
-    throw new chunkOCWPVYNI_cjs.HTTPException(500, {
-      message: error?.message || "Error getting workflow run execution result"
-    });
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting workflow run execution result");
   }
 }
 async function createWorkflowRunHandler({
@@ -175,16 +196,16 @@ async function createWorkflowRunHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.createRunAsync({ runId: prevRunId });
     return { runId: run.runId };
   } catch (error) {
-    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error creating workflow run" });
+    return chunkPZQDCRPV_cjs.handleError(error, "Error creating workflow run");
   }
 }
 async function startAsyncWorkflowHandler({
@@ -196,11 +217,11 @@ async function startAsyncWorkflowHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const _run = await workflow.createRunAsync({ runId });
     const result = await _run.start({
@@ -209,7 +230,7 @@ async function startAsyncWorkflowHandler({
     });
     return result;
   } catch (error) {
-    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error executing workflow" });
+    return chunkPZQDCRPV_cjs.handleError(error, "Error starting async workflow");
   }
 }
 async function startWorkflowRunHandler({
@@ -221,18 +242,18 @@ async function startWorkflowRunHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to start run" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "runId required to start run" });
     }
     const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow run not found" });
     }
     const _run = await workflow.createRunAsync({ runId });
     void _run.start({
@@ -241,7 +262,7 @@ async function startWorkflowRunHandler({
     });
     return { message: "Workflow run started" };
   } catch (e) {
-    return chunk64U3UDTH_cjs.handleError(e, "Error starting workflow run");
+    return chunkPZQDCRPV_cjs.handleError(e, "Error starting workflow run");
   }
 }
 async function watchWorkflowHandler({
@@ -251,18 +272,18 @@ async function watchWorkflowHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to watch workflow" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "runId required to watch workflow" });
     }
     const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow run not found" });
     }
     const _run = await workflow.createRunAsync({ runId });
     let unwatch;
@@ -290,7 +311,7 @@ async function watchWorkflowHandler({
     });
     return stream;
   } catch (error) {
-    return chunk64U3UDTH_cjs.handleError(error, "Error watching workflow");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error watching workflow");
   }
 }
 async function streamWorkflowHandler({
@@ -302,14 +323,14 @@ async function streamWorkflowHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to resume workflow" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "runId required to resume workflow" });
     }
     const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.createRunAsync({ runId });
     const result = run.stream({
@@ -318,7 +339,7 @@ async function streamWorkflowHandler({
     });
     return result;
   } catch (error) {
-    return chunk64U3UDTH_cjs.handleError(error, "Error executing workflow");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error executing workflow");
   }
 }
 async function resumeAsyncWorkflowHandler({
@@ -330,21 +351,21 @@ async function resumeAsyncWorkflowHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to resume workflow" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "runId required to resume workflow" });
     }
     if (!body.step) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "step required to resume workflow" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "step required to resume workflow" });
     }
     const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow run not found" });
     }
     const _run = await workflow.createRunAsync({ runId });
     const result = await _run.resume({
@@ -354,7 +375,7 @@ async function resumeAsyncWorkflowHandler({
     });
     return result;
   } catch (error) {
-    return chunk64U3UDTH_cjs.handleError(error, "Error resuming workflow step");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error resuming workflow step");
   }
 }
 async function resumeWorkflowHandler({
@@ -366,21 +387,21 @@ async function resumeWorkflowHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     if (!runId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to resume workflow" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "runId required to resume workflow" });
     }
     if (!body.step) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "step required to resume workflow" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "step required to resume workflow" });
     }
     const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const run = await workflow.getWorkflowRunById(runId);
     if (!run) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow run not found" });
     }
     const _run = await workflow.createRunAsync({ runId });
     void _run.resume({
@@ -390,7 +411,7 @@ async function resumeWorkflowHandler({
     });
     return { message: "Workflow run resumed" };
   } catch (error) {
-    return chunk64U3UDTH_cjs.handleError(error, "Error resuming workflow");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error resuming workflow");
   }
 }
 async function getWorkflowRunsHandler({
@@ -404,11 +425,11 @@ async function getWorkflowRunsHandler({
 }) {
   try {
     if (!workflowId) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
     }
     const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
     if (!workflow) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
     }
     const workflowRuns = await workflow.getWorkflowRuns({ fromDate, toDate, limit, offset, resourceId }) || {
       runs: [],
@@ -416,10 +437,67 @@ async function getWorkflowRunsHandler({
     };
     return workflowRuns;
   } catch (error) {
-    return chunk64U3UDTH_cjs.handleError(error, "Error getting workflow runs");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting workflow runs");
+  }
+}
+async function cancelWorkflowRunHandler({
+  mastra,
+  workflowId,
+  runId
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "runId required to cancel workflow run" });
+    }
+    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    if (!workflow) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
+    }
+    const run = await workflow.getWorkflowRunById(runId);
+    if (!run) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    const _run = await workflow.createRunAsync({ runId });
+    await _run.cancel();
+    return { message: "Workflow run cancelled" };
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error canceling workflow run");
+  }
+}
+async function sendWorkflowRunEventHandler({
+  mastra,
+  workflowId,
+  runId,
+  event,
+  data
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "runId required to send workflow run event" });
+    }
+    const { workflow } = await getWorkflowsFromSystem({ mastra, workflowId });
+    if (!workflow) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow not found" });
+    }
+    const run = await workflow.getWorkflowRunById(runId);
+    if (!run) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    const _run = await workflow.createRunAsync({ runId });
+    await _run.sendEvent(event, data);
+    return { message: "Workflow run event sent" };
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error sending workflow run event");
   }
 }
 
+exports.cancelWorkflowRunHandler = cancelWorkflowRunHandler;
 exports.createWorkflowRunHandler = createWorkflowRunHandler;
 exports.getWorkflowByIdHandler = getWorkflowByIdHandler;
 exports.getWorkflowRunByIdHandler = getWorkflowRunByIdHandler;
@@ -428,6 +506,7 @@ exports.getWorkflowRunsHandler = getWorkflowRunsHandler;
 exports.getWorkflowsHandler = getWorkflowsHandler;
 exports.resumeAsyncWorkflowHandler = resumeAsyncWorkflowHandler;
 exports.resumeWorkflowHandler = resumeWorkflowHandler;
+exports.sendWorkflowRunEventHandler = sendWorkflowRunEventHandler;
 exports.startAsyncWorkflowHandler = startAsyncWorkflowHandler;
 exports.startWorkflowRunHandler = startWorkflowRunHandler;
 exports.streamWorkflowHandler = streamWorkflowHandler;

package/dist/{chunk-2BCWG3EZ.js → chunk-BK4XT6EG.js}

@@ -1,7 +1,7 @@
 import { stringify, esm_default } from './chunk-MEGCYGBU.js';
-import { validateBody } from './chunk-H5PTF3Y4.js';
-import { handleError } from './chunk-M5ABIP7D.js';
-import { HTTPException } from './chunk-NYN7KFXL.js';
+import { validateBody } from './chunk-RSEO4XPX.js';
+import { handleError } from './chunk-LF7P5PLR.js';
+import { HTTPException } from './chunk-LCM566I4.js';
 import { __export } from './chunk-MLKGABMK.js';
 import { RuntimeContext } from '@mastra/core/runtime-context';
 
@@ -263,7 +263,7 @@ async function streamGenerateHandler({
     });
     return streamResponse;
   } catch (error) {
-    throw new HTTPException(error?.status ?? 500, { message: error?.message ?? "Error streaming from agent" });
+    return handleError(error, "error streaming agent response");
   }
 }
 

package/dist/chunk-CBFTEHOO.cjs

@@ -0,0 +1,157 @@
+'use strict';
+
+var chunkPZQDCRPV_cjs = require('./chunk-PZQDCRPV.cjs');
+var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
+
+// src/server/handlers/scores.ts
+var scores_exports = {};
+chunk75ZPJI57_cjs.__export(scores_exports, {
+  getScorerHandler: () => getScorerHandler,
+  getScorersHandler: () => getScorersHandler,
+  getScoresByEntityIdHandler: () => getScoresByEntityIdHandler,
+  getScoresByRunIdHandler: () => getScoresByRunIdHandler,
+  getScoresByScorerIdHandler: () => getScoresByScorerIdHandler,
+  saveScoreHandler: () => saveScoreHandler
+});
+async function getScorersFromSystem({
+  mastra,
+  runtimeContext
+}) {
+  const agents = mastra.getAgents();
+  const workflows = mastra.getWorkflows();
+  const scorersMap = /* @__PURE__ */ new Map();
+  for (const [agentId, agent] of Object.entries(agents)) {
+    const scorers = await agent.getScorers({
+      runtimeContext
+    }) || {};
+    if (Object.keys(scorers).length > 0) {
+      for (const [scorerId, scorer] of Object.entries(scorers)) {
+        if (scorersMap.has(scorerId)) {
+          scorersMap.get(scorerId)?.agentIds.push(agentId);
+        } else {
+          scorersMap.set(scorerId, {
+            workflowIds: [],
+            ...scorer,
+            agentIds: [agentId]
+          });
+        }
+      }
+    }
+  }
+  for (const [workflowId, workflow] of Object.entries(workflows)) {
+    const scorers = await workflow.getScorers({
+      runtimeContext
+    }) || {};
+    if (Object.keys(scorers).length > 0) {
+      for (const [scorerId, scorer] of Object.entries(scorers)) {
+        if (scorersMap.has(scorerId)) {
+          scorersMap.get(scorerId)?.workflowIds.push(workflowId);
+        } else {
+          scorersMap.set(scorerId, {
+            agentIds: [],
+            ...scorer,
+            workflowIds: [workflowId]
+          });
+        }
+      }
+    }
+  }
+  return Object.fromEntries(scorersMap.entries());
+}
+async function getScorersHandler({ mastra, runtimeContext }) {
+  const scorers = await getScorersFromSystem({
+    mastra,
+    runtimeContext
+  });
+  return scorers;
+}
+async function getScorerHandler({
+  mastra,
+  scorerId,
+  runtimeContext
+}) {
+  const scorers = await getScorersFromSystem({
+    mastra,
+    runtimeContext
+  });
+  const scorer = scorers[scorerId];
+  if (!scorer) {
+    return null;
+  }
+  return scorer;
+}
+async function getScoresByRunIdHandler({
+  mastra,
+  runId,
+  pagination
+}) {
+  try {
+    const scores = await mastra.getStorage()?.getScoresByRunId?.({
+      runId,
+      pagination
+    }) || [];
+    return scores;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting scores by run id");
+  }
+}
+async function getScoresByScorerIdHandler({
+  mastra,
+  scorerId,
+  pagination,
+  entityId,
+  entityType
+}) {
+  try {
+    const scores = await mastra.getStorage()?.getScoresByScorerId?.({
+      scorerId,
+      pagination,
+      entityId,
+      entityType
+    }) || [];
+    return scores;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting scores by scorer id");
+  }
+}
+async function getScoresByEntityIdHandler({
+  mastra,
+  entityId,
+  entityType,
+  pagination
+}) {
+  try {
+    let entityIdToUse = entityId;
+    if (entityType === "AGENT") {
+      const agent = mastra.getAgentById(entityId);
+      entityIdToUse = agent.id;
+    } else if (entityType === "WORKFLOW") {
+      const workflow = mastra.getWorkflowById(entityId);
+      entityIdToUse = workflow.id;
+    }
+    const scores = await mastra.getStorage()?.getScoresByEntityId?.({
+      entityId: entityIdToUse,
+      entityType,
+      pagination
+    }) || [];
+    return scores;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting scores by entity id");
+  }
+}
+async function saveScoreHandler({ mastra, score }) {
+  try {
+    const scores = await mastra.getStorage()?.saveScore?.(score) || [];
+    return scores;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error saving score");
+  }
+}
+
+exports.getScorerHandler = getScorerHandler;
+exports.getScorersHandler = getScorersHandler;
+exports.getScoresByEntityIdHandler = getScoresByEntityIdHandler;
+exports.getScoresByRunIdHandler = getScoresByRunIdHandler;
+exports.getScoresByScorerIdHandler = getScoresByScorerIdHandler;
+exports.saveScoreHandler = saveScoreHandler;
+exports.scores_exports = scores_exports;

package/dist/{chunk-57CJTIPW.cjs → chunk-CCGRCYWJ.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
+var chunk2KZFMI6P_cjs = require('./chunk-2KZFMI6P.cjs');
 
 // src/server/handlers/utils.ts
 function validateBody(body) {
@@ -11,7 +11,7 @@ function validateBody(body) {
     return acc;
   }, {});
   if (Object.keys(errorResponse).length > 0) {
-    throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: Object.values(errorResponse)[0] });
+    throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: Object.values(errorResponse)[0] });
   }
 }
 

package/dist/{chunk-C7564HUT.js → chunk-CRCR3ZUK.js}

@@ -1,6 +1,6 @@
-import { validateBody } from './chunk-H5PTF3Y4.js';
-import { handleError } from './chunk-M5ABIP7D.js';
-import { HTTPException } from './chunk-NYN7KFXL.js';
+import { validateBody } from './chunk-RSEO4XPX.js';
+import { handleError } from './chunk-LF7P5PLR.js';
+import { HTTPException } from './chunk-LCM566I4.js';
 import { __export } from './chunk-MLKGABMK.js';
 
 // src/server/handlers/network.ts