ARCADE_API_KEY={arcade_api_key}
ARCADE_USER_ID={arcade_user_id}

import { Arcade } from "@arcadeai/arcadejs";
import {
  toZodToolSet,
  executeOrAuthorizeZodTool,
} from "@arcadeai/arcadejs/lib/index";
 
const config = {
  // Get all tools from these MCP servers
  mcpServers: ["Slack"],
  // Add specific individual tools
  individualTools: ["Gmail_ListEmails", "Gmail_SendEmail", "Gmail_WhoAmI"],
};
 
// Maximum characters for any string field in tool output
// Keeps responses small while preserving structure (subjects, senders, snippets)
const MAX_STRING_CHARS = 300;
 
/**
 * Recursively truncates all large strings in objects/arrays.
 * This prevents token overflow when tool results pass back to the LLM.
 */
function truncateDeep(obj: unknown): unknown {
  if (obj === null || obj === undefined) return obj;
 
  if (typeof obj === "string") {
    if (obj.length > MAX_STRING_CHARS) {
      return obj.slice(0, MAX_STRING_CHARS) + "...";
    }
    return obj;
  }
 
  if (Array.isArray(obj)) {
    return obj.map(truncateDeep);
  }
 
  if (typeof obj === "object") {
    const result: Record<string, unknown> = {};
    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
      result[key] = truncateDeep(value);
    }
    return result;
  }
 
  return obj;
}
 
export async function getArcadeTools(userId: string) {
  const arcade = new Arcade();
 
  // Fetch tools from MCP servers
  const mcpTools = await Promise.all(
    config.mcpServers.map(async (server) => {
      const response = await arcade.tools.list({ toolkit: server });
      return response.items;
    })
  );
 
  // Fetch individual tools
  const individualTools = await Promise.all(
    config.individualTools.map((toolName) => arcade.tools.get(toolName))
  );
 
  // Combine all tools
  const allTools = [...mcpTools.flat(), ...individualTools];
 
  // Convert to Zod format for Mastra compatibility
  const zodTools = toZodToolSet({
    tools: allTools,
    client: arcade,
    userId,
    executeFactory: executeOrAuthorizeZodTool,
  });
 
  // Wrap tools with truncation and add 'id' property for Mastra Studio
  type ToolType = (typeof zodTools)[string] & { id: string };
  const mastraTools: Record<string, ToolType> = {};
 
  for (const [toolName, tool] of Object.entries(zodTools)) {
    const originalExecute = tool.execute;
    mastraTools[toolName] = {
      ...tool,
      id: toolName,
      execute: async (input: unknown) => {
        const result = await originalExecute(input);
        return truncateDeep(result) as Awaited<ReturnType<typeof originalExecute>>;
      },
    } as ToolType;
  }
 
  return mastraTools;
}

import { Agent } from "@mastra/core/agent";
import { TokenLimiterProcessor, ToolCallFilter } from "@mastra/core/processors";
import { Memory } from "@mastra/memory";
import { LibSQLStore } from "@mastra/libsql";
import { openai } from "@ai-sdk/openai";
import { getArcadeTools } from "../tools/arcade";
 
const userId = process.env.ARCADE_USER_ID || "default-user";
 
// Fetch Arcade tools at startup
const arcadeTools = await getArcadeTools(userId);
 
// Configure memory with conversation history
const memory = new Memory({
  storage: new LibSQLStore({
    id: "arcade-agent-memory",
    url: "file:memory.db",
  }),
  options: {
    lastMessages: 10,
  },
});
 
export const arcadeAgent = new Agent({
  id: "arcade-agent",
  name: "arcadeAgent",
  instructions: `You are a helpful assistant that can access Gmail and Slack.
Always use the available tools to fulfill user requests.
 
For Gmail:
- Use Gmail_ListEmails to fetch recent emails
- Use Gmail_SendEmail to send emails
- Use Gmail_WhoAmI to get the user's email address
- To find sent emails, use the query parameter with "in:sent"
- To find received emails, use "in:inbox" or no query
- When composing emails, use plain text (no markdown)
 
For Slack:
- Use Slack_SendMessage to send messages to channels or users
- Use Slack_ListChannels to see available channels
 
After completing any action, always confirm what you did with specific details.
 
IMPORTANT: When a tool returns an authorization response with a URL, tell the user to visit that URL to grant access. After they authorize, they can retry their request.`,
  model: openai("gpt-4o"),
  tools: arcadeTools,
  memory,
  // Filter out tool results from memory (they can be large) and limit tokens
  inputProcessors: [new ToolCallFilter(), new TokenLimiterProcessor({ limit: 50000 })],
});

import { Mastra } from "@mastra/core";
import { arcadeAgent } from "./agents/arcade";
 
export const mastra = new Mastra({
  agents: {
    arcadeAgent,
  },
});

import { createStep, createWorkflow } from "@mastra/core/workflows";
import { z } from "zod";
import { Arcade } from "@arcadeai/arcadejs";
 
const defaultUserId = process.env.ARCADE_USER_ID || "default-user";
 
// Step 1: Fetch emails from Gmail
const fetchEmails = createStep({
  id: "fetch-emails",
  inputSchema: z.object({
    userId: z.string().optional(),
    maxEmails: z.number().optional(),
  }),
  outputSchema: z.object({
    emails: z.array(z.object({
      subject: z.string(),
      from: z.string(),
      snippet: z.string(),
    })),
    userId: z.string(),
    authRequired: z.boolean().optional(),
    authUrl: z.string().optional(),
  }),
  execute: async ({ inputData }) => {
    const arcade = new Arcade();
    const userId = inputData?.userId || defaultUserId;
 
    try {
      const result = await arcade.tools.execute({
        tool_name: "Gmail_ListEmails",
        user_id: userId,
        input: { n_emails: inputData!.maxEmails ?? 5 },
      });
 
      const response = result as { output?: { value?: { emails?: any[] } } };
      const emails = (response.output?.value?.emails || []).map((e: any) => ({
        subject: String(e.subject || "(No subject)"),
        from: String(e.sender || e.from || "Unknown"),
        snippet: String(e.snippet || "").slice(0, 200),
      }));
 
      return { emails, userId };
    } catch (error: any) {
      // Handle authorization required error
      if (error.status === 403 || error.message?.includes("authorization")) {
        const authResponse = await arcade.auth.start({
          user_id: userId,
          provider: "google",
          scopes: ["https://www.googleapis.com/auth/gmail.readonly"],
        });
        return {
          emails: [],
          userId,
          authRequired: true,
          authUrl: authResponse.url,
        };
      }
      throw error;
    }
  },
});
 
// Step 2: Summarize with LLM
const summarizeEmails = createStep({
  id: "summarize-emails",
  inputSchema: z.object({
    emails: z.array(z.object({
      subject: z.string(),
      from: z.string(),
      snippet: z.string(),
    })),
    userId: z.string(),
    authRequired: z.boolean().optional(),
    authUrl: z.string().optional(),
  }),
  outputSchema: z.object({
    summary: z.string(),
    userId: z.string(),
    authRequired: z.boolean().optional(),
    authUrl: z.string().optional(),
  }),
  execute: async ({ inputData, mastra }) => {
    const { emails, userId, authRequired, authUrl } = inputData!;
 
    // Pass through auth requirement
    if (authRequired) {
      return { summary: "", userId, authRequired, authUrl };
    }
 
    if (emails.length === 0) {
      return { summary: "No new emails.", userId };
    }
 
    const agent = mastra?.getAgent("arcadeAgent");
    const emailList = emails.map((e, i) =>
      `${i + 1}. From: ${e.from}\n   Subject: ${e.subject}\n   Preview: ${e.snippet}`
    ).join("\n\n");
 
    const response = await agent!.generate(
      `Summarize these emails in 2-3 bullet points:\n\n${emailList}`
    );
 
    return { summary: response.text, userId };
  },
});
 
// Step 3: Send DM to Slack user
const sendToSlack = createStep({
  id: "send-to-slack",
  inputSchema: z.object({
    summary: z.string(),
    userId: z.string(),
    authRequired: z.boolean().optional(),
    authUrl: z.string().optional(),
  }),
  outputSchema: z.object({
    success: z.boolean(),
    message: z.string(),
    authUrl: z.string().optional(),
  }),
  execute: async ({ inputData }) => {
    const { summary, userId, authRequired, authUrl } = inputData!;
 
    // Return auth URL if authorization is needed
    if (authRequired) {
      return {
        success: false,
        message: `Authorization required. Please visit this URL to grant access: ${authUrl}`,
        authUrl,
      };
    }
 
    const arcade = new Arcade();
 
    try {
      // Get the user's Slack identity
      const whoAmI = await arcade.tools.execute({
        tool_name: "Slack_WhoAmI",
        user_id: userId,
        input: {},
      });
 
      const slackUserId = (whoAmI as any)?.output?.value?.user_id;
 
      // Send DM to the user
      await arcade.tools.execute({
        tool_name: "Slack_SendMessage",
        user_id: userId,
        input: {
          message: `📬 *Email Digest*\n\n${summary}`,
          user_ids: [slackUserId],
        },
      });
 
      return { success: true, message: "Digest sent as DM" };
    } catch (error: any) {
      // Handle Slack authorization required
      if (error.status === 403 || error.message?.includes("authorization")) {
        const slackAuth = await arcade.auth.start({
          user_id: userId,
          provider: "slack",
          scopes: ["chat:write", "users:read"],
        });
        return {
          success: false,
          message: `Slack authorization required. Please visit: ${slackAuth.url}`,
          authUrl: slackAuth.url,
        };
      }
      throw error;
    }
  },
});
 
// Chain the steps together
const emailDigestWorkflow = createWorkflow({
  id: "email-digest",
  inputSchema: z.object({
    userId: z.string().default(defaultUserId),
    maxEmails: z.number().default(5),
  }),
  outputSchema: z.object({
    success: z.boolean(),
    message: z.string(),
    authUrl: z.string().optional(),
  }),
})
  .then(fetchEmails)
  .then(summarizeEmails)
  .then(sendToSlack);
 
emailDigestWorkflow.commit();
 
export { emailDigestWorkflow };

import { Mastra } from "@mastra/core";
import { arcadeAgent } from "./agents/arcade";
import { emailDigestWorkflow } from "./workflows/email-digest";
 
export const mastra = new Mastra({
  agents: {
    arcadeAgent,
  },
  workflows: {
    emailDigestWorkflow,
  },
});