Mastra

import { openai } from "@ai-sdk/openai";
// Or your chosen LLM provider instead of `openai`
import { Agent } from "@mastra/core/agent";
import { MCPConfiguration } from "@mastra/mcp";
import { CoreMessage } from "ai";
import chalk from "chalk";
import dotenv from "dotenv";
 
// Load environment variables
dotenv.config();
 
// --- Configuration ---
const RECALL_BUCKET_ALIAS = "mastra-guide-bucket"; // Choose a name for your test bucket
const OBJECT_KEY = "greeting";
const OBJECT_DATA = { message: "Hello from Mastra Core + Recall!" };
 
// --- Main Function ---
async function main(): Promise<void> {
  console.log(chalk.blue("🚀 Starting Mastra Agent with Recall Integration..."));
 
  // Will add code here...
}
 
// Run the main function
main().catch((error) => {
  console.error(chalk.red("Fatal error in main execution:"));
  console.error(error);
  process.exit(1);
});

async function main(): Promise<void> {
  // Existing code...
 
  // 1. Initialize MCP Configuration for Recall Server
  const mcp = new MCPConfiguration({
    servers: {
      recallMCP: {
        // You can name this server reference anything
        command: "npx", // Or 'npm' and 'exec'
        args: ["-y", "@recallnet/mcp"],
        // Pass necessary environment variables from this process to the MCP server
        env: {
          RECALL_PRIVATE_KEY: process.env.RECALL_PRIVATE_KEY || "",
          RECALL_NETWORK: process.env.RECALL_NETWORK || "testnet",
          RECALL_TOOLS: "all", // Expose all available Recall tools
        },
      },
    },
  });
 
  try {
    // 2. Get Toolsets from MCP
    // Mastra starts the configured MCP servers and retrieves their tool definitions
    console.log(chalk.blue("🔌 Initializing Recall MCP server and getting toolsets..."));
    const toolsets = await mcp.getToolsets();
    console.log(chalk.green("✅ Recall Toolsets obtained successfully!"));
 
    // 3. Define the AI Model
    // Ensure the corresponding API key is in your .env file
    const languageModel = openai("gpt-4o");
    // const languageModel = openai('gpt-4o'); // Example for OpenAI
 
    // 4. Create the Mastra Agent
    const agentInstructions = `You are an agent that uses Recall tools to manage persistent storage.
Available Recall tools are provided. Use them as needed to fulfill user requests.
When asked to store data, use get_or_create_bucket tool first, then add_object.
Confirm success after completing the requested action.`;
 
    const agent = new Agent({
      name: "RecallStorageAgent",
      instructions: agentInstructions,
      model: languageModel,
      // Note: Tools are passed during the stream/generate call in this pattern
    });
    console.log(chalk.blue(`🤖 Agent "${agent.name}" created.`));
 
    // 5. Prepare the Agent Request
    const userRequest = `Please ensure a bucket named '${RECALL_BUCKET_ALIAS}' exists, then store an object with key '${OBJECT_KEY}' and the following data: ${JSON.stringify(OBJECT_DATA)}`;
 
    const messages: CoreMessage[] = [
      // System instructions are often passed in the Agent constructor,
      // but can also be included here for more dynamic scenarios.
      { role: "system", content: agentInstructions },
      { role: "user", content: userRequest },
    ];
 
    // 6. Run the Agent and Stream Results
    console.log(chalk.yellow(`💬 Sending request to agent: "${userRequest}"`));
 
    const stream = await agent.stream(messages, {
      toolsets, // Provide the available tools to the agent for this run
      temperature: 0, // Lower temperature for more deterministic tool use
    });
 
    console.log(chalk.blue("🔄 Agent processing stream..."));
    let finalMessage = "";
    for await (const part of stream.fullStream) {
      switch (part.type) {
        case "error":
          console.error(chalk.red(`Error: ${part.error}`));
          break;
        case "text-delta":
          process.stdout.write(chalk.green(part.textDelta));
          finalMessage += part.textDelta;
          break;
        case "tool-call":
          console.log(
            chalk.magenta(
              `
🔧 Tool Call: ${part.toolName}(${JSON.stringify(part.args)})`
            )
          );
          break;
        case "tool-result":
          console.log(
            chalk.cyan(`⚙️ Tool Result (${part.toolName}): ${JSON.stringify(part.result)}`)
          );
          break;
        // Other types like 'finish' could be handled here if needed
      }
    }
    console.log(chalk.blue("\n🏁 Agent stream finished."));
    console.log(chalk.green(`✅ Agent's final response\n: ${finalMessage}`));
  } catch (error) {
    console.error(chalk.red("Agent execution failed:"));
    console.error(error);
  } finally {
    // Ensure MCP servers are shut down
    await mcp.disconnect();
    console.log(chalk.blue("🔌 MCP servers shut down."));
  }
}