import { Mastra } from "@mastra/core";
import { openai } from "@ai-sdk/openai";
import { Agent } from "@mastra/core/agent";
import { createWorkflow, createStep } from "@mastra/core/workflows/vNext";
import { z } from "zod";
 
const myAgent = new Agent({
  name: "myAgent",
  instructions: "You are a helpful assistant that answers questions concisely.",
  model: openai("gpt-4o"),
});
 
// Input preparation step
const preparationStep = createStep({
  id: "preparation",
  inputSchema: z.object({
      question: z.string()
  }),
  outputSchema: z.object({
      formattedPrompt: z.string()
  }),
  execute: async ({ inputData }) => {
      return {
          formattedPrompt: `Answer this question briefly: ${inputData.question}`
      };
  }
});
 
const agentStep = createStep(myAgent)
 
// Create a simple workflow
const myWorkflow = createWorkflow({
  id: "simple-qa-workflow",
  inputSchema: z.object({
      question: z.string()
  }),
  outputSchema: z.string(),
  steps: [preparationStep, agentStep]
});
 
// Define workflow sequence
myWorkflow
  .then(preparationStep)
  .map({
    prompt: {
        step: preparationStep,
        path: "formattedPrompt",
    },
  })
  .then(agentStep)
  .commit();
 
// Create Mastra instance
const mastra = new Mastra({
  agents: {
      myAgent,
  },
  vnext_workflows: {
      myWorkflow,
  },
});
 
const workflow = mastra.vnext_getWorkflow("myWorkflow");
const run = workflow.createRun();
 
// Run the workflow with a question
const res = await run.start({
  inputData: {
      question: "What is machine learning?"
  }
});
 
if (res.status === "success") {
  console.log("Answer:", res.result);
} else if (res.status === "failed") {
  console.error("Workflow failed:", res.error);
}
 

import { createTool, Mastra } from "@mastra/core";
import { createWorkflow, createStep } from "@mastra/core/workflows/vNext";
import { z } from "zod";
 
// Create a weather tool
const weatherTool = createTool({
  id: "weather-tool",
  description: "Get weather information for a location",
  inputSchema: z.object({
      location: z.string().describe("The city name")
  }),
  outputSchema: z.object({
      temperature: z.number(),
      conditions: z.string()
  }),
  execute: async ({ context: {location} }) => {
      return { 
          temperature: 22, 
          conditions: "Sunny" 
      };
  },
});
 
// Create a step that formats the input
const locationStep = createStep({
  id: "location-formatter",
  inputSchema: z.object({
      city: z.string()
  }),
  outputSchema: z.object({
      location: z.string()
  }),
  execute: async ({ inputData }) => {
      return {
          location: inputData.city
      };
  }
});
 
// Create a step that formats the output
const formatResultStep = createStep({
  id: "format-result",
  inputSchema: z.object({
      temperature: z.number(),
      conditions: z.string()
  }),
  outputSchema: z.object({
      weatherReport: z.string()
  }),
  execute: async ({ inputData }) => {
      return {
          weatherReport: `Current weather: ${inputData.temperature}°C and ${inputData.conditions}`
      };
  }
});
 
const weatherToolStep = createStep(weatherTool)
 
// Create the workflow
const weatherWorkflow = createWorkflow({
  id: "weather-workflow",
  inputSchema: z.object({
      city: z.string()
  }),
  outputSchema: z.object({
      weatherReport: z.string()
  }),
  steps: [locationStep, weatherToolStep, formatResultStep]
});
 
// Define workflow sequence
weatherWorkflow
  .then(locationStep)
  .then(weatherToolStep)
  .then(formatResultStep)
  .commit();
 
// Create Mastra instance
const mastra = new Mastra({
  vnext_workflows: {
      weatherWorkflow
  }
});
 
 
const workflow = mastra.vnext_getWorkflow("weatherWorkflow");
const run = workflow.createRun();
 
// Run the workflow
const result = await run.start({
  inputData: {
      city: "Tokyo"
  }
});
 
if (result.status === "success") {
  console.log(result.result.weatherReport);
} else if (result.status === "failed") {
  console.error("Workflow failed:", result.error);
}
 

import { openai } from "@ai-sdk/openai";
import { Mastra } from "@mastra/core";
import { Agent } from "@mastra/core/agent";
import { createTool } from "@mastra/core/tools";
import { createWorkflow, createStep } from "@mastra/core/workflows/vNext";
import { z } from "zod";
 
// Define the weather fetching step
const fetchWeather = createStep({
  id: "fetch-weather",
  inputSchema: z.object({
    city: z.string().describe("The city to get the weather for")
  }),
  outputSchema: z.object({
    temperature: z.number(),
    conditions: z.string(),
    city: z.string()
  }),
  execute: async ({ inputData }) => {
    return {
      temperature: 25,
      conditions: "Sunny",
      city: inputData.city
    };
  }
});
 
// Define the activity planning step
const planActivities = createStep({
  id: "plan-activities",
  inputSchema: z.object({
    temperature: z.number(),
    conditions: z.string(),
    city: z.string()
  }),
  outputSchema: z.object({
    activities: z.array(z.string())
  }),
  execute: async ({ inputData }) => {
    mastra.getLogger()?.debug(`Planning activities for ${inputData.city} based on weather`);
    const activities = [];
    
    if (inputData.temperature > 20 && inputData.conditions === "Sunny") {
      activities.push("Visit the park", "Go hiking", "Have a picnic");
    } else if (inputData.temperature < 10) {
      activities.push("Visit a museum", "Go to a cafe", "Indoor shopping");
    } else {
      activities.push("Sightseeing tour", "Visit local attractions", "Try local cuisine");
    }
    return {
      activities
    };
  }
});
 
// Create the weather workflow
const weatherWorkflow = createWorkflow({
  id: "weather-workflow",
  inputSchema: z.object({
    city: z.string().describe("The city to get the weather for")
  }),
  outputSchema: z.object({
    activities: z.array(z.string())
  }),
  steps: [fetchWeather, planActivities]
})
.then(fetchWeather)
.then(planActivities)
.commit();
 
// Create a tool that uses the workflow
const activityPlannerTool = createTool({
  id: "get-weather-specific-activities",
  description: "Get weather-specific activities for a city based on current weather conditions",
  inputSchema: z.object({
    city: z.string().describe("The city to get activities for")
  }),
  outputSchema: z.object({
    activities: z.array(z.string())
  }),
  execute: async ({ context: { city }, mastra }) => {
    mastra.getLogger()?.debug(`Tool executing for city: ${city}`);
    
    const workflow = mastra?.vnext_getWorkflow("weatherWorkflow");
    if (!workflow) {
      throw new Error("Weather workflow not found");
    }
    
    const run = workflow.createRun();
    const result = await run.start({
      inputData: {
        city: city
      }
    });
    
    if (result.status === "success") {
      return {
        activities: result.result.activities
      };
    }
    
    throw new Error(`Workflow execution failed: ${result.status}`);
  }
});
 
// Create an agent that uses the tool
const activityPlannerAgent = new Agent({
  name: "activityPlannerAgent",
  model: openai("gpt-4o"),
  instructions: `
  You are an activity planner. You suggest fun activities based on the weather in a city.
  Use the weather-specific activities tool to get activity recommendations.
  Format your response in a friendly, conversational way.
  `,
  tools: { activityPlannerTool }
});
 
// Create the Mastra instance
const mastra = new Mastra({
  vnext_workflows: {
    weatherWorkflow
  },
  agents: {
    activityPlannerAgent
  }
});
 
const response = await activityPlannerAgent.generate("What activities do you recommend for a visit to Tokyo?");
 
console.log("\nAgent response:");
console.log(response.text);