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

package/dist/chunk-LFA7KZS6.cjs

@@ -0,0 +1,276 @@
+'use strict';
+
+var chunkASKESBJW_cjs = require('./chunk-ASKESBJW.cjs');
+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 agent = require('@mastra/core/agent');
+var runtimeContext = require('@mastra/core/runtime-context');
+
+// src/server/handlers/agents.ts
+var agents_exports = {};
+chunk75ZPJI57_cjs.__export(agents_exports, {
+  generateHandler: () => generateHandler,
+  getAgentByIdHandler: () => getAgentByIdHandler,
+  getAgentsHandler: () => getAgentsHandler,
+  getEvalsByAgentIdHandler: () => getEvalsByAgentIdHandler,
+  getLiveEvalsByAgentIdHandler: () => getLiveEvalsByAgentIdHandler,
+  streamGenerateHandler: () => streamGenerateHandler
+});
+async function getAgentsHandler({ mastra, runtimeContext }) {
+  try {
+    const agents = mastra.getAgents();
+    const serializedAgentsMap = await Promise.all(
+      Object.entries(agents).map(async ([id, agent]) => {
+        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] = {
+            ..._tool,
+            inputSchema: _tool.inputSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(_tool.inputSchema)) : void 0,
+            outputSchema: _tool.outputSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(_tool.outputSchema)) : void 0
+          };
+          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(),
+          defaultGenerateOptions,
+          defaultStreamOptions
+        };
+      })
+    );
+    const serializedAgents = serializedAgentsMap.reduce((acc, { id, ...rest }) => {
+      acc[id] = rest;
+      return acc;
+    }, {});
+    return serializedAgents;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting agents");
+  }
+}
+async function getAgentByIdHandler({
+  mastra,
+  runtimeContext,
+  agentId,
+  isPlayground = false
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const tools = await agent.getTools({ runtimeContext });
+    const serializedAgentTools = Object.entries(tools || {}).reduce((acc, [key, tool]) => {
+      const _tool = tool;
+      acc[key] = {
+        ..._tool,
+        inputSchema: _tool.inputSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(_tool.inputSchema)) : void 0,
+        outputSchema: _tool.outputSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(_tool.outputSchema)) : void 0
+      };
+      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,
+              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(),
+      defaultGenerateOptions,
+      defaultStreamOptions
+    };
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting agent");
+  }
+}
+async function getEvalsByAgentIdHandler({
+  mastra,
+  runtimeContext,
+  agentId
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    const evals = await mastra.getStorage()?.getEvalsByAgentName?.(agent.name, "test") || [];
+    const instructions = await agent.getInstructions({ runtimeContext });
+    return {
+      id: agentId,
+      name: agent.name,
+      instructions,
+      evals
+    };
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting test evals");
+  }
+}
+async function getLiveEvalsByAgentIdHandler({
+  mastra,
+  runtimeContext,
+  agentId
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    const evals = await mastra.getStorage()?.getEvalsByAgentName?.(agent.name, "live") || [];
+    const instructions = await agent.getInstructions({ runtimeContext });
+    return {
+      id: agentId,
+      name: agent.name,
+      instructions,
+      evals
+    };
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting live evals");
+  }
+}
+async function generateHandler({
+  mastra,
+  runtimeContext: runtimeContext$1,
+  agentId,
+  body
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const { messages, resourceId, resourceid, runtimeContext: agentRuntimeContext, ...rest } = body;
+    const finalResourceId = resourceId ?? resourceid;
+    const finalRuntimeContext = new runtimeContext.RuntimeContext([
+      ...Array.from(runtimeContext$1.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
+    chunk57CJTIPW_cjs.validateBody({ messages });
+    const result = await agent.generate(messages, {
+      ...rest,
+      // @ts-expect-error TODO fix types
+      resourceId: finalResourceId,
+      runtimeContext: finalRuntimeContext
+    });
+    return result;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error generating from agent");
+  }
+}
+async function streamGenerateHandler({
+  mastra,
+  runtimeContext: runtimeContext$1,
+  agentId,
+  body
+}) {
+  try {
+    const agent$1 = mastra.getAgent(agentId);
+    if (!agent$1) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const { messages, resourceId, runtimeContext: agentRuntimeContext, ...rest } = body;
+    const finalRuntimeContext = new runtimeContext.RuntimeContext([
+      ...Array.from(runtimeContext$1.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
+    chunk57CJTIPW_cjs.validateBody({ messages });
+    const streamResult = await agent$1.stream(messages, {
+      ...rest,
+      // @ts-expect-error TODO fix types
+      resourceId,
+      runtimeContext: finalRuntimeContext
+    });
+    const headers = {
+      "Transfer-Encoding": "chunked"
+    };
+    if (rest.output) {
+      return streamResult.toTextStreamResponse({ headers });
+    }
+    const useV4Compat = mastra.getAiSdkCompatMode() === "v4";
+    const uiMessageStream = streamResult.toUIMessageStreamResponse({
+      headers,
+      sendReasoning: true,
+      sendSources: true,
+      onError: (error) => {
+        return `An error occurred while processing your request. ${error instanceof Error ? error.message : JSON.stringify(error)}`;
+      }
+    });
+    const streamResponse = useV4Compat ? agent.createV4CompatibleResponse(uiMessageStream.body) : uiMessageStream;
+    return streamResponse;
+  } catch (error) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(error?.status ?? 500, { message: error?.message ?? "Error streaming from agent" });
+  }
+}
+
+exports.agents_exports = agents_exports;
+exports.generateHandler = generateHandler;
+exports.getAgentByIdHandler = getAgentByIdHandler;
+exports.getAgentsHandler = getAgentsHandler;
+exports.getEvalsByAgentIdHandler = getEvalsByAgentIdHandler;
+exports.getLiveEvalsByAgentIdHandler = getLiveEvalsByAgentIdHandler;
+exports.streamGenerateHandler = streamGenerateHandler;

package/dist/{chunk-3AHQ5RGN.js → chunk-M5ABIP7D.js}

@@ -1,4 +1,4 @@
-import { HTTPException } from './chunk-TRDNDNGQ.js';
+import { HTTPException } from './chunk-NYN7KFXL.js';
 
 // src/server/handlers/error.ts
 function handleError(error, defaultMessage) {

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export { __export };

package/dist/{chunk-2FJURXCL.cjs → chunk-NDAWJCUJ.cjs}

@@ -1,12 +1,13 @@
 'use strict';
 
-var chunkQN4KF3BH_cjs = require('./chunk-QN4KF3BH.cjs');
-var chunkZLBRQFDD_cjs = require('./chunk-ZLBRQFDD.cjs');
-var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+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');
 
 // src/server/handlers/memory.ts
 var memory_exports = {};
-chunkFV45V6WC_cjs.__export(memory_exports, {
+chunk75ZPJI57_cjs.__export(memory_exports, {
   createThreadHandler: () => createThreadHandler,
   deleteThreadHandler: () => deleteThreadHandler,
   getMemoryStatusHandler: () => getMemoryStatusHandler,
@@ -22,7 +23,7 @@ function getMemoryFromContext({
 }) {
   const agent = agentId ? mastra.getAgent(agentId) : null;
   if (agentId && !agent) {
-    throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Agent not found" });
+    throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
   }
   const memory = agent?.getMemory?.() || mastra.getMemory();
   return memory;
@@ -35,7 +36,7 @@ async function getMemoryStatusHandler({ mastra, agentId }) {
     }
     return { result: true };
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error getting memory status");
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting memory status");
   }
 }
 async function getThreadsHandler({
@@ -46,13 +47,13 @@ async function getThreadsHandler({
   try {
     const memory = getMemoryFromContext({ mastra, agentId });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
-    chunkQN4KF3BH_cjs.validateBody({ resourceId });
+    chunk57CJTIPW_cjs.validateBody({ resourceId });
     const threads = await memory.getThreadsByResourceId({ resourceId });
     return threads;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error getting threads");
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting threads");
   }
 }
 async function getThreadByIdHandler({
@@ -61,18 +62,18 @@ async function getThreadByIdHandler({
   threadId
 }) {
   try {
-    chunkQN4KF3BH_cjs.validateBody({ threadId });
+    chunk57CJTIPW_cjs.validateBody({ threadId });
     const memory = getMemoryFromContext({ mastra, agentId });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     const thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Thread not found" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Thread not found" });
     }
     return thread;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error getting thread");
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting thread");
   }
 }
 async function saveMessagesHandler({
@@ -83,13 +84,13 @@ async function saveMessagesHandler({
   try {
     const memory = getMemoryFromContext({ mastra, agentId });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     if (!body?.messages) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Messages are required" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Messages are required" });
     }
     if (!Array.isArray(body.messages)) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Messages should be an array" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Messages should be an array" });
     }
     const processedMessages = body.messages.map((message) => ({
       ...message,
@@ -99,7 +100,7 @@ async function saveMessagesHandler({
     const result = await memory.saveMessages({ messages: processedMessages, memoryConfig: {} });
     return result;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error saving messages");
+    return chunk64U3UDTH_cjs.handleError(error, "Error saving messages");
   }
 }
 async function createThreadHandler({
@@ -110,9 +111,9 @@ async function createThreadHandler({
   try {
     const memory = getMemoryFromContext({ mastra, agentId });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
-    chunkQN4KF3BH_cjs.validateBody({ resourceId: body?.resourceId });
+    chunk57CJTIPW_cjs.validateBody({ resourceId: body?.resourceId });
     const result = await memory.createThread({
       resourceId: body?.resourceId,
       title: body?.title,
@@ -121,7 +122,7 @@ async function createThreadHandler({
     });
     return result;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error saving thread to memory");
+    return chunk64U3UDTH_cjs.handleError(error, "Error saving thread to memory");
   }
 }
 async function updateThreadHandler({
@@ -133,17 +134,17 @@ async function updateThreadHandler({
   try {
     const memory = getMemoryFromContext({ mastra, agentId });
     if (!body) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Body is required" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Body is required" });
     }
     const { title, metadata, resourceId } = body;
     const updatedAt = /* @__PURE__ */ new Date();
-    chunkQN4KF3BH_cjs.validateBody({ threadId });
+    chunk57CJTIPW_cjs.validateBody({ threadId });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     const thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Thread not found" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Thread not found" });
     }
     const updatedThread = {
       ...thread,
@@ -156,7 +157,7 @@ async function updateThreadHandler({
     const result = await memory.saveThread({ thread: updatedThread });
     return result;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error updating thread");
+    return chunk64U3UDTH_cjs.handleError(error, "Error updating thread");
   }
 }
 async function deleteThreadHandler({
@@ -165,40 +166,59 @@ async function deleteThreadHandler({
   threadId
 }) {
   try {
-    chunkQN4KF3BH_cjs.validateBody({ threadId });
+    chunk57CJTIPW_cjs.validateBody({ threadId });
     const memory = getMemoryFromContext({ mastra, agentId });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     const thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Thread not found" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Thread not found" });
     }
     await memory.deleteThread(threadId);
     return { result: "Thread deleted" };
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error deleting thread");
+    return chunk64U3UDTH_cjs.handleError(error, "Error deleting thread");
   }
 }
 async function getMessagesHandler({
   mastra,
   agentId,
-  threadId
+  threadId,
+  limit,
+  format
 }) {
+  if (limit !== void 0 && (!Number.isInteger(limit) || limit <= 0)) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Invalid limit: must be a positive integer" });
+  }
   try {
-    chunkQN4KF3BH_cjs.validateBody({ threadId });
+    chunk57CJTIPW_cjs.validateBody({ threadId });
     const memory = getMemoryFromContext({ mastra, agentId });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     const thread = await memory.getThreadById({ threadId });
     if (!thread) {
-      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Thread not found" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Thread not found" });
     }
-    const result = await memory.query({ threadId });
-    return result;
+    const result = await memory.query({
+      threadId,
+      ...limit && { selectBy: { last: limit } }
+    });
+    let useV4Format = false;
+    if (format === "aiv4") {
+      useV4Format = true;
+    } else if (format === "aiv5") {
+      useV4Format = false;
+    } else {
+      useV4Format = mastra.getAiSdkCompatMode() === "v4";
+    }
+    if (useV4Format) {
+      return { messages: result.messages, uiMessages: result.uiMessagesV4 };
+    }
+    return { messages: result.messages, uiMessages: result.uiMessages };
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error getting messages");
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting messages");
   }
 }
 

package/dist/{chunk-D3G23FP3.cjs → chunk-NGURCFEJ.cjs}

@@ -1,14 +1,15 @@
 'use strict';
 
-var chunk5SWCVTNL_cjs = require('./chunk-5SWCVTNL.cjs');
-var chunkQN4KF3BH_cjs = require('./chunk-QN4KF3BH.cjs');
-var chunkZLBRQFDD_cjs = require('./chunk-ZLBRQFDD.cjs');
-var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+var chunkASKESBJW_cjs = require('./chunk-ASKESBJW.cjs');
+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 tools = require('@mastra/core/tools');
 
 // src/server/handlers/tools.ts
 var tools_exports = {};
-chunkFV45V6WC_cjs.__export(tools_exports, {
+chunk75ZPJI57_cjs.__export(tools_exports, {
   executeAgentToolHandler: () => executeAgentToolHandler,
   executeToolHandler: () => executeToolHandler,
   getToolByIdHandler: () => getToolByIdHandler,
@@ -24,8 +25,8 @@ async function getToolsHandler({ tools }) {
         const tool = _tool;
         acc[id] = {
           ...tool,
-          inputSchema: tool.inputSchema ? chunk5SWCVTNL_cjs.stringify(chunk5SWCVTNL_cjs.esm_default(tool.inputSchema)) : void 0,
-          outputSchema: tool.outputSchema ? chunk5SWCVTNL_cjs.stringify(chunk5SWCVTNL_cjs.esm_default(tool.outputSchema)) : void 0
+          inputSchema: tool.inputSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(tool.inputSchema)) : void 0,
+          outputSchema: tool.outputSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(tool.outputSchema)) : void 0
         };
         return acc;
       },
@@ -33,23 +34,23 @@ async function getToolsHandler({ tools }) {
     );
     return serializedTools;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error getting tools");
+    return chunk64U3UDTH_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 chunkFV45V6WC_cjs.HTTPException(404, { message: "Tool not found" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Tool not found" });
     }
     const serializedTool = {
       ...tool,
-      inputSchema: tool.inputSchema ? chunk5SWCVTNL_cjs.stringify(chunk5SWCVTNL_cjs.esm_default(tool.inputSchema)) : void 0,
-      outputSchema: tool.outputSchema ? chunk5SWCVTNL_cjs.stringify(chunk5SWCVTNL_cjs.esm_default(tool.outputSchema)) : void 0
+      inputSchema: tool.inputSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(tool.inputSchema)) : void 0,
+      outputSchema: tool.outputSchema ? chunkASKESBJW_cjs.stringify(chunkASKESBJW_cjs.esm_default(tool.outputSchema)) : void 0
     };
     return serializedTool;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error getting tool");
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting tool");
   }
 }
 function executeToolHandler(tools$1) {
@@ -62,16 +63,16 @@ function executeToolHandler(tools$1) {
   }) => {
     try {
       if (!toolId) {
-        throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Tool ID is required" });
+        throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Tool ID is required" });
       }
       const tool = Object.values(tools$1 || {}).find((tool2) => tool2.id === toolId);
       if (!tool) {
-        throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Tool not found" });
+        throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Tool not found" });
       }
       if (!tool?.execute) {
-        throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Tool is not executable" });
+        throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Tool is not executable" });
       }
-      chunkQN4KF3BH_cjs.validateBody({ data });
+      chunk57CJTIPW_cjs.validateBody({ data });
       if (tools.isVercelTool(tool)) {
         const result2 = await tool.execute(data);
         return result2;
@@ -84,7 +85,7 @@ function executeToolHandler(tools$1) {
       });
       return result;
     } catch (error) {
-      return chunkZLBRQFDD_cjs.handleError(error, "Error executing tool");
+      return chunk64U3UDTH_cjs.handleError(error, "Error executing tool");
     }
   };
 }
@@ -98,14 +99,15 @@ async function executeAgentToolHandler({
   try {
     const agent = agentId ? mastra.getAgent(agentId) : null;
     if (!agent) {
-      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Tool not found" });
+      throw new chunkOCWPVYNI_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 chunkFV45V6WC_cjs.HTTPException(404, { message: "Tool not found" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Tool not found" });
     }
     if (!tool?.execute) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Tool is not executable" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Tool is not executable" });
     }
     const result = await tool.execute({
       context: data,
@@ -115,7 +117,7 @@ async function executeAgentToolHandler({
     });
     return result;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error executing tool");
+    return chunk64U3UDTH_cjs.handleError(error, "Error executing tool");
   }
 }
 

package/dist/{chunk-TRDNDNGQ.js → chunk-NYN7KFXL.js}

@@ -1,9 +1,3 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
 // src/server/http-exception.ts
 var HTTPException = class extends Error {
   res;
@@ -37,4 +31,4 @@ var HTTPException = class extends Error {
   }
 };
 
-export { HTTPException, __export };
+export { HTTPException };

package/dist/{chunk-FV45V6WC.cjs → chunk-OCWPVYNI.cjs}

@@ -1,11 +1,5 @@
 'use strict';
 
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
 // src/server/http-exception.ts
 var HTTPException = class extends Error {
   res;
@@ -40,4 +34,3 @@ var HTTPException = class extends Error {
 };
 
 exports.HTTPException = HTTPException;
-exports.__export = __export;