mastra 0.1.57-unstable.57 → 0.1.57-unstable.89

package/dist/src/starter-files/workflow.ts

@@ -0,0 +1,173 @@
+import { Step, Workflow } from '@mastra/core';
+import { z } from 'zod';
+
+const fetchWeather = new Step({
+  id: 'fetch-weather',
+  description: 'Fetches weather forecast for a given city',
+  inputSchema: z.object({
+    city: z.string().describe('The city to get the weather for'),
+  }),
+  execute: async ({ context }) => {
+    const triggerData = context.machineContext?.getStepPayload<{ city: string }>('trigger');
+
+    if (!triggerData) {
+      throw new Error('Trigger data not found');
+    }
+
+    const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(triggerData.city)}&count=1`;
+    const geocodingResponse = await fetch(geocodingUrl);
+    const geocodingData = await geocodingResponse.json();
+
+    if (!geocodingData.results?.[0]) {
+      throw new Error(`Location '${triggerData.city}' not found`);
+    }
+
+    const { latitude, longitude, name } = geocodingData.results[0];
+
+    const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&daily=temperature_2m_max,temperature_2m_min,precipitation_probability_mean,weathercode&timezone=auto`;
+    const response = await fetch(weatherUrl);
+    const data = await response.json();
+
+    const forecast = data.daily.time.map((date: string, index: number) => ({
+      date,
+      maxTemp: data.daily.temperature_2m_max[index],
+      minTemp: data.daily.temperature_2m_min[index],
+      precipitationChance: data.daily.precipitation_probability_mean[index],
+      condition: getWeatherCondition(data.daily.weathercode[index]),
+      location: name,
+    }));
+
+    return forecast;
+  },
+});
+
+const forecastSchema = z.array(
+  z.object({
+    date: z.string(),
+    maxTemp: z.number(),
+    minTemp: z.number(),
+    precipitationChance: z.number(),
+    condition: z.string(),
+    location: z.string(),
+  }),
+);
+
+const planActivities = new Step({
+  id: 'plan-activities',
+  description: 'Suggests activities based on weather conditions',
+  inputSchema: forecastSchema,
+  execute: async ({ context, mastra }) => {
+    const forecast = context.machineContext?.getStepPayload<z.infer<typeof forecastSchema>>('fetch-weather');
+
+    if (!forecast) {
+      throw new Error('Forecast data not found');
+    }
+
+    const prompt = `Based on the following weather forecast for ${forecast[0].location}, suggest appropriate activities:
+      ${JSON.stringify(forecast, null, 2)}
+      `;
+
+    if (!mastra?.llm) {
+      throw new Error('Mastra not found');
+    }
+
+    const llm = mastra.llm({
+      provider: 'OPEN_AI',
+      name: 'gpt-4o',
+    });
+
+    const response = await llm.stream([
+      {
+        role: 'system',
+        content: `You are a local activities and travel expert who excels at weather-based planning. Analyze the weather data and provide practical activity recommendations.
+
+        For each day in the forecast, structure your response exactly as follows:
+
+        📅 [Day, Month Date, Year]
+        ═══════════════════════════
+
+        🌡️ WEATHER SUMMARY
+        • Conditions: [brief description]
+        • Temperature: [X°C/Y°F to A°C/B°F]
+        • Precipitation: [X% chance]
+
+        🌅 MORNING ACTIVITIES
+        Outdoor:
+        • [Activity Name] - [Brief description including specific location/route]
+          Best timing: [specific time range]
+          Note: [relevant weather consideration]
+
+        🌞 AFTERNOON ACTIVITIES
+        Outdoor:
+        • [Activity Name] - [Brief description including specific location/route]
+          Best timing: [specific time range]
+          Note: [relevant weather consideration]
+
+        🏠 INDOOR ALTERNATIVES
+        • [Activity Name] - [Brief description including specific venue]
+          Ideal for: [weather condition that would trigger this alternative]
+
+        ⚠️ SPECIAL CONSIDERATIONS
+        • [Any relevant weather warnings, UV index, wind conditions, etc.]
+
+        Guidelines:
+        - Suggest 2-3 time-specific outdoor activities per day
+        - Include 1-2 indoor backup options
+        - For precipitation >50%, lead with indoor activities
+        - All activities must be specific to the location
+        - Include specific venues, trails, or locations
+        - Consider activity intensity based on temperature
+        - Keep descriptions concise but informative
+
+        Maintain this exact formatting for consistency, using the emoji and section headers as shown.`,
+      },
+      {
+        role: 'user',
+        content: prompt,
+      },
+    ]);
+
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+    }
+
+    return {
+      activities: response.text,
+    };
+  },
+});
+
+function getWeatherCondition(code: number): string {
+  const conditions: Record<number, string> = {
+    0: 'Clear sky',
+    1: 'Mainly clear',
+    2: 'Partly cloudy',
+    3: 'Overcast',
+    45: 'Foggy',
+    48: 'Depositing rime fog',
+    51: 'Light drizzle',
+    53: 'Moderate drizzle',
+    55: 'Dense drizzle',
+    61: 'Slight rain',
+    63: 'Moderate rain',
+    65: 'Heavy rain',
+    71: 'Slight snow fall',
+    73: 'Moderate snow fall',
+    75: 'Heavy snow fall',
+    95: 'Thunderstorm',
+  };
+  return conditions[code] || 'Unknown';
+}
+
+const weatherWorkflow = new Workflow({
+  name: 'weather-workflow',
+  triggerSchema: z.object({
+    city: z.string().describe('The city to get the weather for'),
+  }),
+})
+  .step(fetchWeather)
+  .then(planActivities);
+
+weatherWorkflow.commit();
+
+export { weatherWorkflow };

package/dist/templates/express-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"express-server.d.ts","sourceRoot":"","sources":["../../src/templates/express-server.ts"],"names":[],"mappings":"AAGA,OAAO,UAAU,MAAM,iBAAiB,CAAC;AAmhCzC,eAAO,MAAM,OAAO,oBAAkB,CAAC;AAOvC,eAAe,OAAO,CAAC"}
+{"version":3,"file":"express-server.d.ts","sourceRoot":"","sources":["../../src/templates/express-server.ts"],"names":[],"mappings":"AAGA,OAAO,UAAU,MAAM,iBAAiB,CAAC;AAmhCzC,eAAO,MAAM,OAAO,oBAAkB,CAAC;AAQvC,eAAe,OAAO,CAAC"}

package/dist/templates/express-server.js

@@ -4,13 +4,17 @@ import _path, { join } from 'path';
 import serverless from 'serverless-http';
 import { stringify } from 'superjson';
 import { fileURLToPath as _fileURLToPath } from 'url';
+import { pathToFileURL } from 'url';
 import zodToJsonSchema from 'zod-to-json-schema';
 const ___filename = _fileURLToPath(import.meta.url);
 const ___dirname = _path.dirname(___filename);
-const { mastra } = await import(join(process.cwd(), 'mastra.mjs'));
+const mastraPath = pathToFileURL(join(process.cwd(), 'mastra.mjs')).href;
+const { mastra } = await import(mastraPath);
 const mastraToolsPaths = process.env.MASTRA_TOOLS_PATH;
 const toolImports = mastraToolsPaths
-    ? await Promise.all(mastraToolsPaths.split(',').map(toolPath => import(toolPath)))
+    ? await Promise.all(mastraToolsPaths.split(',').map(async (toolPath) => {
+        return import(pathToFileURL(toolPath).href);
+    }))
     : [];
 const tools = toolImports.reduce((acc, toolModule) => {
     Object.entries(toolModule).forEach(([key, tool]) => {
@@ -129,7 +133,7 @@ app.get('/api/agents', async (_req, res) => {
     }
 });
 /**
- * POST /api/agents/{agentId}/text
+ * POST /api/agents/{agentId}/generate
  * @summary Send text messages to agent
  * @tags Agent
  * @param {string} agentId.path.required - Agent identifier
@@ -138,7 +142,7 @@ app.get('/api/agents', async (_req, res) => {
  * @return {Error} 400 - Validation error
  * @return {Error} 500 - Server error
  */
-app.post('/api/agents/:agentId/text', async (req, res) => {
+app.post('/api/agents/:agentId/generate', async (req, res) => {
     try {
         const agentId = req.params.agentId;
         const agent = mastra.getAgent(agentId);
@@ -150,12 +154,12 @@ app.post('/api/agents/:agentId/text', async (req, res) => {
             res.status(400).json({ error: errorResponse });
             return;
         }
-        if (!Array.isArray(messages)) {
-            res.status(400).json({ error: { messages: 'Messages should be an array' } });
-            return;
-        }
         const result = await agent.generate(messages, { threadId, resourceid });
-        res.json(result);
+        const textResult = {
+            text: result.text,
+            agent: agent.name,
+        };
+        res.json(textResult);
     }
     catch (error) {
         const apiError = error;
@@ -186,12 +190,7 @@ app.post('/api/agents/:agentId/stream', async (req, res) => {
             res.status(400).json({ error: errorResponse });
             return;
         }
-        if (!Array.isArray(messages)) {
-            res.status(400).json({ error: { messages: 'Messages should be an array' } });
-            return;
-        }
-        const streamResult = await agent.generate(messages, {
-            stream: true,
+        const streamResult = await agent.stream(messages, {
             threadId,
             resourceid,
         });
@@ -227,12 +226,12 @@ app.post('/api/agents/:agentId/text-object', async (req, res) => {
             res.status(400).json({ error: errorResponse });
             return;
         }
-        if (!Array.isArray(messages)) {
-            res.status(400).json({ error: { messages: 'Messages should be an array' } });
-            return;
-        }
-        const result = await agent.generate(messages, { schema, threadId, resourceid });
-        res.json(result);
+        const result = await agent.generate(messages, { output: schema, threadId, resourceid });
+        const objectResult = {
+            object: result.object,
+            agent: result.agent,
+        };
+        res.json(objectResult);
     }
     catch (error) {
         const apiError = error;
@@ -266,11 +265,7 @@ app.post('/api/agents/:agentId/stream-object', async (req, res) => {
             res.status(400).json({ error: errorResponse });
             return;
         }
-        if (!Array.isArray(messages)) {
-            res.status(400).json({ error: { messages: 'Messages should be an array' } });
-            return;
-        }
-        const streamResult = await agent.generate(messages, { schema, stream: true, threadId, resourceid });
+        const streamResult = await agent.stream(messages, { output: schema, threadId, resourceid });
         streamResult.pipeTextStreamToResponse(res);
     }
     catch (error) {
@@ -323,7 +318,7 @@ app.post('/api/agents/:agentId/tools/:toolId/execute', async (req, res) => {
  */
 app.get('/api/workflows', async (_req, res) => {
     try {
-        const workflows = mastra.getWorkflows();
+        const workflows = mastra.getWorkflows({ serialized: true });
         res.json(workflows);
     }
     catch (error) {
@@ -358,7 +353,7 @@ app.get('/api/workflows/:workflowId', async (req, res) => {
             return acc;
         }, {});
         res.json({
-            ...workflow,
+            name: workflow.name,
             triggerSchema: triggerSchema ? stringify(zodToJsonSchema(triggerSchema)) : undefined,
             steps: serializedSteps,
             stepGraph,
@@ -377,7 +372,7 @@ app.get('/api/workflows/:workflowId', async (req, res) => {
  * @summary Execute a workflow
  * @tags Workflow
  * @param {string} workflowId.path.required - Workflow identifier
- * @param {object} request.body.required - Workflow input data
+ * @param {object} request.body.required - Workflow trigger data
  * @return {object} 200 - Workflow execution result
  * @return {Error} 500 - Server error
  */
@@ -385,8 +380,11 @@ app.post('/api/workflows/:workflowId/execute', async (req, res) => {
     try {
         const workflowId = req.params.workflowId;
         const workflow = mastra.getWorkflow(workflowId);
-        const result = await workflow.execute(req.body);
-        res.json(result);
+        const result = await workflow.execute({ triggerData: req.body });
+        res.json({
+            results: result?.results ?? {},
+            workflow: workflowId,
+        });
     }
     catch (error) {
         const apiError = error;
@@ -959,5 +957,6 @@ export const handler = serverless(app);
 app.listen(process.env.PORT || 4111, () => {
     console.log(`🦄Server running on port ${process.env.PORT || 4111}`);
     console.log(`📚 Open API documentation available at http://localhost:${process.env.PORT || 4111}/openapi.json`);
+    console.log(`👨‍💻 Playground available at http://localhost:${process.env.PORT || 4111}/`);
 });
 export default handler;

package/dist/templates/netlify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"netlify.d.ts","sourceRoot":"","sources":["../../src/templates/netlify.ts"],"names":[],"mappings":"AAEA,OAAO,UAAU,MAAM,iBAAiB,CAAC;AA4iBzC,eAAO,MAAM,OAAO,oBAAkB,CAAC"}
+{"version":3,"file":"netlify.d.ts","sourceRoot":"","sources":["../../src/templates/netlify.ts"],"names":[],"mappings":"AAGA,OAAO,UAAU,MAAM,iBAAiB,CAAC;AA0tBzC,eAAO,MAAM,OAAO,oBAAkB,CAAC"}

package/dist/templates/netlify.js

@@ -2,8 +2,21 @@ import express from 'express';
 import { join } from 'path';
 import serverless from 'serverless-http';
 import { stringify } from 'superjson';
+import { pathToFileURL } from 'url';
 import zodToJsonSchema from 'zod-to-json-schema';
 const { mastra } = await import(join(process.cwd(), 'mastra.mjs'));
+const mastraToolsPaths = process.env.MASTRA_TOOLS_PATH;
+const toolImports = mastraToolsPaths
+    ? await Promise.all(mastraToolsPaths.split(',').map(async (toolPath) => {
+        return import(pathToFileURL(toolPath).href);
+    }))
+    : [];
+const tools = toolImports.reduce((acc, toolModule) => {
+    Object.entries(toolModule).forEach(([key, tool]) => {
+        acc[key] = tool;
+    });
+    return acc;
+}, {});
 const app = express();
 app.use(express.json());
 const validateBody = async (body) => {
@@ -24,7 +37,24 @@ app.get('/', (_req, res) => {
 app.get('/api/agents', async (_req, res) => {
     try {
         const agents = mastra.getAgents();
-        res.json(agents);
+        const serializedAgents = Object.entries(agents).reduce((acc, [_id, _agent]) => {
+            const agent = _agent;
+            const serializedAgentTools = Object.entries(agent?.tools || {}).reduce((acc, [key, tool]) => {
+                const _tool = tool;
+                acc[key] = {
+                    ..._tool,
+                    inputSchema: _tool.inputSchema ? stringify(zodToJsonSchema(_tool.inputSchema)) : undefined,
+                    outputSchema: _tool.outputSchema ? stringify(zodToJsonSchema(_tool.outputSchema)) : undefined,
+                };
+                return acc;
+            }, {});
+            acc[_id] = {
+                ...agent,
+                tools: serializedAgentTools,
+            };
+            return acc;
+        }, {});
+        res.json(serializedAgents);
     }
     catch (error) {
         const apiError = error;
@@ -37,7 +67,19 @@ app.get('/api/agents/:agentId', async (req, res) => {
     try {
         const agentId = req.params.agentId;
         const agent = mastra.getAgent(agentId);
-        res.json(agent);
+        const serializedAgentTools = Object.entries(agent?.tools || {}).reduce((acc, [key, tool]) => {
+            const _tool = tool;
+            acc[key] = {
+                ..._tool,
+                inputSchema: _tool.inputSchema ? stringify(zodToJsonSchema(_tool.inputSchema)) : undefined,
+                outputSchema: _tool.outputSchema ? stringify(zodToJsonSchema(_tool.outputSchema)) : undefined,
+            };
+            return acc;
+        }, {});
+        res.json({
+            ...agent,
+            tools: serializedAgentTools,
+        });
     }
     catch (error) {
         const apiError = error;
@@ -46,11 +88,11 @@ app.get('/api/agents/:agentId', async (req, res) => {
         return;
     }
 });
-app.post('/api/agents/:agentId/text', async (req, res) => {
+app.post('/api/agents/:agentId/generate', async (req, res) => {
     try {
         const agentId = req.params.agentId;
         const agent = mastra.getAgent(agentId);
-        const messages = req.body.messages;
+        const { messages, threadId, resourceid } = req.body;
         const { ok, errorResponse } = await validateBody({
             messages,
         });
@@ -58,11 +100,7 @@ app.post('/api/agents/:agentId/text', async (req, res) => {
             res.status(400).json({ error: errorResponse });
             return;
         }
-        if (!Array.isArray(messages)) {
-            res.status(400).json({ error: { messages: 'Messages should be an array' } });
-            return;
-        }
-        const result = await agent.generate(messages);
+        const result = await agent.generate(messages, { threadId, resourceid });
         res.json(result);
     }
     catch (error) {
@@ -76,7 +114,7 @@ app.post('/api/agents/:agentId/stream', async (req, res) => {
     try {
         const agentId = req.params.agentId;
         const agent = mastra.getAgent(agentId);
-        const messages = req.body.messages;
+        const { messages, threadId, resourceid } = req.body;
         const { ok, errorResponse } = await validateBody({
             messages,
         });
@@ -84,11 +122,10 @@ app.post('/api/agents/:agentId/stream', async (req, res) => {
             res.status(400).json({ error: errorResponse });
             return;
         }
-        if (!Array.isArray(messages)) {
-            res.status(400).json({ error: { messages: 'Messages should be an array' } });
-            return;
-        }
-        const streamResult = await agent.generate(messages, { stream: true });
+        const streamResult = await agent.stream(messages, {
+            threadId,
+            resourceid,
+        });
         streamResult.pipeDataStreamToResponse(res);
     }
     catch (error) {
@@ -102,8 +139,7 @@ app.post('/api/agents/:agentId/text-object', async (req, res) => {
     try {
         const agentId = req.params.agentId;
         const agent = mastra.getAgent(agentId);
-        const messages = req.body.messages;
-        const schema = req.body.schema;
+        const { messages, schema, threadId, resourceid } = req.body;
         const { ok, errorResponse } = await validateBody({
             messages,
             schema,
@@ -112,11 +148,7 @@ app.post('/api/agents/:agentId/text-object', async (req, res) => {
             res.status(400).json({ error: errorResponse });
             return;
         }
-        if (!Array.isArray(messages)) {
-            res.status(400).json({ error: { messages: 'Messages should be an array' } });
-            return;
-        }
-        const result = await agent.generate(messages, { schema });
+        const result = await agent.generate(messages, { output: schema, threadId, resourceid });
         res.json(result);
     }
     catch (error) {
@@ -132,8 +164,7 @@ app.post('/api/agents/:agentId/stream-object', async (req, res) => {
     try {
         const agentId = req.params.agentId;
         const agent = mastra.getAgent(agentId);
-        const messages = req.body.messages;
-        const schema = req.body.schema;
+        const { messages, schema, threadId, resourceid } = req.body;
         const { ok, errorResponse } = await validateBody({
             messages,
             schema,
@@ -142,11 +173,7 @@ app.post('/api/agents/:agentId/stream-object', async (req, res) => {
             res.status(400).json({ error: errorResponse });
             return;
         }
-        if (!Array.isArray(messages)) {
-            res.status(400).json({ error: { messages: 'Messages should be an array' } });
-            return;
-        }
-        const streamResult = await agent.generate(messages, { schema, stream: true });
+        const streamResult = await agent.stream(messages, { output: schema, threadId, resourceid });
         streamResult.pipeTextStreamToResponse(res);
     }
     catch (error) {
@@ -158,9 +185,31 @@ app.post('/api/agents/:agentId/stream-object', async (req, res) => {
         return;
     }
 });
+app.post('/api/agents/:agentId/tools/:toolId/execute', async (req, res) => {
+    try {
+        const agentId = req.params.agentId;
+        const toolId = req.params.toolId;
+        const agent = mastra.getAgent(agentId);
+        const tool = Object.values(agent?.tools || {}).find((tool) => tool.id === toolId);
+        const result = await tool.execute({
+            context: {
+                ...req.body,
+            },
+            mastra,
+            runId: agentId,
+        });
+        res.json(result);
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error executing tool', apiError);
+        res.status(apiError.status || 500).json({ error: apiError.message || 'Error executing tool' });
+        return;
+    }
+});
 app.get('/api/workflows', async (_req, res) => {
     try {
-        const workflows = mastra.getWorkflows();
+        const workflows = mastra.getWorkflows({ serialized: true });
         res.json(workflows);
     }
     catch (error) {
@@ -175,9 +224,23 @@ app.get('/api/workflows/:workflowId', async (req, res) => {
         const workflowId = req.params.workflowId;
         const workflow = mastra.getWorkflow(workflowId);
         const triggerSchema = workflow.triggerSchema;
+        const stepGraph = workflow.stepGraph;
+        const stepSubscriberGraph = workflow.stepSubscriberGraph;
+        const serializedSteps = Object.entries(workflow.steps).reduce((acc, [key, step]) => {
+            const _step = step;
+            acc[key] = {
+                ..._step,
+                inputSchema: _step.inputSchema ? stringify(zodToJsonSchema(_step.inputSchema)) : undefined,
+                outputSchema: _step.outputSchema ? stringify(zodToJsonSchema(_step.outputSchema)) : undefined,
+            };
+            return acc;
+        }, {});
         res.json({
             ...workflow,
             triggerSchema: triggerSchema ? stringify(zodToJsonSchema(triggerSchema)) : undefined,
+            steps: serializedSteps,
+            stepGraph,
+            stepSubscriberGraph,
         });
     }
     catch (error) {
@@ -190,8 +253,7 @@ app.get('/api/workflows/:workflowId', async (req, res) => {
 app.post('/api/workflows/:workflowId/execute', async (req, res) => {
     try {
         const workflowId = req.params.workflowId;
-        const workflow = mastra.workflows.get(workflowId);
-        console.log('req.body', req.body);
+        const workflow = mastra.getWorkflow(workflowId);
         const result = await workflow.execute(req.body);
         res.json(result);
     }
@@ -202,14 +264,35 @@ app.post('/api/workflows/:workflowId/execute', async (req, res) => {
         return;
     }
 });
-app.get('/api/memory/threads/get-by-resourceid/:resourceid', async (req, res) => {
+app.get('/api/memory/status', async (_req, res) => {
     try {
-        const resourceid = req.params.resourceid;
+        const memory = mastra.memory;
+        if (!memory) {
+            res.json({ result: false });
+            return;
+        }
+        res.json({ result: true });
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error getting memory status', apiError);
+        res.status(apiError.status || 500).json({ error: apiError.message || 'Error getting memory status' });
+        return;
+    }
+});
+app.get('/api/memory/threads', async (req, res) => {
+    try {
+        const resourceid = req.query.resourceid;
         const memory = mastra.memory;
         if (!memory) {
             res.status(400).json({ error: 'Memory is not initialized' });
             return;
         }
+        const { ok, errorResponse } = await validateBody({ resourceid });
+        if (!ok) {
+            res.status(400).json({ error: errorResponse });
+            return;
+        }
         const threads = await memory.getThreadsByResourceId({ resourceid });
         res.json(threads);
     }
@@ -485,4 +568,86 @@ app.post('/api/syncs/:syncId/execute', async (req, res) => {
         return;
     }
 });
+app.get('/api/logs', async (_req, res) => {
+    try {
+        const logs = await mastra.getLogs();
+        res.json(logs);
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error getting logs', apiError);
+        res.status(apiError.status || 500).json({ error: apiError.message || 'Error getting logs' });
+        return;
+    }
+});
+app.get('/api/logs/:runId', async (req, res) => {
+    try {
+        const runId = req.params.runId;
+        const logs = await mastra.getLogsByRunId(runId);
+        res.json(logs);
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error getting logs', apiError);
+        res.status(apiError.status || 500).json({ error: apiError.message || 'Error getting logs' });
+        return;
+    }
+});
+app.get('/api/tools', async (_req, res) => {
+    if (tools) {
+        const serializedTools = Object.entries(tools).reduce((acc, [id, _tool]) => {
+            const tool = _tool;
+            acc[id] = {
+                ...tool,
+                inputSchema: tool.inputSchema ? stringify(zodToJsonSchema(tool.inputSchema)) : undefined,
+                outputSchema: tool.outputSchema ? stringify(zodToJsonSchema(tool.outputSchema)) : undefined,
+            };
+            return acc;
+        }, {});
+        res.json(serializedTools);
+    }
+    else {
+        res.status(200).json({});
+    }
+});
+app.get('/api/tools/:toolId', async (req, res) => {
+    const toolId = req.params.toolId;
+    const tool = Object.values(tools || {}).find((tool) => tool.id === toolId);
+    if (tool) {
+        const serializedTool = {
+            ...tool,
+            inputSchema: tool.inputSchema ? stringify(zodToJsonSchema(tool.inputSchema)) : undefined,
+            outputSchema: tool.outputSchema ? stringify(zodToJsonSchema(tool.outputSchema)) : undefined,
+        };
+        res.json(serializedTool);
+    }
+    else {
+        res.status(404).json({ error: 'Tool not found' });
+    }
+});
+app.post('/api/tools/:toolId/execute', async (req, res) => {
+    try {
+        const toolId = req.params.toolId;
+        const tool = Object.values(tools || {}).find((tool) => tool.id === toolId);
+        if (!tool) {
+            res.status(404).json({ error: 'Tool not found' });
+            return;
+        }
+        const { input } = req.body;
+        const result = await tool.execute({
+            context: {
+                ...input,
+            },
+            mastra,
+            runId: mastra.runId,
+        });
+        res.json(result);
+    }
+    catch (error) {
+        const apiError = error;
+        console.error('Error executing tool', apiError);
+        res.status(apiError.status || 500).json({ error: apiError.message || 'Error executing tool' });
+        return;
+    }
+});
 export const handler = serverless(app);

package/dist/templates/worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/templates/worker.ts"],"names":[],"mappings":"AAwBA,UAAU,gBAAgB;IACxB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACvC,sBAAsB,IAAI,IAAI,CAAC;CAChC;;mBAk0BsB,OAAO,OAAO,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,gBAAgB;;AADlF,wBAQE"}
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/templates/worker.ts"],"names":[],"mappings":"AA0CA,UAAU,gBAAgB;IACxB,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACvC,sBAAsB,IAAI,IAAI,CAAC;CAChC;;mBAshCsB,OAAO,OAAO,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,gBAAgB;;AADlF,wBAQE"}