@mastra/server 0.0.0-taofeeqInngest-20250603090617 → 0.0.0-transpile-packages-20250724123433

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

package/dist/{chunk-ZE5AAC4I.cjs → chunk-FRVBFMO2.cjs}

@@ -1,11 +1,10 @@
 'use strict';
 
-var chunkYWLUOY3D_cjs = require('./chunk-YWLUOY3D.cjs');
-var chunk57CJTIPW_cjs = require('./chunk-57CJTIPW.cjs');
-var chunk64U3UDTH_cjs = require('./chunk-64U3UDTH.cjs');
-var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
+var chunkLI436ITD_cjs = require('./chunk-LI436ITD.cjs');
+var chunkCCGRCYWJ_cjs = require('./chunk-CCGRCYWJ.cjs');
+var chunkPZQDCRPV_cjs = require('./chunk-PZQDCRPV.cjs');
+var chunk2KZFMI6P_cjs = require('./chunk-2KZFMI6P.cjs');
 var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
-var di = require('@mastra/core/di');
 var tools = require('@mastra/core/tools');
 
 // src/server/handlers/tools.ts
@@ -26,8 +25,8 @@ async function getToolsHandler({ tools }) {
         const tool = _tool;
         acc[id] = {
           ...tool,
-          inputSchema: tool.inputSchema ? chunkYWLUOY3D_cjs.stringify(chunkYWLUOY3D_cjs.esm_default(tool.inputSchema)) : void 0,
-          outputSchema: tool.outputSchema ? chunkYWLUOY3D_cjs.stringify(chunkYWLUOY3D_cjs.esm_default(tool.outputSchema)) : void 0
+          inputSchema: tool.inputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(tool.inputSchema)) : void 0,
+          outputSchema: tool.outputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(tool.outputSchema)) : void 0
         };
         return acc;
       },
@@ -35,23 +34,23 @@ async function getToolsHandler({ tools }) {
     );
     return serializedTools;
   } catch (error) {
-    return chunk64U3UDTH_cjs.handleError(error, "Error getting tools");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting tools");
   }
 }
 async function getToolByIdHandler({ tools, toolId }) {
   try {
     const tool = Object.values(tools || {}).find((tool2) => tool2.id === toolId);
     if (!tool) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Tool not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Tool not found" });
     }
     const serializedTool = {
       ...tool,
-      inputSchema: tool.inputSchema ? chunkYWLUOY3D_cjs.stringify(chunkYWLUOY3D_cjs.esm_default(tool.inputSchema)) : void 0,
-      outputSchema: tool.outputSchema ? chunkYWLUOY3D_cjs.stringify(chunkYWLUOY3D_cjs.esm_default(tool.outputSchema)) : void 0
+      inputSchema: tool.inputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(tool.inputSchema)) : void 0,
+      outputSchema: tool.outputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(tool.outputSchema)) : void 0
     };
     return serializedTool;
   } catch (error) {
-    return chunk64U3UDTH_cjs.handleError(error, "Error getting tool");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting tool");
   }
 }
 function executeToolHandler(tools$1) {
@@ -60,38 +59,33 @@ function executeToolHandler(tools$1) {
     runId,
     toolId,
     data,
-    runtimeContext,
-    runtimeContextFromRequest
+    runtimeContext
   }) => {
     try {
       if (!toolId) {
-        throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Tool ID is required" });
+        throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Tool ID is required" });
       }
       const tool = Object.values(tools$1 || {}).find((tool2) => tool2.id === toolId);
       if (!tool) {
-        throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Tool not found" });
+        throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Tool not found" });
       }
       if (!tool?.execute) {
-        throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Tool is not executable" });
+        throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Tool is not executable" });
       }
-      chunk57CJTIPW_cjs.validateBody({ data });
+      chunkCCGRCYWJ_cjs.validateBody({ data });
       if (tools.isVercelTool(tool)) {
         const result2 = await tool.execute(data);
         return result2;
       }
-      const finalRuntimeContext = new di.RuntimeContext([
-        ...Array.from(runtimeContext.entries()),
-        ...Array.from(Object.entries(runtimeContextFromRequest ?? {}))
-      ]);
       const result = await tool.execute({
         context: data,
         mastra,
         runId,
-        runtimeContext: finalRuntimeContext
+        runtimeContext
       });
       return result;
     } catch (error) {
-      return chunk64U3UDTH_cjs.handleError(error, "Error executing tool");
+      return chunkPZQDCRPV_cjs.handleError(error, "Error executing tool");
     }
   };
 }
@@ -100,34 +94,30 @@ async function executeAgentToolHandler({
   agentId,
   toolId,
   data,
-  runtimeContext,
-  runtimeContextFromRequest
+  runtimeContext
 }) {
   try {
     const agent = agentId ? mastra.getAgent(agentId) : null;
     if (!agent) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Tool not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Tool not found" });
     }
-    const tool = Object.values(agent?.tools || {}).find((tool2) => tool2.id === toolId);
+    const agentTools = await agent.getTools({ runtimeContext });
+    const tool = Object.values(agentTools || {}).find((tool2) => tool2.id === toolId);
     if (!tool) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Tool not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Tool not found" });
     }
     if (!tool?.execute) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Tool is not executable" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Tool is not executable" });
     }
-    const finalRuntimeContext = new di.RuntimeContext([
-      ...Array.from(runtimeContext.entries()),
-      ...Array.from(Object.entries(runtimeContextFromRequest ?? {}))
-    ]);
     const result = await tool.execute({
       context: data,
-      runtimeContext: finalRuntimeContext,
+      runtimeContext,
       mastra,
       runId: agentId
     });
     return result;
   } catch (error) {
-    return chunk64U3UDTH_cjs.handleError(error, "Error executing tool");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error executing tool");
   }
 }
 

package/dist/{chunk-DJJIUEL2.js → chunk-G4L7OMCA.js}

@@ -1,7 +1,8 @@
-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 { generateEmptyFromSchema } from '@mastra/core';
 
 // src/server/handlers/memory.ts
 var memory_exports = {};
@@ -10,25 +11,44 @@ __export(memory_exports, {
   deleteThreadHandler: () => deleteThreadHandler,
   getMemoryStatusHandler: () => getMemoryStatusHandler,
   getMessagesHandler: () => getMessagesHandler,
+  getMessagesPaginatedHandler: () => getMessagesPaginatedHandler,
   getThreadByIdHandler: () => getThreadByIdHandler,
   getThreadsHandler: () => getThreadsHandler,
+  getWorkingMemoryHandler: () => getWorkingMemoryHandler,
   saveMessagesHandler: () => saveMessagesHandler,
-  updateThreadHandler: () => updateThreadHandler
+  updateThreadHandler: () => updateThreadHandler,
+  updateWorkingMemoryHandler: () => updateWorkingMemoryHandler
 });
-function getMemoryFromContext({
+async function getMemoryFromContext({
   mastra,
-  agentId
+  agentId,
+  networkId,
+  runtimeContext
 }) {
   const agent = agentId ? mastra.getAgent(agentId) : null;
   if (agentId && !agent) {
     throw new HTTPException(404, { message: "Agent not found" });
   }
-  const memory = agent?.getMemory?.() || mastra.getMemory();
-  return memory;
+  const network = networkId ? mastra.vnext_getNetwork(networkId) : null;
+  if (networkId && !network) {
+    throw new HTTPException(404, { message: "Network not found" });
+  }
+  if (agent) {
+    return agent?.getMemory() || mastra.getMemory();
+  }
+  if (network) {
+    return await network?.getMemory({ runtimeContext }) || mastra.getMemory();
+  }
+  return mastra.getMemory();
 }
-async function getMemoryStatusHandler({ mastra, agentId }) {
+async function getMemoryStatusHandler({
+  mastra,
+  agentId,
+  networkId,
+  runtimeContext
+}) {
   try {
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
       return { result: false };
     }
@@ -40,10 +60,12 @@ async function getMemoryStatusHandler({ mastra, agentId }) {
 async function getThreadsHandler({
   mastra,
   agentId,
-  resourceId
+  resourceId,
+  networkId,
+  runtimeContext
 }) {
   try {
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
     }
@@ -57,11 +79,13 @@ async function getThreadsHandler({
 async function getThreadByIdHandler({
   mastra,
   agentId,
-  threadId
+  threadId,
+  networkId,
+  runtimeContext
 }) {
   try {
     validateBody({ threadId });
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
     }
@@ -77,10 +101,12 @@ async function getThreadByIdHandler({
 async function saveMessagesHandler({
   mastra,
   agentId,
-  body
+  body,
+  networkId,
+  runtimeContext
 }) {
   try {
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
     }
@@ -104,10 +130,12 @@ async function saveMessagesHandler({
 async function createThreadHandler({
   mastra,
   agentId,
-  body
+  body,
+  networkId,
+  runtimeContext
 }) {
   try {
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
     }
@@ -127,10 +155,12 @@ async function updateThreadHandler({
   mastra,
   agentId,
   threadId,
-  body
+  body,
+  networkId,
+  runtimeContext
 }) {
   try {
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!body) {
       throw new HTTPException(400, { message: "Body is required" });
     }
@@ -161,11 +191,13 @@ async function updateThreadHandler({
 async function deleteThreadHandler({
   mastra,
   agentId,
-  threadId
+  threadId,
+  networkId,
+  runtimeContext
 }) {
   try {
     validateBody({ threadId });
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
     }
@@ -179,18 +211,43 @@ async function deleteThreadHandler({
     return handleError(error, "Error deleting thread");
   }
 }
+async function getMessagesPaginatedHandler({
+  mastra,
+  threadId,
+  resourceId,
+  selectBy,
+  format
+}) {
+  try {
+    validateBody({ threadId });
+    const storage = mastra.getStorage();
+    if (!storage) {
+      throw new HTTPException(400, { message: "Storage is not initialized" });
+    }
+    const thread = await storage.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: "Thread not found" });
+    }
+    const result = await storage.getMessagesPaginated({ threadId, resourceId, selectBy, format });
+    return result;
+  } catch (error) {
+    return handleError(error, "Error getting messages");
+  }
+}
 async function getMessagesHandler({
   mastra,
   agentId,
   threadId,
-  limit
+  limit,
+  networkId,
+  runtimeContext
 }) {
   if (limit !== void 0 && (!Number.isInteger(limit) || limit <= 0)) {
     throw new HTTPException(400, { message: "Invalid limit: must be a positive integer" });
   }
   try {
     validateBody({ threadId });
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
       throw new HTTPException(400, { message: "Memory is not initialized" });
     }
@@ -202,10 +259,62 @@ async function getMessagesHandler({
       threadId,
       ...limit && { selectBy: { last: limit } }
     });
-    return result;
+    return { messages: result.messages, uiMessages: result.uiMessages };
   } catch (error) {
     return handleError(error, "Error getting messages");
   }
 }
+async function getWorkingMemoryHandler({
+  mastra,
+  agentId,
+  threadId,
+  resourceId,
+  networkId,
+  runtimeContext,
+  memoryConfig
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    validateBody({ threadId });
+    if (!memory) {
+      throw new HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    const threadExists = !!thread;
+    const template = await memory.getWorkingMemoryTemplate({ memoryConfig });
+    const workingMemoryTemplate = template?.format === "json" ? { ...template, content: JSON.stringify(generateEmptyFromSchema(template.content)) } : template;
+    const workingMemory = await memory.getWorkingMemory({ threadId, resourceId, memoryConfig });
+    const config = memory.getMergedThreadConfig(memoryConfig || {});
+    const source = config.workingMemory?.scope === "resource" && resourceId ? "resource" : "thread";
+    return { workingMemory, source, workingMemoryTemplate, threadExists };
+  } catch (error) {
+    return handleError(error, "Error getting working memory");
+  }
+}
+async function updateWorkingMemoryHandler({
+  mastra,
+  agentId,
+  threadId,
+  body,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    const { resourceId, memoryConfig, workingMemory } = body;
+    if (!memory) {
+      throw new HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: "Thread not found" });
+    }
+    await memory.updateWorkingMemory({ threadId, resourceId, workingMemory, memoryConfig });
+    return { success: true };
+  } catch (error) {
+    return handleError(error, "Error updating working memory");
+  }
+}
 
-export { createThreadHandler, deleteThreadHandler, getMemoryStatusHandler, getMessagesHandler, getThreadByIdHandler, getThreadsHandler, memory_exports, saveMessagesHandler, updateThreadHandler };
+export { createThreadHandler, deleteThreadHandler, getMemoryStatusHandler, getMessagesHandler, getMessagesPaginatedHandler, getThreadByIdHandler, getThreadsHandler, getWorkingMemoryHandler, memory_exports, saveMessagesHandler, updateThreadHandler, updateWorkingMemoryHandler };

package/dist/{chunk-B4MQFJ7G.cjs → chunk-G7KH752Y.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-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');
 
 // src/server/handlers/telemetry.ts
@@ -15,13 +15,13 @@ async function getTelemetryHandler({ mastra, body }) {
     const telemetry = mastra.getTelemetry();
     const storage = mastra.getStorage();
     if (!telemetry) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Telemetry is not initialized" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Telemetry is not initialized" });
     }
     if (!storage) {
       return [];
     }
     if (!body) {
-      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Body is required" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Body is required" });
     }
     const { name, scope, page, perPage, attribute, fromDate, toDate } = body;
     const attributes = attribute ? Object.fromEntries(
@@ -41,7 +41,7 @@ async function getTelemetryHandler({ mastra, body }) {
     });
     return traces;
   } catch (error2) {
-    return chunk64U3UDTH_cjs.handleError(error2, "Error getting telemetry");
+    return chunkPZQDCRPV_cjs.handleError(error2, "Error getting telemetry");
   }
 }
 async function storeTelemetryHandler({ mastra, body }) {