mastra 0.1.57-unstable.56 → 0.1.57-unstable.88

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

@@ -0,0 +1,95 @@
+import { createTool } from '@mastra/core';
+import { z } from 'zod';
+
+interface WeatherResponse {
+  current: {
+    time: string;
+    temperature_2m: number;
+    apparent_temperature: number;
+    relative_humidity_2m: number;
+    wind_speed_10m: number;
+    wind_gusts_10m: number;
+    weather_code: number;
+  };
+}
+
+export const weatherTool = createTool({
+  id: 'get-weather',
+  description: 'Get current weather for a location',
+  inputSchema: z.object({
+    location: z.string().describe('City name'),
+  }),
+  outputSchema: z.object({
+    temperature: z.number(),
+    feelsLike: z.number(),
+    humidity: z.number(),
+    windSpeed: z.number(),
+    windGust: z.number(),
+    conditions: z.string(),
+    location: z.string(),
+  }),
+  execute: async ({ context }) => {
+    return await getWeather(context.location);
+  },
+});
+
+const getWeather = async (location: string) => {
+  const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(location)}&count=1`;
+  const geocodingResponse = await fetch(geocodingUrl);
+  const geocodingData = await geocodingResponse.json();
+
+  if (!geocodingData.results?.[0]) {
+    throw new Error(`Location '${location}' not found`);
+  }
+
+  const { latitude, longitude, name } = geocodingData.results[0];
+
+  const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=temperature_2m,apparent_temperature,relative_humidity_2m,wind_speed_10m,wind_gusts_10m,weather_code`;
+
+  const response = await fetch(weatherUrl);
+  const data: WeatherResponse = await response.json();
+
+  return {
+    temperature: data.current.temperature_2m,
+    feelsLike: data.current.apparent_temperature,
+    humidity: data.current.relative_humidity_2m,
+    windSpeed: data.current.wind_speed_10m,
+    windGust: data.current.wind_gusts_10m,
+    conditions: getWeatherCondition(data.current.weather_code),
+    location: name,
+  };
+};
+
+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',
+    56: 'Light freezing drizzle',
+    57: 'Dense freezing drizzle',
+    61: 'Slight rain',
+    63: 'Moderate rain',
+    65: 'Heavy rain',
+    66: 'Light freezing rain',
+    67: 'Heavy freezing rain',
+    71: 'Slight snow fall',
+    73: 'Moderate snow fall',
+    75: 'Heavy snow fall',
+    77: 'Snow grains',
+    80: 'Slight rain showers',
+    81: 'Moderate rain showers',
+    82: 'Violent rain showers',
+    85: 'Slight snow showers',
+    86: 'Heavy snow showers',
+    95: 'Thunderstorm',
+    96: 'Thunderstorm with slight hail',
+    99: 'Thunderstorm with heavy hail',
+  };
+  return conditions[code] || 'Unknown';
+}

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;AAm/BzC,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,11 +142,11 @@ 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);
-        const messages = req.body.messages;
+        const { messages, threadId, resourceid } = req.body;
         const { ok, errorResponse } = await validateBody({
             messages,
         });
@@ -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);
-        res.json(result);
+        const result = await agent.generate(messages, { threadId, resourceid });
+        const textResult = {
+            text: result.text,
+            agent: agent.name,
+        };
+        res.json(textResult);
     }
     catch (error) {
         const apiError = error;
@@ -178,7 +182,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,
         });
@@ -186,12 +190,9 @@ 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);
     }
@@ -216,8 +217,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,
@@ -226,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 });
-        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;
@@ -256,8 +256,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,
@@ -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 });
+        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;
@@ -396,22 +394,50 @@ app.post('/api/workflows/:workflowId/execute', async (req, res) => {
     }
 });
 /**
- * GET /api/memory/threads/get-by-resourceid/{resourceid}
- * @summary Get threads by resource ID
+ * GET /api/memory/status
+ * @summary Get memory status
  * @tags Memory
- * @param {string} resourceid.path.required - Resource identifier
+ * @return {object} 200 - Memory status
+ * @return {Error} 500 - Server error
+ */
+app.get('/api/memory/status', async (_req, res) => {
+    try {
+        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;
+    }
+});
+/**
+ * GET /api/memory/threads
+ * @summary Get threads
+ * @tags Memory
+ * @param {string} resourceid.query.required - Resource identifier
  * @return {Thread[]} 200 - Array of threads
  * @return {Error} 400 - Memory not initialized
  * @return {Error} 500 - Server error
  */
-app.get('/api/memory/threads/get-by-resourceid/:resourceid', async (req, res) => {
+app.get('/api/memory/threads', async (req, res) => {
     try {
-        const resourceid = req.params.resourceid;
+        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);
     }
@@ -931,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"}