@mastra/mcp-docs-server 1.0.0-beta.9 → 1.0.1

package/.docs/organized/code-examples/inngest.md

@@ -0,0 +1,1075 @@
+### package.json
+```json
+{
+  "name": "inngest",
+  "dependencies": {
+    "@hono/node-server": "^1.19.8",
+    "@inngest/realtime": "^0.4.5",
+    "@mastra/core": "1.0.0-beta.20",
+    "@mastra/deployer": "1.0.0-beta.20",
+    "@mastra/inngest": "1.0.0-beta.11",
+    "@mastra/libsql": "1.0.0-beta.11",
+    "@mastra/loggers": "1.0.0-beta.4",
+    "@mastra/observability": "1.0.0-beta.10",
+    "inngest": "^3.49.0",
+    "mastra": "1.0.0-beta.13",
+    "zod": "^3.25.76"
+  }
+}
+```
+
+### mastra/agents/planning-agent.ts
+```typescript
+import { Agent } from '@mastra/core/agent';
+
+// Create a new planning agent that uses the OpenAI model
+const planningAgent = new Agent({
+  id: 'planning-agent',
+  name: 'planningAgent',
+  model: 'openai/gpt-5.1',
+  instructions: `
+        You are a local activities and travel expert who excels at weather-based planning. Analyze the weather data and provide practical activity recommendations.
+
+        📅 [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.
+      `,
+});
+
+export { planningAgent };
+
+```
+
+### mastra/agents/trip-comparison-agent.ts
+```typescript
+import { Agent } from '@mastra/core/agent';
+
+const tripComparisonAgent = new Agent({
+  id: 'trip-comparison-agent',
+  name: 'tripComparisonAgent',
+  model: 'openai/gpt-4o-mini',
+  instructions: `You are a travel advisor who compares two city trip plans and provides a recommendation.
+
+Given activity plans for two cities, analyze:
+- Weather conditions in each city
+- Quality and variety of suggested activities
+- Overall trip experience potential
+
+Provide a concise comparison and recommend which city would be better for a trip, explaining your reasoning.
+
+Keep your response brief and actionable.`,
+});
+
+export { tripComparisonAgent };
+
+```
+
+### mastra/index.ts
+```typescript
+import { Mastra } from '@mastra/core';
+import { serve as inngestServe } from '@mastra/inngest';
+import { PinoLogger } from '@mastra/loggers';
+import { Observability, ConsoleExporter, DefaultExporter } from '@mastra/observability';
+import { activityPlanningWorkflow, inngest } from './workflows/inngest-workflow';
+import { defaultActivityPlanningWorkflow } from './workflows/default-workflow';
+import { parallelCityComparisonWorkflow } from './workflows/inngest-parallel-workflow';
+import { defaultParallelCityComparisonWorkflow } from './workflows/default-parallel-workflow';
+import { planningAgent } from './agents/planning-agent';
+import { tripComparisonAgent } from './agents/trip-comparison-agent';
+import { LibSQLStore } from '@mastra/libsql';
+
+const storage = new LibSQLStore({
+  id: 'mastra-storage',
+  url: 'file:./mastra.db',
+});
+
+// Configure observability with tracing exporters
+// ConsoleExporter logs spans to console for debugging
+// DefaultExporter persists traces to storage for later analysis
+const observability = new Observability({
+  configs: {
+    default: {
+      serviceName: 'inngest-workflow-example',
+      exporters: [
+        new ConsoleExporter(), // Logs trace events to console
+        new DefaultExporter(), // Persists traces to storage
+      ],
+    },
+  },
+});
+
+// Create and configure the main Mastra instance
+export const mastra = new Mastra({
+  workflows: {
+    activityPlanningWorkflow,
+    defaultActivityPlanningWorkflow,
+    parallelCityComparisonWorkflow,
+    defaultParallelCityComparisonWorkflow,
+  },
+  agents: {
+    planningAgent,
+    tripComparisonAgent,
+  },
+  storage,
+  observability,
+  server: {
+    host: '0.0.0.0',
+    apiRoutes: [
+      {
+        path: '/api/inngest', // API endpoint for Inngest to send events to
+        method: 'ALL',
+        createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+      },
+    ],
+  },
+  logger: new PinoLogger({
+    name: 'Mastra',
+    level: 'info',
+  }),
+});
+
+```
+
+### mastra/workflows/default-parallel-workflow.ts
+```typescript
+import { createWorkflow, createStep } from '@mastra/core/workflows';
+import { z } from 'zod';
+
+function getWeatherCondition(code: number): string {
+  const conditions: Record<number, string> = {
+    0: 'Clear sky',
+    1: 'Mainly clear',
+    2: 'Partly cloudy',
+    3: 'Overcast',
+    45: 'Foggy',
+    51: 'Light drizzle',
+    61: 'Slight rain',
+    63: 'Moderate rain',
+    65: 'Heavy rain',
+    95: 'Thunderstorm',
+  };
+  return conditions[code] || 'Unknown';
+}
+
+const forecastSchema = z.object({
+  date: z.string(),
+  maxTemp: z.number(),
+  minTemp: z.number(),
+  precipitationChance: z.number(),
+  condition: z.string(),
+  location: z.string(),
+});
+
+const fetchWeatherA = createStep({
+  id: 'fetch-weather-a',
+  inputSchema: z.object({ cityA: z.string(), cityB: z.string() }),
+  outputSchema: forecastSchema,
+  execute: async ({ inputData }) => {
+    const city = inputData.cityA;
+    const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(city)}&count=1`;
+    const geocodingResponse = await fetch(geocodingUrl);
+    const geocodingData = (await geocodingResponse.json()) as {
+      results: { latitude: number; longitude: number; name: string }[];
+    };
+
+    if (!geocodingData.results?.[0]) {
+      throw new Error(`Location '${city}' not found`);
+    }
+
+    const { latitude, longitude, name } = geocodingData.results[0];
+
+    const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=precipitation,weathercode&timezone=auto,&hourly=precipitation_probability,temperature_2m`;
+    const response = await fetch(weatherUrl);
+    const data = (await response.json()) as {
+      current: { weathercode: number };
+      hourly: { precipitation_probability: number[]; temperature_2m: number[] };
+    };
+
+    return {
+      date: new Date().toISOString(),
+      maxTemp: Math.max(...data.hourly.temperature_2m),
+      minTemp: Math.min(...data.hourly.temperature_2m),
+      condition: getWeatherCondition(data.current.weathercode),
+      location: name,
+      precipitationChance: Math.max(...data.hourly.precipitation_probability),
+    };
+  },
+});
+
+const fetchWeatherB = createStep({
+  id: 'fetch-weather-b',
+  inputSchema: z.object({ cityA: z.string(), cityB: z.string() }),
+  outputSchema: forecastSchema,
+  execute: async ({ inputData }) => {
+    const city = inputData.cityB;
+    const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(city)}&count=1`;
+    const geocodingResponse = await fetch(geocodingUrl);
+    const geocodingData = (await geocodingResponse.json()) as {
+      results: { latitude: number; longitude: number; name: string }[];
+    };
+
+    if (!geocodingData.results?.[0]) {
+      throw new Error(`Location '${city}' not found`);
+    }
+
+    const { latitude, longitude, name } = geocodingData.results[0];
+
+    const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=precipitation,weathercode&timezone=auto,&hourly=precipitation_probability,temperature_2m`;
+    const response = await fetch(weatherUrl);
+    const data = (await response.json()) as {
+      current: { weathercode: number };
+      hourly: { precipitation_probability: number[]; temperature_2m: number[] };
+    };
+
+    return {
+      date: new Date().toISOString(),
+      maxTemp: Math.max(...data.hourly.temperature_2m),
+      minTemp: Math.min(...data.hourly.temperature_2m),
+      condition: getWeatherCondition(data.current.weathercode),
+      location: name,
+      precipitationChance: Math.max(...data.hourly.precipitation_probability),
+    };
+  },
+});
+
+const planActivitiesA = createStep({
+  id: 'plan-activities-a',
+  inputSchema: forecastSchema,
+  outputSchema: z.object({ activities: z.string(), location: z.string() }),
+  execute: async ({ inputData, mastra }) => {
+    const agent = mastra?.getAgent('planningAgent');
+    if (!agent) throw new Error('Planning agent not found');
+
+    const response = await agent.stream([
+      {
+        role: 'user',
+        content: `Based on the following weather forecast for ${inputData.location}, suggest appropriate activities:\n${JSON.stringify(inputData, null, 2)}`,
+      },
+    ]);
+
+    let activitiesText = '';
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+      activitiesText += chunk;
+    }
+
+    return { activities: activitiesText, location: inputData.location };
+  },
+});
+
+const planActivitiesB = createStep({
+  id: 'plan-activities-b',
+  inputSchema: forecastSchema,
+  outputSchema: z.object({ activities: z.string(), location: z.string() }),
+  execute: async ({ inputData, mastra }) => {
+    const agent = mastra?.getAgent('planningAgent');
+    if (!agent) throw new Error('Planning agent not found');
+
+    const response = await agent.stream([
+      {
+        role: 'user',
+        content: `Based on the following weather forecast for ${inputData.location}, suggest appropriate activities:\n${JSON.stringify(inputData, null, 2)}`,
+      },
+    ]);
+
+    let activitiesText = '';
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+      activitiesText += chunk;
+    }
+
+    return { activities: activitiesText, location: inputData.location };
+  },
+});
+
+const inputSchema = z.object({ cityA: z.string(), cityB: z.string() });
+
+// Nested workflow A: fetches weather and plans activities for cityA
+const defaultCityPlanWorkflowA = createWorkflow({
+  id: 'default-city-plan-workflow-a',
+  inputSchema,
+  outputSchema: z.object({ activities: z.string(), location: z.string() }),
+})
+  .then(fetchWeatherA)
+  .then(planActivitiesA);
+
+defaultCityPlanWorkflowA.commit();
+
+// Nested workflow B: fetches weather and plans activities for cityB
+const defaultCityPlanWorkflowB = createWorkflow({
+  id: 'default-city-plan-workflow-b',
+  inputSchema,
+  outputSchema: z.object({ activities: z.string(), location: z.string() }),
+})
+  .then(fetchWeatherB)
+  .then(planActivitiesB);
+
+defaultCityPlanWorkflowB.commit();
+
+const compareTripsDefault = createStep({
+  id: 'compare-trips',
+  inputSchema: z.object({
+    'default-city-plan-workflow-a': z.object({ activities: z.string(), location: z.string() }),
+    'default-city-plan-workflow-b': z.object({ activities: z.string(), location: z.string() }),
+  }),
+  outputSchema: z.object({ comparison: z.string() }),
+  execute: async ({ inputData, mastra }) => {
+    const agent = mastra?.getAgent('tripComparisonAgent');
+    if (!agent) throw new Error('Trip comparison agent not found');
+
+    const planA = inputData['default-city-plan-workflow-a'];
+    const planB = inputData['default-city-plan-workflow-b'];
+
+    const response = await agent.stream([
+      {
+        role: 'user',
+        content: `Compare these two city trip plans and recommend which is better:
+
+## ${planA.location}
+${planA.activities}
+
+## ${planB.location}
+${planB.activities}`,
+      },
+    ]);
+
+    let comparisonText = '';
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+      comparisonText += chunk;
+    }
+
+    return { comparison: comparisonText };
+  },
+});
+
+// Main workflow: runs both city plans in parallel, then compares them
+const defaultParallelCityComparisonWorkflow = createWorkflow({
+  id: 'default-parallel-city-comparison-workflow',
+  inputSchema,
+  outputSchema: z.object({ comparison: z.string() }),
+})
+  .parallel([defaultCityPlanWorkflowA, defaultCityPlanWorkflowB])
+  .then(compareTripsDefault)
+  .commit();
+
+export { defaultParallelCityComparisonWorkflow };
+
+```
+
+### mastra/workflows/default-workflow.ts
+```typescript
+import { createWorkflow, createStep } from '@mastra/core/workflows';
+import { z } from 'zod';
+
+// Helper function to convert weather codes to human-readable descriptions
+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 forecastSchema = z.object({
+  date: z.string(),
+  maxTemp: z.number(),
+  minTemp: z.number(),
+  precipitationChance: z.number(),
+  condition: z.string(),
+  location: z.string(),
+});
+
+const fetchWeatherDefault = createStep({
+  id: 'fetch-weather',
+  description: 'Fetches weather forecast for a given city',
+  inputSchema: z.object({
+    city: z.string(),
+  }),
+  outputSchema: forecastSchema,
+  execute: async ({ inputData }) => {
+    console.dir({ inputData }, { depth: null });
+    if (!inputData) {
+      throw new Error('Trigger data not found');
+    }
+
+    // Get latitude and longitude for the city
+    const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(inputData.city)}&count=1`;
+    const geocodingResponse = await fetch(geocodingUrl);
+    const geocodingData = (await geocodingResponse.json()) as {
+      results: { latitude: number; longitude: number; name: string }[];
+    };
+
+    if (!geocodingData.results?.[0]) {
+      throw new Error(`Location '${inputData.city}' not found`);
+    }
+
+    const { latitude, longitude, name } = geocodingData.results[0];
+
+    // Fetch weather data using the coordinates
+    const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=precipitation,weathercode&timezone=auto,&hourly=precipitation_probability,temperature_2m`;
+    const response = await fetch(weatherUrl);
+    const data = (await response.json()) as {
+      current: {
+        time: string;
+        precipitation: number;
+        weathercode: number;
+      };
+      hourly: {
+        precipitation_probability: number[];
+        temperature_2m: number[];
+      };
+    };
+
+    const forecast = {
+      date: new Date().toISOString(),
+      maxTemp: Math.max(...data.hourly.temperature_2m),
+      minTemp: Math.min(...data.hourly.temperature_2m),
+      condition: getWeatherCondition(data.current.weathercode),
+      location: name,
+      precipitationChance: data.hourly.precipitation_probability.reduce((acc, curr) => Math.max(acc, curr), 0),
+    };
+
+    return forecast;
+  },
+});
+
+const planActivitiesDefault = createStep({
+  id: 'plan-activities',
+  description: 'Suggests activities based on weather conditions',
+  inputSchema: forecastSchema,
+  outputSchema: z.object({
+    activities: z.string(),
+  }),
+  execute: async ({ inputData, mastra }) => {
+    const forecast = inputData;
+
+    if (!forecast) {
+      throw new Error('Forecast data not found');
+    }
+
+    const prompt = `Based on the following weather forecast for ${forecast.location}, suggest appropriate activities:
+      ${JSON.stringify(forecast, null, 2)}
+      `;
+
+    const agent = mastra?.getAgent('planningAgent');
+    if (!agent) {
+      throw new Error('Planning agent not found');
+    }
+
+    const response = await agent.stream([
+      {
+        role: 'user',
+        content: prompt,
+      },
+    ]);
+
+    let activitiesText = '';
+
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+      activitiesText += chunk;
+    }
+
+    return {
+      activities: activitiesText,
+    };
+  },
+});
+
+const planIndoorActivitiesDefault = createStep({
+  id: 'plan-indoor-activities',
+  description: 'Suggests indoor activities based on weather conditions',
+  inputSchema: forecastSchema,
+  outputSchema: z.object({
+    activities: z.string(),
+  }),
+  execute: async ({ inputData, mastra }) => {
+    const forecast = inputData;
+
+    if (!forecast) {
+      throw new Error('Forecast data not found');
+    }
+
+    const prompt = `In case it rains, plan indoor activities for ${forecast.location} on ${forecast.date}`;
+
+    const agent = mastra?.getAgent('planningAgent');
+    if (!agent) {
+      throw new Error('Planning agent not found');
+    }
+
+    const response = await agent.stream([
+      {
+        role: 'user',
+        content: prompt,
+      },
+    ]);
+
+    let activitiesText = '';
+
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+      activitiesText += chunk;
+    }
+
+    return {
+      activities: activitiesText,
+    };
+  },
+});
+
+// Same workflow structure but using the default (non-Inngest) engine
+const defaultActivityPlanningWorkflow = createWorkflow({
+  id: 'default-activity-planning-workflow',
+  inputSchema: z.object({
+    city: z.string().describe('The city to get the weather for'),
+  }),
+  outputSchema: z.object({
+    activities: z.string(),
+  }),
+})
+  .then(fetchWeatherDefault)
+  .branch([
+    [
+      // If precipitation chance is greater than 50%, suggest indoor activities
+      async ({ inputData }) => {
+        return inputData?.precipitationChance > 50;
+      },
+      planIndoorActivitiesDefault,
+    ],
+    [
+      // Otherwise, suggest a mix of activities
+      async ({ inputData }) => {
+        return inputData?.precipitationChance <= 50;
+      },
+      planActivitiesDefault,
+    ],
+  ]);
+
+defaultActivityPlanningWorkflow.commit();
+
+export { defaultActivityPlanningWorkflow };
+
+```
+
+### mastra/workflows/inngest-parallel-workflow.ts
+```typescript
+import { init } from '@mastra/inngest';
+import { z } from 'zod';
+import { inngest } from './inngest-workflow';
+
+const { createWorkflow, createStep } = init(inngest);
+
+function getWeatherCondition(code: number): string {
+  const conditions: Record<number, string> = {
+    0: 'Clear sky',
+    1: 'Mainly clear',
+    2: 'Partly cloudy',
+    3: 'Overcast',
+    45: 'Foggy',
+    51: 'Light drizzle',
+    61: 'Slight rain',
+    63: 'Moderate rain',
+    65: 'Heavy rain',
+    95: 'Thunderstorm',
+  };
+  return conditions[code] || 'Unknown';
+}
+
+const forecastSchema = z.object({
+  date: z.string(),
+  maxTemp: z.number(),
+  minTemp: z.number(),
+  precipitationChance: z.number(),
+  condition: z.string(),
+  location: z.string(),
+});
+
+const fetchWeatherA = createStep({
+  id: 'fetch-weather-a',
+  inputSchema: z.object({ cityA: z.string(), cityB: z.string() }),
+  outputSchema: forecastSchema,
+  execute: async ({ inputData }) => {
+    const city = inputData.cityA;
+    const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(city)}&count=1`;
+    const geocodingResponse = await fetch(geocodingUrl);
+
+    if (!geocodingResponse.ok) {
+      const errorBody = await geocodingResponse.text();
+      throw new Error(`Geocoding API error (${geocodingResponse.status}): ${errorBody} - URL: ${geocodingUrl}`);
+    }
+
+    const geocodingData = (await geocodingResponse.json()) as {
+      results: { latitude: number; longitude: number; name: string }[];
+    };
+
+    if (!geocodingData.results?.[0]) {
+      throw new Error(`Location '${city}' not found`);
+    }
+
+    const { latitude, longitude, name } = geocodingData.results[0];
+
+    const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=precipitation,weathercode&timezone=auto,&hourly=precipitation_probability,temperature_2m`;
+    const response = await fetch(weatherUrl);
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Weather API error (${response.status}): ${errorBody} - URL: ${weatherUrl}`);
+    }
+
+    const data = (await response.json()) as {
+      current: { weathercode: number };
+      hourly: { precipitation_probability: number[]; temperature_2m: number[] };
+    };
+
+    return {
+      date: new Date().toISOString(),
+      maxTemp: Math.max(...data.hourly.temperature_2m),
+      minTemp: Math.min(...data.hourly.temperature_2m),
+      condition: getWeatherCondition(data.current.weathercode),
+      location: name,
+      precipitationChance: Math.max(...data.hourly.precipitation_probability),
+    };
+  },
+});
+
+const fetchWeatherB = createStep({
+  id: 'fetch-weather-b',
+  inputSchema: z.object({ cityA: z.string(), cityB: z.string() }),
+  outputSchema: forecastSchema,
+  execute: async ({ inputData }) => {
+    const city = inputData.cityB;
+    const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(city)}&count=1`;
+    const geocodingResponse = await fetch(geocodingUrl);
+
+    if (!geocodingResponse.ok) {
+      const errorBody = await geocodingResponse.text();
+      throw new Error(`Geocoding API error (${geocodingResponse.status}): ${errorBody} - URL: ${geocodingUrl}`);
+    }
+
+    const geocodingData = (await geocodingResponse.json()) as {
+      results: { latitude: number; longitude: number; name: string }[];
+    };
+
+    if (!geocodingData.results?.[0]) {
+      throw new Error(`Location '${city}' not found`);
+    }
+
+    const { latitude, longitude, name } = geocodingData.results[0];
+
+    const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=precipitation,weathercode&timezone=auto,&hourly=precipitation_probability,temperature_2m`;
+    const response = await fetch(weatherUrl);
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Weather API error (${response.status}): ${errorBody} - URL: ${weatherUrl}`);
+    }
+
+    const data = (await response.json()) as {
+      current: { weathercode: number };
+      hourly: { precipitation_probability: number[]; temperature_2m: number[] };
+    };
+
+    return {
+      date: new Date().toISOString(),
+      maxTemp: Math.max(...data.hourly.temperature_2m),
+      minTemp: Math.min(...data.hourly.temperature_2m),
+      condition: getWeatherCondition(data.current.weathercode),
+      location: name,
+      precipitationChance: Math.max(...data.hourly.precipitation_probability),
+    };
+  },
+});
+
+const planActivitiesA = createStep({
+  id: 'plan-activities-a',
+  inputSchema: forecastSchema,
+  outputSchema: z.object({ activities: z.string(), location: z.string() }),
+  execute: async ({ inputData, mastra }) => {
+    const agent = mastra?.getAgent('planningAgent');
+    if (!agent) throw new Error('Planning agent not found');
+
+    const response = await agent.stream([
+      {
+        role: 'user',
+        content: `Based on the following weather forecast for ${inputData.location}, suggest appropriate activities:\n${JSON.stringify(inputData, null, 2)}`,
+      },
+    ]);
+
+    let activitiesText = '';
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+      activitiesText += chunk;
+    }
+
+    return { activities: activitiesText, location: inputData.location };
+  },
+});
+
+const planActivitiesB = createStep({
+  id: 'plan-activities-b',
+  inputSchema: forecastSchema,
+  outputSchema: z.object({ activities: z.string(), location: z.string() }),
+  execute: async ({ inputData, mastra }) => {
+    const agent = mastra?.getAgent('planningAgent');
+    if (!agent) throw new Error('Planning agent not found');
+
+    const response = await agent.stream([
+      {
+        role: 'user',
+        content: `Based on the following weather forecast for ${inputData.location}, suggest appropriate activities:\n${JSON.stringify(inputData, null, 2)}`,
+      },
+    ]);
+
+    let activitiesText = '';
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+      activitiesText += chunk;
+    }
+
+    return { activities: activitiesText, location: inputData.location };
+  },
+});
+
+const inputSchema = z.object({ cityA: z.string(), cityB: z.string() });
+
+// Nested workflow A: fetches weather and plans activities for cityA
+const cityPlanWorkflowA = createWorkflow({
+  id: 'city-plan-workflow-a',
+  inputSchema,
+  outputSchema: z.object({ activities: z.string(), location: z.string() }),
+})
+  .then(fetchWeatherA)
+  .then(planActivitiesA);
+
+cityPlanWorkflowA.commit();
+
+// Nested workflow B: fetches weather and plans activities for cityB
+const cityPlanWorkflowB = createWorkflow({
+  id: 'city-plan-workflow-b',
+  inputSchema,
+  outputSchema: z.object({ activities: z.string(), location: z.string() }),
+})
+  .then(fetchWeatherB)
+  .then(planActivitiesB);
+
+cityPlanWorkflowB.commit();
+
+const compareTrips = createStep({
+  id: 'compare-trips',
+  inputSchema: z.object({
+    'city-plan-workflow-a': z.object({ activities: z.string(), location: z.string() }),
+    'city-plan-workflow-b': z.object({ activities: z.string(), location: z.string() }),
+  }),
+  outputSchema: z.object({ comparison: z.string() }),
+  execute: async ({ inputData, mastra }) => {
+    const agent = mastra?.getAgent('tripComparisonAgent');
+    if (!agent) throw new Error('Trip comparison agent not found');
+
+    const planA = inputData['city-plan-workflow-a'];
+    const planB = inputData['city-plan-workflow-b'];
+
+    const response = await agent.stream([
+      {
+        role: 'user',
+        content: `Compare these two city trip plans and recommend which is better:
+
+## ${planA.location}
+${planA.activities}
+
+## ${planB.location}
+${planB.activities}`,
+      },
+    ]);
+
+    let comparisonText = '';
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+      comparisonText += chunk;
+    }
+
+    return { comparison: comparisonText };
+  },
+});
+
+// Main workflow: runs both city plans in parallel, then compares them
+const parallelCityComparisonWorkflow = createWorkflow({
+  id: 'parallel-city-comparison-workflow',
+  inputSchema,
+  outputSchema: z.object({ comparison: z.string() }),
+})
+  .parallel([cityPlanWorkflowA, cityPlanWorkflowB])
+  .then(compareTrips)
+  .commit();
+
+export { parallelCityComparisonWorkflow };
+
+```
+
+### mastra/workflows/inngest-workflow.ts
+```typescript
+import { realtimeMiddleware } from '@inngest/realtime/middleware';
+import { init } from '@mastra/inngest';
+import { Inngest } from 'inngest';
+import { z } from 'zod';
+
+// Create a single Inngest instance to be shared across the application
+export const inngest = new Inngest({
+  id: 'mastra',
+  baseUrl: `http://localhost:8288`, // URL of your local Inngest dev server
+  isDev: true,
+  middleware: [realtimeMiddleware()], // Enable real-time updates in the Inngest dashboard
+});
+
+const { createWorkflow, createStep } = init(inngest);
+
+// Helper function to convert weather codes to human-readable descriptions
+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 forecastSchema = z.object({
+  date: z.string(),
+  maxTemp: z.number(),
+  minTemp: z.number(),
+  precipitationChance: z.number(),
+  condition: z.string(),
+  location: z.string(),
+});
+
+const fetchWeather = createStep({
+  id: 'fetch-weather',
+  description: 'Fetches weather forecast for a given city',
+  inputSchema: z.object({
+    city: z.string(),
+  }),
+  outputSchema: forecastSchema,
+  execute: async ({ inputData }) => {
+    console.dir({ inputData }, { depth: null });
+    if (!inputData) {
+      throw new Error('Trigger data not found');
+    }
+
+    // Get latitude and longitude for the city
+    const geocodingUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(inputData.city)}&count=1`;
+    const geocodingResponse = await fetch(geocodingUrl);
+    const geocodingData = (await geocodingResponse.json()) as {
+      results: { latitude: number; longitude: number; name: string }[];
+    };
+
+    if (!geocodingData.results?.[0]) {
+      throw new Error(`Location '${inputData.city}' not found`);
+    }
+
+    const { latitude, longitude, name } = geocodingData.results[0];
+
+    // Fetch weather data using the coordinates
+    const weatherUrl = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=precipitation,weathercode&timezone=auto,&hourly=precipitation_probability,temperature_2m`;
+    const response = await fetch(weatherUrl);
+    const data = (await response.json()) as {
+      current: {
+        time: string;
+        precipitation: number;
+        weathercode: number;
+      };
+      hourly: {
+        precipitation_probability: number[];
+        temperature_2m: number[];
+      };
+    };
+
+    const forecast = {
+      date: new Date().toISOString(),
+      maxTemp: Math.max(...data.hourly.temperature_2m),
+      minTemp: Math.min(...data.hourly.temperature_2m),
+      condition: getWeatherCondition(data.current.weathercode),
+      location: name,
+      precipitationChance: data.hourly.precipitation_probability.reduce((acc, curr) => Math.max(acc, curr), 0),
+    };
+
+    return forecast;
+  },
+});
+
+const planActivities = createStep({
+  id: 'plan-activities',
+  description: 'Suggests activities based on weather conditions',
+  inputSchema: forecastSchema,
+  outputSchema: z.object({
+    activities: z.string(),
+  }),
+  execute: async ({ inputData, mastra }) => {
+    const forecast = inputData;
+
+    if (!forecast) {
+      throw new Error('Forecast data not found');
+    }
+
+    const prompt = `Based on the following weather forecast for ${forecast.location}, suggest appropriate activities:
+      ${JSON.stringify(forecast, null, 2)}
+      `;
+
+    const agent = mastra?.getAgent('planningAgent');
+    if (!agent) {
+      throw new Error('Planning agent not found');
+    }
+
+    const response = await agent.stream([
+      {
+        role: 'user',
+        content: prompt,
+      },
+    ]);
+
+    let activitiesText = '';
+
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+      activitiesText += chunk;
+    }
+
+    return {
+      activities: activitiesText,
+    };
+  },
+});
+
+const planIndoorActivities = createStep({
+  id: 'plan-indoor-activities',
+  description: 'Suggests indoor activities based on weather conditions',
+  inputSchema: forecastSchema,
+  outputSchema: z.object({
+    activities: z.string(),
+  }),
+  execute: async ({ inputData, mastra }) => {
+    const forecast = inputData;
+
+    if (!forecast) {
+      throw new Error('Forecast data not found');
+    }
+
+    const prompt = `In case it rains, plan indoor activities for ${forecast.location} on ${forecast.date}`;
+
+    const agent = mastra?.getAgent('planningAgent');
+    if (!agent) {
+      throw new Error('Planning agent not found');
+    }
+
+    const response = await agent.stream([
+      {
+        role: 'user',
+        content: prompt,
+      },
+    ]);
+
+    let activitiesText = '';
+
+    for await (const chunk of response.textStream) {
+      process.stdout.write(chunk);
+      activitiesText += chunk;
+    }
+
+    return {
+      activities: activitiesText,
+    };
+  },
+});
+
+const activityPlanningWorkflow = createWorkflow({
+  id: 'activity-planning-workflow-step2-if-else',
+  inputSchema: z.object({
+    city: z.string().describe('The city to get the weather for'),
+  }),
+  outputSchema: z.object({
+    activities: z.string(),
+  }),
+})
+  .then(fetchWeather)
+  .branch([
+    [
+      // If precipitation chance is greater than 50%, suggest indoor activities
+      async ({ inputData }) => {
+        return inputData?.precipitationChance > 50;
+      },
+      planIndoorActivities,
+    ],
+    [
+      // Otherwise, suggest a mix of activities
+      async ({ inputData }) => {
+        return inputData?.precipitationChance <= 50;
+      },
+      planActivities,
+    ],
+  ]);
+
+activityPlanningWorkflow.commit();
+
+export { activityPlanningWorkflow };
+
+```