@hmawla/co-assistant 1.0.6 → 1.0.8

package/plugins/gmail/plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "gmail",
   "name": "Gmail Plugin",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Send, read, and search Gmail messages via the Gmail API",
   "author": "co-assistant",
   "requiredCredentials": [

package/plugins/gmail/tools.ts

@@ -117,7 +117,7 @@ export function createGmailTools(auth: GmailAuth, logger: Logger): ToolDefinitio
   const searchEmails: ToolDefinition = {
     name: "search_emails",
     description:
-      "Search for emails in Gmail using a query string (same syntax as the Gmail search bar)",
+      "Search for emails in Gmail. Returns metadata by default; set includeBody=true to also return full message bodies (avoids needing separate read_email calls).",
     parameters: z.object({
       /** Gmail search query (e.g. "from:alice subject:meeting"). */
       query: z.string().describe("Gmail search query"),
@@ -130,13 +130,21 @@ export function createGmailTools(auth: GmailAuth, logger: Logger): ToolDefinitio
         .optional()
         .default(10)
         .describe("Maximum number of results to return"),
+      /** When true, fetches full message bodies inline. Slower per message but
+       *  eliminates the need for separate read_email calls. */
+      includeBody: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Include full message body in results"),
     }),
 
     handler: async (args) => {
       try {
         const query = args.query as string;
         const maxResults = (args.maxResults as number | undefined) ?? 10;
-        logger.debug({ query, maxResults }, "search_emails called");
+        const includeBody = (args.includeBody as boolean | undefined) ?? false;
+        logger.debug({ query, maxResults, includeBody }, "search_emails called");
 
         // Step 1 — List message IDs matching the query.
         const params = new URLSearchParams({
@@ -162,32 +170,47 @@ export function createGmailTools(auth: GmailAuth, logger: Logger): ToolDefinitio
           return "No emails found matching that query.";
         }
 
-        // Step 2 — Fetch each message's metadata (Subject, From, Date, snippet).
+        // Step 2 — Fetch each message. Use "full" format when body is
+        // requested, otherwise "metadata" for a lighter response.
+        const format = includeBody ? "full" : "metadata";
         const headers = await authHeaders(auth);
         const results = await Promise.all(
           listData.messages.map(async (msg) => {
-            const msgRes = await fetch(
-              `${GMAIL_API}/messages/${msg.id}?format=metadata&metadataHeaders=Subject&metadataHeaders=From&metadataHeaders=Date`,
-              { headers },
-            );
+            const url = includeBody
+              ? `${GMAIL_API}/messages/${msg.id}?format=${format}`
+              : `${GMAIL_API}/messages/${msg.id}?format=${format}&metadataHeaders=Subject&metadataHeaders=From&metadataHeaders=Date`;
+            const msgRes = await fetch(url, { headers });
 
             if (!msgRes.ok) {
-              return { id: msg.id, error: `Failed to fetch (${msgRes.status})` };
+              return { id: msg.id, threadId: msg.threadId, error: `Failed to fetch (${msgRes.status})` };
             }
 
             const msgData = (await msgRes.json()) as {
               id: string;
+              threadId: string;
               snippet: string;
-              payload: { headers: Array<{ name: string; value: string }> };
+              payload: {
+                headers: Array<{ name: string; value: string }>;
+                body?: { data?: string };
+                parts?: Array<Record<string, unknown>>;
+                mimeType?: string;
+              };
             };
 
-            return {
+            const result: Record<string, unknown> = {
               id: msgData.id,
+              threadId: msgData.threadId,
               subject: getHeader(msgData.payload.headers, "Subject"),
               from: getHeader(msgData.payload.headers, "From"),
               date: getHeader(msgData.payload.headers, "Date"),
               snippet: msgData.snippet,
             };
+
+            if (includeBody) {
+              result.body = extractBody(msgData.payload as Record<string, unknown>);
+            }
+
+            return result;
           }),
         );
 
@@ -332,5 +355,211 @@ export function createGmailTools(auth: GmailAuth, logger: Logger): ToolDefinitio
     },
   };
 
-  return [searchEmails, readEmail, sendEmail];
+  // -----------------------------------------------------------------------
+  // get_thread
+  // -----------------------------------------------------------------------
+  const getThread: ToolDefinition = {
+    name: "get_thread",
+    description:
+      "Get all messages in a Gmail thread (including your sent replies). " +
+      "Use this to check if you already replied to a conversation before suggesting a new reply.",
+    parameters: z.object({
+      /** The Gmail thread ID (returned by search_emails or read_email). */
+      threadId: z.string().describe("Gmail thread ID"),
+    }),
+
+    handler: async (args) => {
+      try {
+        const threadId = args.threadId as string;
+        logger.debug({ threadId }, "get_thread called");
+
+        const res = await fetch(
+          `${GMAIL_API}/threads/${threadId}?format=metadata` +
+            "&metadataHeaders=Subject&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Date",
+          { headers: await authHeaders(auth) },
+        );
+
+        if (!res.ok) {
+          const errText = await res.text();
+          logger.error({ status: res.status, errText }, "Gmail get_thread failed");
+          return `Error getting thread (${res.status}): ${errText}`;
+        }
+
+        const data = (await res.json()) as {
+          id: string;
+          messages: Array<{
+            id: string;
+            labelIds: string[];
+            snippet: string;
+            payload: { headers: Array<{ name: string; value: string }> };
+          }>;
+        };
+
+        const messages = data.messages.map((msg) => ({
+          id: msg.id,
+          from: getHeader(msg.payload.headers, "From"),
+          to: getHeader(msg.payload.headers, "To"),
+          date: getHeader(msg.payload.headers, "Date"),
+          snippet: msg.snippet,
+          isSent: msg.labelIds?.includes("SENT") ?? false,
+        }));
+
+        return {
+          threadId: data.id,
+          messageCount: messages.length,
+          messages,
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error({ error: message }, "get_thread error");
+        return `Error getting thread: ${message}`;
+      }
+    },
+  };
+
+  // -----------------------------------------------------------------------
+  // search_threads  (single-call inbox analysis)
+  // -----------------------------------------------------------------------
+  const searchThreads: ToolDefinition = {
+    name: "search_threads",
+    description:
+      "Search Gmail and return results grouped by thread. Each thread includes " +
+      "ALL messages (including your sent replies) with isSent flags, so you can " +
+      "tell at a glance whether you already replied. Ideal for inbox review — " +
+      "returns everything in a single call.",
+    parameters: z.object({
+      /** Gmail search query (e.g. "in:inbox", "from:alice"). */
+      query: z.string().describe("Gmail search query"),
+      /** Maximum threads to return (default 5, max 20). */
+      maxThreads: z
+        .number()
+        .int()
+        .min(1)
+        .max(20)
+        .optional()
+        .default(5)
+        .describe("Maximum number of threads to return"),
+      /** When true, includes the full decoded body of the latest message in
+       *  each thread. When false, only snippets are returned. */
+      includeLatestBody: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Include full body of the latest message per thread"),
+    }),
+
+    handler: async (args) => {
+      try {
+        const query = args.query as string;
+        const maxThreads = (args.maxThreads as number | undefined) ?? 5;
+        const includeLatestBody = (args.includeLatestBody as boolean | undefined) ?? false;
+        logger.debug({ query, maxThreads, includeLatestBody }, "search_threads called");
+
+        // Step 1 — List thread IDs matching the query.
+        const params = new URLSearchParams({
+          q: query,
+          maxResults: String(maxThreads),
+        });
+        const listRes = await fetch(`${GMAIL_API}/threads?${params}`, {
+          headers: await authHeaders(auth),
+        });
+
+        if (!listRes.ok) {
+          const errText = await listRes.text();
+          logger.error({ status: listRes.status, errText }, "Gmail threads search failed");
+          return `Error searching threads (${listRes.status}): ${errText}`;
+        }
+
+        const listData = (await listRes.json()) as {
+          threads?: Array<{ id: string; snippet: string }>;
+          resultSizeEstimate?: number;
+        };
+
+        if (!listData.threads?.length) {
+          return { threadCount: 0, threads: [] };
+        }
+
+        // Step 2 — Fetch each thread. Use "full" format for the latest
+        // message body when requested, "metadata" otherwise.
+        const format = includeLatestBody ? "full" : "metadata";
+        const headers = await authHeaders(auth);
+        const threads = await Promise.all(
+          listData.threads.map(async (t) => {
+            const url =
+              `${GMAIL_API}/threads/${t.id}?format=${format}` +
+              "&metadataHeaders=Subject&metadataHeaders=From&metadataHeaders=To&metadataHeaders=Date";
+            const res = await fetch(url, { headers });
+
+            if (!res.ok) {
+              return { threadId: t.id, error: `Failed to fetch (${res.status})` };
+            }
+
+            const data = (await res.json()) as {
+              id: string;
+              messages: Array<{
+                id: string;
+                labelIds: string[];
+                snippet: string;
+                payload: {
+                  headers: Array<{ name: string; value: string }>;
+                  body?: { data?: string };
+                  parts?: Array<Record<string, unknown>>;
+                  mimeType?: string;
+                };
+              }>;
+            };
+
+            // Build a compact summary for each message in the thread.
+            const messages = data.messages.map((msg) => {
+              const result: Record<string, unknown> = {
+                id: msg.id,
+                from: getHeader(msg.payload.headers, "From"),
+                to: getHeader(msg.payload.headers, "To"),
+                date: getHeader(msg.payload.headers, "Date"),
+                snippet: msg.snippet,
+                isSent: msg.labelIds?.includes("SENT") ?? false,
+              };
+              return result;
+            });
+
+            // The last message in the array is the most recent.
+            const latest = data.messages[data.messages.length - 1];
+            const lastIsSent = latest?.labelIds?.includes("SENT") ?? false;
+            const subject = getHeader(
+              data.messages[0].payload.headers,
+              "Subject",
+            );
+
+            const thread: Record<string, unknown> = {
+              threadId: data.id,
+              subject,
+              messageCount: messages.length,
+              lastMessageIsSent: lastIsSent,
+              messages,
+            };
+
+            // Only decode the body for the latest message when requested.
+            if (includeLatestBody && latest) {
+              thread.latestBody = extractBody(
+                latest.payload as Record<string, unknown>,
+              );
+            }
+
+            return thread;
+          }),
+        );
+
+        return {
+          threadCount: threads.length,
+          threads,
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error({ error: message }, "search_threads error");
+        return `Error searching threads: ${message}`;
+      }
+    },
+  };
+
+  return [searchEmails, readEmail, sendEmail, getThread, searchThreads];
 }

package/plugins/google-calendar/index.compiled.mjs

@@ -0,0 +1,361 @@
+// plugins/google-calendar/auth.ts
+var TOKEN_ENDPOINT = "https://oauth2.googleapis.com/token";
+var EXPIRY_MARGIN_MS = 6e4;
+var CalendarAuth = class {
+  clientId;
+  clientSecret;
+  refreshToken;
+  accessToken = null;
+  expiresAt = 0;
+  constructor(clientId, clientSecret, refreshToken) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.refreshToken = refreshToken;
+  }
+  /**
+   * Check whether all required credentials have been provided.
+   */
+  isConfigured() {
+    return Boolean(this.clientId && this.clientSecret && this.refreshToken);
+  }
+  /**
+   * Return a valid access token, refreshing it first if necessary.
+   *
+   * @throws {Error} If credentials are missing or the token exchange fails.
+   */
+  async getAccessToken() {
+    if (!this.isConfigured()) {
+      throw new Error(
+        "CalendarAuth is not configured \u2014 client ID, client secret, and refresh token are all required."
+      );
+    }
+    if (this.accessToken && Date.now() < this.expiresAt) {
+      return this.accessToken;
+    }
+    const body = new URLSearchParams({
+      client_id: this.clientId,
+      client_secret: this.clientSecret,
+      refresh_token: this.refreshToken,
+      grant_type: "refresh_token"
+    });
+    const response = await fetch(TOKEN_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(
+        `Failed to refresh Google access token (${response.status}): ${text}`
+      );
+    }
+    const data = await response.json();
+    this.accessToken = data.access_token;
+    this.expiresAt = Date.now() + data.expires_in * 1e3 - EXPIRY_MARGIN_MS;
+    return this.accessToken;
+  }
+};
+
+// plugins/google-calendar/tools.ts
+var CALENDAR_API = "https://www.googleapis.com/calendar/v3";
+async function calendarFetch(auth, path, options = {}) {
+  const token = await auth.getAccessToken();
+  const res = await fetch(`${CALENDAR_API}${path}`, {
+    ...options,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Google Calendar API error (${res.status}): ${text}`);
+  }
+  if (res.status === 204) return { success: true };
+  return res.json();
+}
+function formatEventTime(dt) {
+  if (dt.dateTime) {
+    return new Date(dt.dateTime).toLocaleString("en-US", {
+      weekday: "short",
+      month: "short",
+      day: "numeric",
+      year: "numeric",
+      hour: "numeric",
+      minute: "2-digit",
+      timeZoneName: "short"
+    });
+  }
+  if (dt.date) {
+    return (/* @__PURE__ */ new Date(dt.date + "T00:00:00")).toLocaleDateString("en-US", {
+      weekday: "short",
+      month: "short",
+      day: "numeric",
+      year: "numeric"
+    });
+  }
+  return "N/A";
+}
+function formatEvent(event) {
+  const lines = [];
+  lines.push(`\u{1F4C5} ${event.summary ?? "(no title)"}`);
+  if (event.start) lines.push(`   Start: ${formatEventTime(event.start)}`);
+  if (event.end) lines.push(`   End:   ${formatEventTime(event.end)}`);
+  if (event.location) lines.push(`   \u{1F4CD} ${event.location}`);
+  if (event.description) lines.push(`   ${event.description}`);
+  if (event.attendees?.length) {
+    const emails = event.attendees.map((a) => a.email).join(", ");
+    lines.push(`   \u{1F465} ${emails}`);
+  }
+  lines.push(`   ID: ${event.id}`);
+  return lines.join("\n");
+}
+function createCalendarTools(auth) {
+  const listEvents = {
+    name: "list_events",
+    description: "List upcoming calendar events. Optionally filter by date range.",
+    parameters: {
+      type: "object",
+      properties: {
+        maxResults: {
+          type: "number",
+          description: "Maximum number of events to return (default 10)."
+        },
+        timeMin: {
+          type: "string",
+          description: "Start of the time range as an ISO 8601 date-time string. Defaults to now."
+        },
+        timeMax: {
+          type: "string",
+          description: "End of the time range as an ISO 8601 date-time string."
+        },
+        calendarId: {
+          type: "string",
+          description: 'Calendar ID to query (default "primary").'
+        }
+      }
+    },
+    handler: async (args) => {
+      try {
+        const calendarId = encodeURIComponent(
+          args.calendarId ?? "primary"
+        );
+        const params = new URLSearchParams({
+          maxResults: String(args.maxResults ?? 10),
+          timeMin: args.timeMin ?? (/* @__PURE__ */ new Date()).toISOString(),
+          orderBy: "startTime",
+          singleEvents: "true"
+        });
+        if (args.timeMax) params.set("timeMax", args.timeMax);
+        const data = await calendarFetch(
+          auth,
+          `/calendars/${calendarId}/events?${params.toString()}`
+        );
+        const events = data.items ?? [];
+        if (events.length === 0) {
+          return "No upcoming events found.";
+        }
+        return events.map(formatEvent).join("\n\n");
+      } catch (error) {
+        return `Error listing events: ${error.message}`;
+      }
+    }
+  };
+  const createEvent = {
+    name: "create_event",
+    description: "Create a new calendar event.",
+    parameters: {
+      type: "object",
+      properties: {
+        summary: { type: "string", description: "Event title." },
+        description: { type: "string", description: "Event description." },
+        startTime: {
+          type: "string",
+          description: "Start date-time in ISO 8601 format."
+        },
+        endTime: {
+          type: "string",
+          description: "End date-time in ISO 8601 format."
+        },
+        location: { type: "string", description: "Event location." },
+        attendees: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of attendee email addresses."
+        },
+        calendarId: {
+          type: "string",
+          description: 'Calendar ID (default "primary").'
+        }
+      },
+      required: ["summary", "startTime", "endTime"]
+    },
+    handler: async (args) => {
+      try {
+        const calendarId = encodeURIComponent(
+          args.calendarId ?? "primary"
+        );
+        const body = {
+          summary: args.summary,
+          start: { dateTime: args.startTime },
+          end: { dateTime: args.endTime }
+        };
+        if (args.description) body.description = args.description;
+        if (args.location) body.location = args.location;
+        if (args.attendees) {
+          body.attendees = args.attendees.map((email) => ({
+            email
+          }));
+        }
+        const event = await calendarFetch(
+          auth,
+          `/calendars/${calendarId}/events`,
+          { method: "POST", body: JSON.stringify(body) }
+        );
+        return `\u2705 Event created successfully!
+
+${formatEvent(event)}`;
+      } catch (error) {
+        return `Error creating event: ${error.message}`;
+      }
+    }
+  };
+  const updateEvent = {
+    name: "update_event",
+    description: "Update an existing calendar event by event ID.",
+    parameters: {
+      type: "object",
+      properties: {
+        eventId: { type: "string", description: "The event ID to update." },
+        summary: { type: "string", description: "New event title." },
+        description: { type: "string", description: "New event description." },
+        startTime: {
+          type: "string",
+          description: "New start date-time in ISO 8601 format."
+        },
+        endTime: {
+          type: "string",
+          description: "New end date-time in ISO 8601 format."
+        },
+        location: { type: "string", description: "New event location." },
+        calendarId: {
+          type: "string",
+          description: 'Calendar ID (default "primary").'
+        }
+      },
+      required: ["eventId"]
+    },
+    handler: async (args) => {
+      try {
+        const calendarId = encodeURIComponent(
+          args.calendarId ?? "primary"
+        );
+        const eventId = encodeURIComponent(args.eventId);
+        const body = {};
+        if (args.summary !== void 0) body.summary = args.summary;
+        if (args.description !== void 0)
+          body.description = args.description;
+        if (args.startTime !== void 0)
+          body.start = { dateTime: args.startTime };
+        if (args.endTime !== void 0) body.end = { dateTime: args.endTime };
+        if (args.location !== void 0) body.location = args.location;
+        const event = await calendarFetch(
+          auth,
+          `/calendars/${calendarId}/events/${eventId}`,
+          { method: "PATCH", body: JSON.stringify(body) }
+        );
+        return `\u2705 Event updated successfully!
+
+${formatEvent(event)}`;
+      } catch (error) {
+        return `Error updating event: ${error.message}`;
+      }
+    }
+  };
+  const deleteEvent = {
+    name: "delete_event",
+    description: "Delete a calendar event by event ID.",
+    parameters: {
+      type: "object",
+      properties: {
+        eventId: { type: "string", description: "The event ID to delete." },
+        calendarId: {
+          type: "string",
+          description: 'Calendar ID (default "primary").'
+        }
+      },
+      required: ["eventId"]
+    },
+    handler: async (args) => {
+      try {
+        const calendarId = encodeURIComponent(
+          args.calendarId ?? "primary"
+        );
+        const eventId = encodeURIComponent(args.eventId);
+        await calendarFetch(
+          auth,
+          `/calendars/${calendarId}/events/${eventId}`,
+          { method: "DELETE" }
+        );
+        return `\u2705 Event ${args.eventId} deleted successfully.`;
+      } catch (error) {
+        return `Error deleting event: ${error.message}`;
+      }
+    }
+  };
+  return [listEvents, createEvent, updateEvent, deleteEvent];
+}
+
+// plugins/google-calendar/index.ts
+var createPlugin = () => {
+  let auth;
+  let tools = [];
+  let logger;
+  return {
+    id: "google-calendar",
+    name: "Google Calendar Plugin",
+    version: "1.0.0",
+    description: "View, create, and manage Google Calendar events",
+    requiredCredentials: [
+      "GCAL_CLIENT_ID",
+      "GCAL_CLIENT_SECRET",
+      "GCAL_REFRESH_TOKEN"
+    ],
+    async initialize(context) {
+      logger = context.logger;
+      logger.info("Initialising Google Calendar plugin\u2026");
+      auth = new CalendarAuth(
+        context.credentials.GCAL_CLIENT_ID,
+        context.credentials.GCAL_CLIENT_SECRET,
+        context.credentials.GCAL_REFRESH_TOKEN
+      );
+      if (!auth.isConfigured()) {
+        throw new Error(
+          "Google Calendar plugin is missing one or more required credentials."
+        );
+      }
+      tools = createCalendarTools(auth);
+      logger.info(`Registered ${tools.length} calendar tools`);
+    },
+    getTools() {
+      return tools;
+    },
+    async destroy() {
+      tools = [];
+      logger?.info("Google Calendar plugin destroyed");
+    },
+    async healthCheck() {
+      try {
+        await auth.getAccessToken();
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+};
+var index_default = createPlugin;
+export {
+  index_default as default
+};