feat: add Google Calendar integration via Composio

- Add calendar connect/disconnect tools in interaction worker
- Load calendar tools (create, update, delete, find free slots) in execution agent
- Add webhook handler for calendar event reminders (Event Starting Soon trigger)
- Add COMPOSIO_CALENDAR_AUTH_CONFIG_ID environment variable
- Update getComposioTools to support specific tool requests with higher limits

Author: caelinsutch

apps/execution-worker/src/durable-objects/execution-agent.ts

@@ -99,6 +99,44 @@ export class ExecutionAgent extends Agent<WorkerEnv, ExecutionState> {
           userId: input.userId,
         });
       }
+
+      // Add Google Calendar tools if user has an active connection
+      const calendarConnection = await checkUserConnection(
+        this.env.COMPOSIO_API_KEY,
+        input.userId,
+        "googlecalendar",
+      );
+
+      if (calendarConnection.connected) {
+        logger.info("Loading Calendar tools for user", {
+          userId: input.userId,
+        });
+
+        // Request specific calendar tools - must use exact Composio action names
+        const calendarTools = await getComposioTools(
+          this.env.COMPOSIO_API_KEY,
+          input.userId,
+          ["googlecalendar"],
+          [
+            "GOOGLECALENDAR_EVENTS_LIST_ALL_CALENDARS",
+            "GOOGLECALENDAR_CREATE_EVENT",
+            "GOOGLECALENDAR_UPDATE_EVENT",
+            "GOOGLECALENDAR_DELETE_EVENT",
+            "GOOGLECALENDAR_FIND_FREE_SLOTS",
+            "GOOGLECALENDAR_QUICK_ADD",
+          ],
+        );
+
+        Object.assign(tools, calendarTools);
+
+        logger.info("Calendar tools loaded successfully", {
+          calendarToolCount: Object.keys(calendarTools).length,
+        });
+      } else {
+        logger.info("No active Calendar connection for user", {
+          userId: input.userId,
+        });
+      }
     }
 
     return tools;

apps/execution-worker/src/services/composio-webhook-handler.ts

@@ -37,6 +37,57 @@ type ComposioV2EmailPayload = {
   };
 };
 
+// Composio V2 webhook format for calendar triggers
+// Trigger types from Composio:
+// - googlecalendar_event_starting_soon: Event is within configured minutes from starting
+// - googlecalendar_event_created: New event created
+// - googlecalendar_event_updated: Existing event modified
+// - googlecalendar_event_canceled_or_deleted: Event cancelled/deleted
+// - googlecalendar_attendee_response_changed: RSVP changed
+// - googlecalendar_calendar_event_sync: Full event data sync
+type ComposioV2CalendarPayload = {
+  type:
+    | "googlecalendar_event_starting_soon"
+    | "googlecalendar_event_created"
+    | "googlecalendar_event_updated"
+    | "googlecalendar_event_canceled_or_deleted"
+    | "googlecalendar_attendee_response_changed"
+    | "googlecalendar_calendar_event_sync";
+  timestamp: string;
+  log_id: string;
+  data: {
+    id: string;
+    event_id: string;
+    calendar_id?: string;
+    summary: string;
+    description?: string;
+    start?: {
+      dateTime?: string;
+      date?: string;
+      timeZone?: string;
+    };
+    end?: {
+      dateTime?: string;
+      date?: string;
+      timeZone?: string;
+    };
+    attendees?: Array<{
+      email: string;
+      displayName?: string;
+      responseStatus?: string;
+    }>;
+    location?: string;
+    // Event Starting Soon specific fields
+    countdown_minutes?: number;
+    start_time?: string;
+    connection_id: string;
+    connection_nano_id: string;
+    trigger_nano_id: string;
+    trigger_id: string;
+    user_id: string; // This is our Poppy userId
+  };
+};
+
 // Legacy email trigger format
 type EmailTriggerPayload = {
   event: "trigger";
@@ -73,7 +124,8 @@ type OAuthCallbackPayload = {
 type ComposioWebhookPayload =
   | OAuthCallbackPayload
   | EmailTriggerPayload
-  | ComposioV2EmailPayload;
+  | ComposioV2EmailPayload
+  | ComposioV2CalendarPayload;
 
 type EmailInfo = {
   messageId: string;
@@ -98,6 +150,20 @@ const isV2EmailPayload = (
   return "type" in payload && payload.type === "gmail_new_gmail_message";
 };
 
+const isV2CalendarPayload = (
+  payload: ComposioWebhookPayload,
+): payload is ComposioV2CalendarPayload => {
+  return (
+    "type" in payload &&
+    (payload.type === "googlecalendar_event_starting_soon" ||
+      payload.type === "googlecalendar_event_created" ||
+      payload.type === "googlecalendar_event_updated" ||
+      payload.type === "googlecalendar_event_canceled_or_deleted" ||
+      payload.type === "googlecalendar_attendee_response_changed" ||
+      payload.type === "googlecalendar_calendar_event_sync")
+  );
+};
+
 const isOAuthCallback = (
   payload: ComposioWebhookPayload,
 ): payload is OAuthCallbackPayload => {
@@ -116,6 +182,10 @@ export const handleComposioWebhook = async (
     return handleV2EmailTrigger(payload, env);
   }
 
+  if (isV2CalendarPayload(payload)) {
+    return handleV2CalendarTrigger(payload, env);
+  }
+
   if (isEmailTrigger(payload)) {
     return handleEmailTrigger(payload, env);
   }
@@ -419,3 +489,128 @@ Notify the user about this email. Keep it brief but informative.`;
     return { success: false, message: "Failed to notify user" };
   }
 };
+
+const handleV2CalendarTrigger = async (
+  payload: ComposioV2CalendarPayload,
+  env: WorkerEnv,
+): Promise<{ success: boolean; message: string }> => {
+  const calendarLogger = logger.withTags({ module: "v2-calendar-trigger" });
+
+  calendarLogger.info("Processing V2 calendar trigger", {
+    type: payload.type,
+    userId: payload.data.user_id,
+    eventSummary: payload.data.summary,
+  });
+
+  const userId = payload.data.user_id;
+
+  // Only notify for "Event Starting Soon" trigger
+  // Other events are informational - user initiated them or we don't need to notify
+  if (payload.type !== "googlecalendar_event_starting_soon") {
+    calendarLogger.info("Calendar event logged (non-reminder)", {
+      type: payload.type,
+      eventSummary: payload.data.summary,
+    });
+    return { success: true, message: "Calendar event logged" };
+  }
+
+  // Notify user about upcoming event
+  const eventInfo = {
+    eventId: payload.data.event_id,
+    summary: payload.data.summary,
+    description: payload.data.description,
+    start:
+      payload.data.start_time ||
+      payload.data.start?.dateTime ||
+      payload.data.start?.date,
+    location: payload.data.location,
+    attendees: payload.data.attendees?.map((a) => a.email).join(", "),
+    countdownMinutes: payload.data.countdown_minutes,
+  };
+
+  const db = getDb(env.HYPERDRIVE.connectionString);
+  return notifyUserAboutCalendarEvent(userId, eventInfo, db, env);
+};
+
+const notifyUserAboutCalendarEvent = async (
+  userId: string,
+  eventInfo: {
+    eventId: string;
+    summary: string;
+    description?: string;
+    start?: string;
+    location?: string;
+    attendees?: string;
+    countdownMinutes?: number;
+  },
+  db: Database,
+  env: WorkerEnv,
+): Promise<{ success: boolean; message: string }> => {
+  const notifyLogger = logger.withTags({ module: "calendar-notify" });
+
+  // Find user's conversation
+  const userConversation = await db
+    .select({ conversationId: conversationParticipants.conversationId })
+    .from(conversationParticipants)
+    .innerJoin(
+      conversations,
+      eq(conversations.id, conversationParticipants.conversationId),
+    )
+    .where(eq(conversationParticipants.userId, userId))
+    .orderBy(desc(conversations.updatedAt))
+    .limit(1);
+
+  if (userConversation.length === 0) {
+    notifyLogger.warn("No conversation found", { userId });
+    return { success: false, message: "No conversation found" };
+  }
+
+  const conversationId = userConversation[0].conversationId;
+
+  const interactionAgent = await db.query.agents.findFirst({
+    where: eq(agents.conversationId, conversationId),
+  });
+
+  if (!interactionAgent) {
+    notifyLogger.warn("No interaction agent found", { conversationId });
+    return { success: false, message: "No interaction agent found" };
+  }
+
+  const countdownText = eventInfo.countdownMinutes
+    ? `Starting in ${eventInfo.countdownMinutes} minutes`
+    : `Time: ${eventInfo.start || "Not specified"}`;
+
+  const taskDescription = `[CALENDAR REMINDER] Upcoming event:
+Event: ${eventInfo.summary}
+${countdownText}
+${eventInfo.location ? `Location: ${eventInfo.location}` : ""}
+${eventInfo.attendees ? `Attendees: ${eventInfo.attendees}` : ""}
+${eventInfo.description ? `Description: ${eventInfo.description}` : ""}
+
+Notify the user about this upcoming calendar event. Keep it brief but informative.`;
+
+  const executionAgentId = env.EXECUTION_AGENT.idFromName(interactionAgent.id);
+  const executionAgent = env.EXECUTION_AGENT.get(executionAgentId);
+
+  try {
+    await executionAgent.executeTask({
+      agentId: interactionAgent.id,
+      conversationId,
+      taskDescription,
+      userId,
+    });
+
+    notifyLogger.info("Calendar notification dispatched", {
+      userId,
+      eventSummary: eventInfo.summary,
+    });
+
+    return { success: true, message: "User notified" };
+  } catch (error) {
+    notifyLogger.error("Failed to dispatch calendar notification", {
+      error: error instanceof Error ? error.message : String(error),
+      userId,
+    });
+    return { success: false, message: "Failed to notify user" };
+  }
+};

apps/execution-worker/src/tools/gmail.ts

@@ -3,28 +3,34 @@ import { VercelProvider } from "@composio/vercel";
 import { logger } from "@poppy/hono-helpers";
 
 /**
- * Gets Gmail tools from Composio for use with Vercel AI SDK.
+ * Gets tools from Composio for use with Vercel AI SDK.
  * Uses the user's Poppy userId as the Composio userId.
  */
 export const getComposioTools = async (
   apiKey: string,
   userId: string,
   toolkits: string[] = ["gmail"],
+  specificTools?: string[],
 ) => {
   try {
     const composio = new Composio({
       apiKey,
       provider: new VercelProvider(),
     });
 
-    // Get tools using toolkits - userId must have an active connection
-    const tools = await composio.tools.get(userId, {
-      toolkits,
-    });
+    // If specific tools are requested, use the tools parameter
+    // Otherwise use toolkits with a high limit
+    const queryParams = specificTools
+      ? { tools: specificTools }
+      : { toolkits, limit: 100 };
+
+    const tools = await composio.tools.get(userId, queryParams);
 
     logger.info("Successfully loaded Composio tools", {
       toolCount: Object.keys(tools).length,
+      toolNames: Object.keys(tools),
       toolkits,
+      specificTools,
       userId,
     });
 
@@ -34,6 +40,7 @@ export const getComposioTools = async (
       error: error instanceof Error ? error.message : String(error),
       userId,
       toolkits,
+      specificTools,
     });
     return {};
   }