Test

app/api/emails/inbound/route.ts

@@ -0,0 +1,6 @@
+import type { NextRequest } from "next/server";
+import { handleInboundEmail } from "@/lib/emails/inbound/handleInboundEmail";
+
+export const POST = async (request: NextRequest) => {
+  return handleInboundEmail(request);
+};

lib/agents/generalAgent/getGeneralAgent.ts

@@ -0,0 +1,65 @@
+import { stepCountIs, ToolLoopAgent } from "ai";
+import { DEFAULT_MODEL } from "@/lib/const";
+import { RoutingDecision } from "@/lib/chat/types";
+import { extractImageUrlsFromMessages } from "@/lib/messages/extractImageUrlsFromMessages";
+import { buildSystemPromptWithImages } from "@/lib/chat/buildSystemPromptWithImages";
+import { getSystemPrompt } from "@/lib/prompts/getSystemPrompt";
+import { setupToolsForRequest } from "@/lib/chat/setupToolsForRequest";
+import { ChatRequestBody } from "@/lib/chat/validateChatRequest";
+import selectAccountEmails from "@/lib/supabase/account_emails/selectAccountEmails";
+import { selectAccountInfo } from "@/lib/supabase/account_info/selectAccountInfo";
+import { getKnowledgeBaseText } from "@/lib/files/getKnowledgeBaseText";
+import { getAccountWithDetails } from "@/lib/supabase/accounts/getAccountWithDetails";
+
+/**
+ * Gets the general agent for the chat
+ *
+ * @param body - The chat request body
+ * @returns The general agent
+ */
+export default async function getGeneralAgent(body: ChatRequestBody): Promise<RoutingDecision> {
+  const { accountId, messages, artistId, model: bodyModel } = body;
+
+  const accountEmails = await selectAccountEmails({ accountIds: accountId });
+  const email = accountEmails[0]?.email || undefined;
+
+  // Fetch artist instruction and knowledge base if artistId is provided
+  let artistInstruction: string | undefined;
+  let knowledgeBaseText: string | undefined;
+  if (artistId) {
+    const artistAccountInfo = await selectAccountInfo(artistId);
+    artistInstruction = artistAccountInfo?.instruction || undefined;
+    knowledgeBaseText = await getKnowledgeBaseText(artistAccountInfo?.knowledges);
+  }
+
+  const accountWithDetails = await getAccountWithDetails(accountId);
+  const baseSystemPrompt = getSystemPrompt({
+    roomId: body.roomId,
+    artistId,
+    accountId,
+    email,
+    artistInstruction,
+    knowledgeBaseText,
+    accountWithDetails,
+  });
+  const imageUrls = extractImageUrlsFromMessages(messages);
+  const instructions = buildSystemPromptWithImages(baseSystemPrompt, imageUrls);
+
+  const tools = await setupToolsForRequest(body);
+  const model = bodyModel || DEFAULT_MODEL;
+  const stopWhen = stepCountIs(111);
+
+  const agent = new ToolLoopAgent({
+    model,
+    instructions,
+    tools,
+    stopWhen,
+  });
+
+  return {
+    agent,
+    model,
+    instructions,
+    stopWhen,
+  };
+}

lib/ai/generateText.ts

@@ -0,0 +1,22 @@
+import { generateText as generate } from "ai";
+import { DEFAULT_MODEL } from "@/lib/const";
+
+const generateText = async ({
+  system,
+  prompt,
+  model,
+}: {
+  system?: string;
+  prompt: string;
+  model?: string;
+}) => {
+  const result = await generate({
+    system,
+    model: model || DEFAULT_MODEL,
+    prompt,
+  });
+
+  return result;
+};
+
+export default generateText;

lib/chat/buildSystemPromptWithImages.ts

@@ -0,0 +1,14 @@
+/**
+ * Appends image URLs to system prompt for GPT to extract for tool parameters
+ *
+ * @param basePrompt - The base system prompt
+ * @param imageUrls - Array of image URLs to append
+ * @returns System prompt with image URLs appended (if any)
+ */
+export function buildSystemPromptWithImages(basePrompt: string, imageUrls: string[]): string {
+  if (imageUrls.length === 0) {
+    return basePrompt;
+  }
+
+  return `${basePrompt}\n\n**ATTACHED IMAGE URLS (for edit_image imageUrl parameter):**\n${imageUrls.map((url, i) => `- Image ${i}: ${url}`).join("\n")}`;
+}

lib/chat/const.ts

@@ -0,0 +1,83 @@
+export const SYSTEM_PROMPT = `You are Recoup, a friendly, sharp, and strategic AI assistant specialized in the music industry. Your purpose is to help music executives, artist teams, and self-starting artists analyze fan data, optimize marketing strategies, and improve artist growth.
+
+⸻
+
+# Core Capabilities
+	1.	Artist Management: You can manage artist profiles, social media strategy, and overall marketing direction. Always use the available tools to fetch artist data when requested.
+	2.	Fan Analysis: You excel at analyzing fan demographics, engagement metrics, and behavioral segmentation. Always consider platform-specific metrics and patterns.
+	3.	Marketing Funnels: You identify conversion paths, diagnose bottlenecks, and suggest optimizations for acquisition and engagement.
+	4.	Social Media Strategy: You provide platform-specific recommendations tied to fan behavior and artist brand.
+	5.	Actionable Insights: You generate clear, data-informed, and instantly usable recommendations—not generic marketing advice.
+
+⸻
+
+# Specialized Knowledge
+	•	Music Industry Trends: You understand the realities of modern artist development, fan behavior, and campaign strategy.
+	•	Platform Optimization: You are fluent in the nuances of Spotify, TikTok, Instagram, YouTube, and more.
+	•	Fan Segmentation: You group fans based on behavior, geography, platform habits, and cultural signals.
+
+You do not give advice in a vacuum—you analyze everything in context. You understand the artists:
+	•	Genre and brand
+	•	Current career stage (emerging, breakout, legacy)
+	•	Cultural relevance
+	•	Position in the market
+
+What works for an underground rapper will not work for a legacy pop act. Your strategies adapt to the moment the artist is in.
+
+⸻
+
+# How You Think
+
+You are proactive. When fan or campaign data reveals a trend, niche, or opportunity, you surface it immediately—even if the user did not ask.
+
+Once you identify an opportunity (e.g., growing skateboarding interest in Asia), you think through all viable monetization paths:
+	1.	Content series targeting that niche
+	2.	Influencer partnerships
+	3.	Brand collaborations (tailored by artist tier)
+	4.	Artist collaborations
+	5.	Tour or live event strategies
+
+Then you figure out how to execute:
+	•	If it is a brand play, find regional brands likely to partner based on artist fit and engagement
+	•	If it is an influencer angle, identify relevant creators by niche and geography
+	•	If it is a touring strategy, suggest cities, venues, activations, and content ideas
+	•	Bundle insights into a multi-pronged campaign blueprint
+
+You may suggest one or multiple directions—depending on user interest and feasibility.
+
+⸻
+
+# How You Communicate
+
+You are:
+	•	Brief by default, expanding when needed
+	•	Conversational and collaborative—switch between telling and asking
+	•	Warm but strategic—no fluff, just clarity and sharp thinking
+	•	Always focused on next steps without overwhelming the user
+	•	User-friendly—avoid technical jargon like "bytes", "root directory", "storage keys", etc. Speak naturally about creating, updating, or managing files
+
+# Markdown Formatting
+
+Keep it simple:
+• Clarity first: short paragraphs; one idea per paragraph.
+• Gentle structure: use H2 for sections when helpful; avoid deep nesting.
+• Inline labels over bullets: for facets of one idea, use bold labels with a colon (e.g., Concept, Hook, CTA, Why) inline rather than bullets.
+• Bullets only when necessary: use bullets only for multiple parallel items; otherwise keep prose.
+• Subtle emphasis: bold for key terms; italics for nuance; keep headers plain.
+• Minimal extras: at most one callout or a simple table if it meaningfully improves scanning; avoid decorative elements.
+
+⸻
+
+🧷 Behavior Rules
+	•	Be proactive when insights emerge from fan or artist data
+	•	Always factor in the artists cultural relevance and career stage
+	•	Avoid generic advice—ground everything in actual data and user context
+	•	Suggest next steps clearly and strategically
+	•	Use tools or data to expand on viable monetization paths
+	•	Adjust depth and complexity based on the artists level (e.g., indie vs. major)
+	•	Acknowledge limitations and adapt creatively with what you can access
+	•	Do NOT ask for permission. Continue until you've accomplished the task
+
+⸻
+
+You impress by being useful. Every conversation should feel like something the user could not have come up with on their own.`;

lib/chat/createNewRoom.ts

@@ -0,0 +1,54 @@
+import { insertRoom } from "@/lib/supabase/rooms/insertRoom";
+import { generateChatTitle } from "@/lib/chat/generateChatTitle";
+import { sendNewConversationNotification } from "@/lib/telegram/sendNewConversationNotification";
+import { UIMessage } from "ai";
+import selectAccountEmails from "@/lib/supabase/account_emails/selectAccountEmails";
+
+interface CreateNewRoomParams {
+  accountId: string;
+  roomId: string;
+  artistId?: string;
+  lastMessage: UIMessage;
+}
+
+/**
+ * Creates a new room and sends a notification for a new conversation.
+ *
+ * @param params - The parameters for creating a new room
+ * @param params.accountId - The account ID
+ * @param params.roomId - The room ID
+ * @param params.artistId - Optional artist ID
+ * @param params.lastMessage - The last message from the conversation
+ * @returns void
+ */
+export async function createNewRoom({
+  accountId,
+  roomId,
+  artistId,
+  lastMessage,
+}: CreateNewRoomParams): Promise<void> {
+  const latestMessageText = lastMessage.parts.find(part => part.type === "text")?.text || "";
+  const conversationName = await generateChatTitle(latestMessageText);
+
+  let email = "";
+  const accountEmails = await selectAccountEmails({ accountIds: accountId });
+  if (accountEmails.length > 0 && accountEmails[0].email) {
+    email = accountEmails[0].email;
+  }
+
+  await Promise.all([
+    insertRoom({
+      account_id: accountId,
+      topic: conversationName,
+      artist_id: artistId || undefined,
+      id: roomId,
+    }),
+    sendNewConversationNotification({
+      accountId,
+      email,
+      conversationId: roomId,
+      topic: conversationName,
+      firstMessage: latestMessageText,
+    }),
+  ]);
+}

lib/chat/filterExcludedTools.ts

@@ -0,0 +1,20 @@
+import { ToolSet } from "ai";
+
+/**
+ * Filters out excluded tools from a tools object
+ *
+ * @param tools - The tools object to filter
+ * @param excludeTools - Array of tool names to exclude
+ * @returns Filtered tools object with excluded tools removed
+ */
+export function filterExcludedTools(tools: ToolSet, excludeTools?: string[]): ToolSet {
+  if (!excludeTools || excludeTools.length === 0) {
+    return tools;
+  }
+
+  const filteredTools = Object.fromEntries(
+    Object.entries(tools).filter(([toolName]) => !excludeTools.includes(toolName)),
+  );
+
+  return filteredTools as ToolSet;
+}

lib/chat/generateChatTitle.ts

@@ -0,0 +1,21 @@
+import generateText from "@/lib/ai/generateText";
+import { LIGHTWEIGHT_MODEL } from "@/lib/const";
+
+/**
+ * Generates a brief, formal title (max 20 characters) based on the given question context.
+ * Highlights segment names if present in the question.
+ *
+ * @param question - The question or context to generate a title for
+ * @returns A promise that resolves to the generated title string
+ */
+export async function generateChatTitle(question: string): Promise<string> {
+  const response = await generateText({
+    prompt: `Provide a brief title (more formal, no more than 20 characters!!!) that reflects the key elements of the given context. Do not wrap the title in quotes.
+        If the question is related to a segment or contains a segment name, highlight the segment name.
+        Context: ${question}`,
+    model: LIGHTWEIGHT_MODEL,
+  });
+
+  // In case model accidentally generates quotes again, remove them here
+  return response.text.replace(/^["']|["']$/g, "");
+}

lib/chat/setupToolsForRequest.ts

@@ -0,0 +1,28 @@
+import { ToolSet } from "ai";
+import { filterExcludedTools } from "./filterExcludedTools";
+import { ChatRequestBody } from "./validateChatRequest";
+import { experimental_createMCPClient as createMCPClient } from "@ai-sdk/mcp";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+/**
+ * Sets up and filters tools for a chat request.
+ * This is a simplified version that returns an empty tool set.
+ * In a full implementation, this would load MCP tools, Google Sheets tools, etc.
+ *
+ * @param body - The chat request body
+ * @returns Filtered tool set ready for use
+ */
+export async function setupToolsForRequest(body: ChatRequestBody): Promise<ToolSet> {
+  const { excludeTools } = body;
+
+  const mcpClient = await createMCPClient({
+    transport: new StreamableHTTPClientTransport(new URL("/mcp", "https://recoup-api.vercel.app")),
+  });
+
+  const mcpClientTools = (await mcpClient.tools()) as ToolSet;
+
+  const allTools: ToolSet = { ...mcpClientTools };
+
+  const tools = filterExcludedTools(allTools, excludeTools);
+  return tools;
+}

lib/chat/types.ts

@@ -0,0 +1,9 @@
+import { VercelToolCollection } from "@composio/vercel";
+import { type ToolSet, type StopCondition, type ToolLoopAgent } from "ai";
+
+export interface RoutingDecision {
+  model: string;
+  instructions: string;
+  agent: ToolLoopAgent<never, VercelToolCollection, never>;
+  stopWhen?: StopCondition<NoInfer<ToolSet>> | StopCondition<NoInfer<ToolSet>>[] | undefined;
+}

lib/chat/validateChatRequest.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+
+export const chatRequestSchema = z
+  .object({
+    // Chat content
+    prompt: z.string().optional(),
+    messages: z.array(z.any()).default([]),
+    // Core routing / context fields
+    roomId: z.string().optional(),
+    accountId: z.string().optional(),
+    artistId: z.string().optional(),
+    model: z.string().optional(),
+    excludeTools: z.array(z.string()).optional(),
+  })
+  .superRefine((data, ctx) => {
+    const hasMessages = Array.isArray(data.messages) && data.messages.length > 0;
+    const hasPrompt = typeof data.prompt === "string" && data.prompt.trim().length > 0;
+
+    if ((hasMessages && hasPrompt) || (!hasMessages && !hasPrompt)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Exactly one of messages or prompt must be provided",
+        path: ["messages"],
+      });
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Exactly one of messages or prompt must be provided",
+        path: ["prompt"],
+      });
+    }
+  });
+
+type BaseChatRequestBody = z.infer<typeof chatRequestSchema>;
+
+export type ChatRequestBody = BaseChatRequestBody & {
+  accountId: string;
+};

lib/coinbase/getAccount.ts

@@ -12,8 +12,6 @@ export async function getAccount(accountId: string): Promise<EvmServerAccount> {
     const account = await cdp.evm.getAccount({ name: accountId });
     return account;
   } catch {
-    // If account doesn't exist, create it
-    console.log(`[getAccount] Account ${accountId} not found, creating new account`);
     try {
       const newAccount = await cdp.evm.createAccount({ name: accountId });
       return newAccount;

lib/const.ts

@@ -10,4 +10,5 @@ export const USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as Addr
 export const PAYMASTER_URL = `https://api.developer.coinbase.com/rpc/v1/base/${process.env.PAYMASTER_KEY}`;
 export const IMAGE_GENERATE_PRICE = "0.15";
 export const DEFAULT_MODEL = "openai/gpt-5-mini";
+export const LIGHTWEIGHT_MODEL = "openai/gpt-4o-mini";
 export const PRIVY_PROJECT_SECRET = process.env.PRIVY_PROJECT_SECRET;