gmcp 0.1.0

package/dist/index.js

@@ -0,0 +1,3391 @@
+#!/usr/bin/env node
+import {
+  createAuthenticatedClient,
+  getEnvConfig,
+  getHeader
+} from "./shared/chunk-n2k9eesp.js";
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/calendar.ts
+import { google } from "googleapis";
+function parseCalendar(calendar) {
+  return {
+    id: calendar.id || "",
+    summary: calendar.summary || "",
+    description: calendar.description ?? undefined,
+    timeZone: calendar.timeZone ?? undefined,
+    primary: calendar.primary ?? undefined,
+    backgroundColor: calendar.backgroundColor ?? undefined,
+    foregroundColor: calendar.foregroundColor ?? undefined,
+    accessRole: calendar.accessRole ?? undefined
+  };
+}
+var ALL_DAY_DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+function isAllDayDate(dateString) {
+  return ALL_DAY_DATE_REGEX.test(dateString);
+}
+function parseEventDateTime(datetime) {
+  return {
+    date: datetime?.date ?? undefined,
+    dateTime: datetime?.dateTime ?? undefined,
+    timeZone: datetime?.timeZone ?? undefined
+  };
+}
+function parseAttendee(attendee) {
+  return {
+    email: attendee.email || "",
+    displayName: attendee.displayName ?? undefined,
+    responseStatus: attendee.responseStatus,
+    optional: attendee.optional ?? undefined,
+    organizer: attendee.organizer ?? undefined,
+    self: attendee.self ?? undefined
+  };
+}
+function parseEventPerson(person) {
+  if (!person) {
+    return;
+  }
+  return {
+    email: person.email || "",
+    displayName: person.displayName ?? undefined
+  };
+}
+function parseEvent(event) {
+  return {
+    id: event.id || "",
+    summary: event.summary || "(No title)",
+    description: event.description ?? undefined,
+    location: event.location ?? undefined,
+    start: parseEventDateTime(event.start),
+    end: parseEventDateTime(event.end),
+    attendees: event.attendees?.map(parseAttendee),
+    creator: parseEventPerson(event.creator),
+    organizer: parseEventPerson(event.organizer),
+    status: event.status,
+    htmlLink: event.htmlLink ?? undefined,
+    hangoutLink: event.hangoutLink ?? undefined,
+    recurrence: event.recurrence ?? undefined,
+    recurringEventId: event.recurringEventId ?? undefined,
+    created: event.created ?? undefined,
+    updated: event.updated ?? undefined
+  };
+}
+function createCalendarClient(auth, logger) {
+  const calendar = google.calendar({ version: "v3", auth });
+  return {
+    async listCalendars(showHidden = false) {
+      const startTime = Date.now();
+      logger?.debug({ showHidden }, "listCalendars start");
+      try {
+        const response = await calendar.calendarList.list({
+          showHidden
+        });
+        const calendars = response.data.items || [];
+        const result = calendars.map((cal) => parseCalendar(cal));
+        logger?.info({ calendarCount: result.length, durationMs: Date.now() - startTime }, "listCalendars completed");
+        return result;
+      } catch (error) {
+        logger?.error({
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined
+        }, "listCalendars failed");
+        throw new Error(`Failed to list calendars: ${error}`);
+      }
+    },
+    async listEvents(calendarId = "primary", timeMin, timeMax, maxResults = 10, query, singleEvents = true, orderBy = "startTime") {
+      const startTime = Date.now();
+      logger?.debug({ calendarId, timeMin, timeMax, maxResults, query }, "listEvents start");
+      try {
+        const response = await calendar.events.list({
+          calendarId,
+          timeMin,
+          timeMax,
+          maxResults,
+          q: query,
+          singleEvents,
+          orderBy: singleEvents ? orderBy : undefined
+        });
+        const events = response.data.items || [];
+        const result = events.map((event) => parseEvent(event));
+        logger?.info({
+          calendarId,
+          eventCount: result.length,
+          durationMs: Date.now() - startTime
+        }, "listEvents completed");
+        return result;
+      } catch (error) {
+        logger?.error({
+          calendarId,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined
+        }, "listEvents failed");
+        throw new Error(`Failed to list events from calendar ${calendarId}: ${error}`);
+      }
+    },
+    async getEvent(calendarId, eventId) {
+      const startTime = Date.now();
+      logger?.debug({ calendarId, eventId }, "getEvent start");
+      try {
+        const response = await calendar.events.get({
+          calendarId,
+          eventId
+        });
+        const result = parseEvent(response.data);
+        logger?.info({ calendarId, eventId, durationMs: Date.now() - startTime }, "getEvent completed");
+        return result;
+      } catch (error) {
+        logger?.error({
+          calendarId,
+          eventId,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined
+        }, "getEvent failed");
+        throw new Error(`Failed to get event ${eventId} from calendar ${calendarId}: ${error}`);
+      }
+    },
+    async createEvent(calendarId, summary, start, end, description, location, attendees, timezone, recurrence, addMeet) {
+      const startTime = Date.now();
+      logger?.debug({ calendarId, summary, start, end, addMeet }, "createEvent start");
+      try {
+        const isAllDay = isAllDayDate(start);
+        const eventResource = {
+          summary,
+          description,
+          location,
+          start: isAllDay ? { date: start, timeZone: timezone } : { dateTime: start, timeZone: timezone },
+          end: isAllDay ? { date: end, timeZone: timezone } : { dateTime: end, timeZone: timezone },
+          attendees: attendees?.map((email) => ({ email })),
+          recurrence
+        };
+        if (addMeet) {
+          eventResource.conferenceData = {
+            createRequest: {
+              requestId: `${Date.now()}-${Math.random().toString(36).substring(7)}`,
+              conferenceSolutionKey: { type: "hangoutsMeet" }
+            }
+          };
+        }
+        const response = await calendar.events.insert({
+          calendarId,
+          requestBody: eventResource,
+          conferenceDataVersion: addMeet ? 1 : undefined
+        });
+        const result = parseEvent(response.data);
+        logger?.info({
+          calendarId,
+          summary,
+          eventId: result.id,
+          durationMs: Date.now() - startTime
+        }, "createEvent completed");
+        return result;
+      } catch (error) {
+        logger?.error({
+          calendarId,
+          summary,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined
+        }, "createEvent failed");
+        throw new Error(`Failed to create event "${summary}" in calendar ${calendarId}: ${error}`);
+      }
+    }
+  };
+}
+
+// src/gmail.ts
+import { google as google2 } from "googleapis";
+
+// src/constants.ts
+var EMAIL_FETCH_BATCH_SIZE = 10;
+
+// src/gmail.ts
+var BASE64_PADDING_REGEX = /=+$/;
+function decodeBase64(data) {
+  try {
+    const base64 = data.replace(/-/g, "+").replace(/_/g, "/");
+    return Buffer.from(base64, "base64").toString("utf-8");
+  } catch (_error) {
+    return "(error decoding body)";
+  }
+}
+function getPartBody(part, mimeType) {
+  if (part.mimeType === mimeType && part.body?.data) {
+    return decodeBase64(part.body.data);
+  }
+  if (part.parts) {
+    for (const subPart of part.parts) {
+      const body = getPartBody(subPart, mimeType);
+      if (body) {
+        return body;
+      }
+    }
+  }
+  return "";
+}
+function extractBody(payload) {
+  if (!payload) {
+    return "";
+  }
+  let body = getPartBody(payload, "text/plain");
+  if (!body) {
+    body = getPartBody(payload, "text/html");
+  }
+  if (!body && payload.body?.data) {
+    body = decodeBase64(payload.body.data);
+  }
+  return body || "(no body)";
+}
+function parseMessage(message, includeBody) {
+  const headers = message.payload?.headers || [];
+  const subject = getHeader(headers, "Subject");
+  const from = getHeader(headers, "From");
+  const to = getHeader(headers, "To");
+  const date = getHeader(headers, "Date");
+  const email = {
+    id: message.id || "",
+    threadId: message.threadId || "",
+    subject: subject || "(no subject)",
+    from: from || "(unknown)",
+    to: to || "(unknown)",
+    date: date || "",
+    snippet: message.snippet || "",
+    labels: message.labelIds || undefined
+  };
+  if (includeBody) {
+    email.body = extractBody(message.payload);
+  }
+  return email;
+}
+function createMimeMessage(params) {
+  const lines = [];
+  lines.push(`To: ${params.to}`);
+  if (params.cc) {
+    lines.push(`Cc: ${params.cc}`);
+  }
+  if (params.bcc) {
+    lines.push(`Bcc: ${params.bcc}`);
+  }
+  lines.push(`Subject: ${params.subject}`);
+  if (params.inReplyTo) {
+    lines.push(`In-Reply-To: ${params.inReplyTo}`);
+  }
+  if (params.references) {
+    lines.push(`References: ${params.references}`);
+  }
+  lines.push(`Content-Type: ${params.contentType}; charset=utf-8`);
+  lines.push("");
+  lines.push(params.body);
+  return lines.join(`\r
+`);
+}
+function encodeMessage(message) {
+  return Buffer.from(message).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(BASE64_PADDING_REGEX, "");
+}
+function parseLabel(label) {
+  return {
+    id: label.id || "",
+    name: label.name || "",
+    type: label.type === "system" ? "system" : "user",
+    messageListVisibility: label.messageListVisibility,
+    labelListVisibility: label.labelListVisibility,
+    messagesTotal: label.messagesTotal || undefined,
+    messagesUnread: label.messagesUnread || undefined,
+    color: label.color ? {
+      textColor: label.color.textColor || "",
+      backgroundColor: label.color.backgroundColor || ""
+    } : undefined
+  };
+}
+function createGmailClient(auth, logger) {
+  const gmail = google2.gmail({ version: "v1", auth });
+  return {
+    async searchEmails(query, maxResults = 10, includeBody = false, pageToken) {
+      const startTime = Date.now();
+      logger?.debug({ query, maxResults, includeBody, pageToken }, "searchEmails start");
+      try {
+        const listResponse = await gmail.users.messages.list({
+          userId: "me",
+          q: query,
+          maxResults,
+          pageToken
+        });
+        const messages = listResponse.data.messages || [];
+        const resultSizeEstimate = listResponse.data.resultSizeEstimate || 0;
+        const nextPageToken = listResponse.data.nextPageToken;
+        const validMessages = messages.filter((message) => message.id);
+        const emails = [];
+        for (let i = 0;i < validMessages.length; i += EMAIL_FETCH_BATCH_SIZE) {
+          const batchStartTime = Date.now();
+          const batch = validMessages.slice(i, i + EMAIL_FETCH_BATCH_SIZE);
+          const batchEmails = await Promise.all(batch.map(async (message) => {
+            const messageId = message.id ?? "";
+            const details = await gmail.users.messages.get({
+              userId: "me",
+              id: messageId,
+              format: includeBody ? "full" : "metadata",
+              metadataHeaders: includeBody ? undefined : ["From", "To", "Subject", "Date"]
+            });
+            return parseMessage(details.data, includeBody);
+          }));
+          emails.push(...batchEmails);
+          logger?.debug({
+            batchSize: batch.length,
+            durationMs: Date.now() - batchStartTime
+          }, "searchEmails batch completed");
+        }
+        const durationMs = Date.now() - startTime;
+        logger?.info({ query, resultCount: emails.length, durationMs }, "searchEmails completed");
+        return {
+          emails,
+          total_estimate: resultSizeEstimate,
+          has_more: !!nextPageToken,
+          next_page_token: nextPageToken || undefined
+        };
+      } catch (error) {
+        logger?.error({
+          query,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined
+        }, "searchEmails failed");
+        throw new Error(`Failed to search emails with query "${query}": ${error}`);
+      }
+    },
+    async getMessage(messageId, includeBody = false) {
+      const startTime = Date.now();
+      logger?.debug({ messageId, includeBody }, "getMessage start");
+      try {
+        const response = await gmail.users.messages.get({
+          userId: "me",
+          id: messageId,
+          format: includeBody ? "full" : "metadata",
+          metadataHeaders: includeBody ? undefined : ["From", "To", "Subject", "Date"]
+        });
+        const result = parseMessage(response.data, includeBody);
+        logger?.info({ messageId, durationMs: Date.now() - startTime }, "getMessage completed");
+        return result;
+      } catch (error) {
+        logger?.error({
+          messageId,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined
+        }, "getMessage failed");
+        throw new Error(`Failed to get message ${messageId}: ${error}`);
+      }
+    },
+    async getThread(threadId, includeBody = false) {
+      try {
+        const response = await gmail.users.threads.get({
+          userId: "me",
+          id: threadId,
+          format: includeBody ? "full" : "metadata",
+          metadataHeaders: includeBody ? undefined : ["From", "To", "Subject", "Date"]
+        });
+        const messages = response.data.messages || [];
+        return messages.map((message) => parseMessage(message, includeBody));
+      } catch (error) {
+        throw new Error(`Failed to get thread ${threadId}: ${error}`);
+      }
+    },
+    async listAttachments(messageId) {
+      try {
+        const response = await gmail.users.messages.get({
+          userId: "me",
+          id: messageId,
+          format: "full"
+        });
+        const attachments = [];
+        const extractAttachments = (part) => {
+          if (part.filename && part.body?.attachmentId) {
+            attachments.push({
+              filename: part.filename,
+              mimeType: part.mimeType || "application/octet-stream",
+              size: part.body.size || 0,
+              attachmentId: part.body.attachmentId
+            });
+          }
+          if (part.parts) {
+            for (const subPart of part.parts) {
+              extractAttachments(subPart);
+            }
+          }
+        };
+        if (response.data.payload) {
+          extractAttachments(response.data.payload);
+        }
+        return attachments;
+      } catch (error) {
+        throw new Error(`Failed to list attachments for ${messageId}: ${error}`);
+      }
+    },
+    async getAttachment(messageId, attachmentId) {
+      try {
+        const response = await gmail.users.messages.attachments.get({
+          userId: "me",
+          messageId,
+          id: attachmentId
+        });
+        if (!response.data.data) {
+          throw new Error("Attachment data not found");
+        }
+        return response.data.data;
+      } catch (error) {
+        throw new Error(`Failed to get attachment ${attachmentId} from message ${messageId}: ${error}`);
+      }
+    },
+    async modifyLabels(messageId, addLabelIds, removeLabelIds) {
+      try {
+        const response = await gmail.users.messages.modify({
+          userId: "me",
+          id: messageId,
+          requestBody: {
+            addLabelIds: addLabelIds || [],
+            removeLabelIds: removeLabelIds || []
+          }
+        });
+        return parseMessage(response.data, false);
+      } catch (error) {
+        throw new Error(`Failed to modify labels for ${messageId}: ${error}`);
+      }
+    },
+    async batchModifyLabels(messageIds, addLabelIds, removeLabelIds) {
+      const startTime = Date.now();
+      logger?.debug({
+        messageCount: messageIds.length,
+        addLabelCount: addLabelIds?.length || 0,
+        removeLabelCount: removeLabelIds?.length || 0
+      }, "batchModifyLabels start");
+      try {
+        await gmail.users.messages.batchModify({
+          userId: "me",
+          requestBody: {
+            ids: messageIds,
+            addLabelIds: addLabelIds || [],
+            removeLabelIds: removeLabelIds || []
+          }
+        });
+        logger?.info({
+          messageCount: messageIds.length,
+          durationMs: Date.now() - startTime
+        }, "batchModifyLabels completed");
+      } catch (error) {
+        logger?.error({
+          messageCount: messageIds.length,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined
+        }, "batchModifyLabels failed");
+        throw new Error(`Failed to batch modify labels on ${messageIds.length} messages: ${error}`);
+      }
+    },
+    async sendEmail(to, subject, body, contentType = "text/plain", cc, bcc) {
+      const startTime = Date.now();
+      logger?.debug({ to, subject, contentType }, "sendEmail start");
+      try {
+        const mimeMessage = createMimeMessage({
+          to,
+          subject,
+          body,
+          contentType,
+          cc,
+          bcc
+        });
+        const encodedMessage = encodeMessage(mimeMessage);
+        const response = await gmail.users.messages.send({
+          userId: "me",
+          requestBody: {
+            raw: encodedMessage
+          }
+        });
+        const result = {
+          id: response.data.id || "",
+          threadId: response.data.threadId || "",
+          labelIds: response.data.labelIds || undefined
+        };
+        logger?.info({
+          to,
+          subject,
+          messageId: result.id,
+          durationMs: Date.now() - startTime
+        }, "sendEmail completed");
+        return result;
+      } catch (error) {
+        logger?.error({
+          to,
+          subject,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined
+        }, "sendEmail failed");
+        throw new Error(`Failed to send email to ${to}: ${error}`);
+      }
+    },
+    async replyToEmail(to, subject, body, threadId, messageId, contentType = "text/plain", cc) {
+      try {
+        const replySubject = subject.startsWith("Re:") ? subject : `Re: ${subject}`;
+        const mimeMessage = createMimeMessage({
+          to,
+          subject: replySubject,
+          body,
+          contentType,
+          cc,
+          inReplyTo: `<${messageId}>`,
+          references: `<${messageId}>`
+        });
+        const encodedMessage = encodeMessage(mimeMessage);
+        const response = await gmail.users.messages.send({
+          userId: "me",
+          requestBody: {
+            raw: encodedMessage,
+            threadId
+          }
+        });
+        return {
+          id: response.data.id || "",
+          threadId: response.data.threadId || "",
+          labelIds: response.data.labelIds || undefined
+        };
+      } catch (error) {
+        throw new Error(`Failed to reply to message ${messageId} in thread ${threadId}: ${error}`);
+      }
+    },
+    async createDraft(to, subject, body, contentType = "text/plain", cc, bcc) {
+      try {
+        const mimeMessage = createMimeMessage({
+          to,
+          subject,
+          body,
+          contentType,
+          cc,
+          bcc
+        });
+        const encodedMessage = encodeMessage(mimeMessage);
+        const response = await gmail.users.drafts.create({
+          userId: "me",
+          requestBody: {
+            message: {
+              raw: encodedMessage
+            }
+          }
+        });
+        return {
+          id: response.data.id || "",
+          message: {
+            id: response.data.message?.id || "",
+            threadId: response.data.message?.threadId || ""
+          }
+        };
+      } catch (error) {
+        throw new Error(`Failed to create draft to ${to}: ${error}`);
+      }
+    },
+    async listLabels() {
+      try {
+        const response = await gmail.users.labels.list({
+          userId: "me"
+        });
+        const labels = response.data.labels || [];
+        return labels.map((label) => parseLabel(label));
+      } catch (error) {
+        throw new Error(`Failed to list labels: ${error}`);
+      }
+    },
+    async getLabel(labelId) {
+      try {
+        const response = await gmail.users.labels.get({
+          userId: "me",
+          id: labelId
+        });
+        return parseLabel(response.data);
+      } catch (error) {
+        throw new Error(`Failed to get label ${labelId}: ${error}`);
+      }
+    },
+    async createLabel(name, messageListVisibility, labelListVisibility, backgroundColor, textColor) {
+      try {
+        const response = await gmail.users.labels.create({
+          userId: "me",
+          requestBody: {
+            name,
+            messageListVisibility,
+            labelListVisibility,
+            color: backgroundColor && textColor ? { backgroundColor, textColor } : undefined
+          }
+        });
+        return parseLabel(response.data);
+      } catch (error) {
+        throw new Error(`Failed to create label "${name}": ${error}`);
+      }
+    },
+    async updateLabel(labelId, name, messageListVisibility, labelListVisibility, backgroundColor, textColor) {
+      try {
+        const response = await gmail.users.labels.update({
+          userId: "me",
+          id: labelId,
+          requestBody: {
+            id: labelId,
+            name,
+            messageListVisibility,
+            labelListVisibility,
+            color: backgroundColor && textColor ? { backgroundColor, textColor } : undefined
+          }
+        });
+        return parseLabel(response.data);
+      } catch (error) {
+        throw new Error(`Failed to update label ${labelId}: ${error}`);
+      }
+    },
+    async deleteLabel(labelId) {
+      try {
+        await gmail.users.labels.delete({
+          userId: "me",
+          id: labelId
+        });
+      } catch (error) {
+        throw new Error(`Failed to delete label ${labelId}: ${error}`);
+      }
+    }
+  };
+}
+
+// src/logger.ts
+import pino from "pino";
+function createLogger(options = {}) {
+  const level = options.level || process.env.LOG_LEVEL || "info";
+  const pretty = options.pretty ?? process.env.LOG_PRETTY === "true";
+  const pinoOptions = {
+    level,
+    name: options.name || "gmcp",
+    ...pretty && {
+      transport: {
+        target: "pino-pretty",
+        options: {
+          colorize: true,
+          translateTime: "HH:MM:ss Z",
+          ignore: "pid,hostname",
+          destination: 2
+        }
+      }
+    }
+  };
+  if (!pretty) {
+    return pino(pinoOptions, pino.destination(2));
+  }
+  return pino(pinoOptions);
+}
+
+// src/tool-registry.ts
+var READ_ONLY_ANNOTATIONS = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+var MODIFY_ANNOTATIONS = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var SEND_ANNOTATIONS = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: false
+};
+var DESTRUCTIVE_ANNOTATIONS = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  idempotentHint: true,
+  openWorldHint: false
+};
+function registerTools(server, client, tools, logger) {
+  for (const tool of tools) {
+    server.registerTool(tool.name, {
+      title: tool.title,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      annotations: tool.annotations
+    }, async (params) => {
+      const toolLogger = logger?.child({ tool: tool.name });
+      const startTime = Date.now();
+      toolLogger?.info({ params }, "Tool execution start");
+      try {
+        const result = await tool.handler(client, params);
+        toolLogger?.info({ durationMs: Date.now() - startTime, success: !result.isError }, "Tool execution completed");
+        return result;
+      } catch (error) {
+        toolLogger?.error({
+          durationMs: Date.now() - startTime,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined
+        }, "Tool execution failed");
+        throw error;
+      }
+    });
+  }
+}
+
+// src/tools/batch-modify.ts
+import json2md from "json2md";
+import { z } from "zod";
+
+// src/utils/tool-helpers.ts
+function formatEmailForOutput(email) {
+  return {
+    id: email.id,
+    thread_id: email.threadId,
+    subject: email.subject,
+    from: email.from,
+    to: email.to,
+    date: email.date,
+    snippet: email.snippet,
+    ...email.body ? { body: email.body } : {},
+    ...email.labels ? { labels: email.labels } : {}
+  };
+}
+function createErrorResponse(context, error, logger) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  logger?.error({
+    context,
+    error: errorMessage,
+    stack: error instanceof Error ? error.stack : undefined
+  }, "Tool error");
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Error ${context}: ${errorMessage}`
+      }
+    ],
+    isError: true
+  };
+}
+
+// src/tools/batch-modify.ts
+var BatchModifyInputSchema = z.object({
+  message_ids: z.array(z.string()).min(1, "Must provide at least one message ID").max(1000, "Maximum 1000 messages per batch").describe("Array of Gmail message IDs to modify (max 1000)"),
+  add_labels: z.array(z.string()).optional().describe("Label IDs to add to all messages (e.g., ['STARRED', 'IMPORTANT'])"),
+  remove_labels: z.array(z.string()).optional().describe("Label IDs to remove from all messages (e.g., ['UNREAD', 'INBOX'])"),
+  output_format: z.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function batchModificationToMarkdown(messageCount, addedLabels, removedLabels) {
+  const sections = [
+    { h1: "Batch Label Modification Successful" },
+    { p: `**Modified Messages:** ${messageCount}` }
+  ];
+  if (addedLabels && addedLabels.length > 0) {
+    sections.push({ h2: "Added Labels" });
+    sections.push({ ul: addedLabels });
+  }
+  if (removedLabels && removedLabels.length > 0) {
+    sections.push({ h2: "Removed Labels" });
+    sections.push({ ul: removedLabels });
+  }
+  sections.push({
+    p: `All ${messageCount} messages have been updated successfully.`
+  });
+  return json2md(sections);
+}
+async function batchModifyTool(gmailClient, params) {
+  try {
+    if (!(params.add_labels || params.remove_labels)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Error: Must specify at least one of add_labels or remove_labels"
+          }
+        ],
+        isError: true
+      };
+    }
+    await gmailClient.batchModifyLabels(params.message_ids, params.add_labels, params.remove_labels);
+    const output = {
+      modified_count: params.message_ids.length,
+      message_ids: params.message_ids,
+      added_labels: params.add_labels || [],
+      removed_labels: params.remove_labels || [],
+      success: true
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : batchModificationToMarkdown(params.message_ids.length, params.add_labels, params.remove_labels);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("batch modifying labels", error);
+  }
+}
+var BATCH_MODIFY_DESCRIPTION = `Batch modify Gmail labels on multiple messages at once.
+
+This tool allows you to efficiently add or remove labels from multiple Gmail messages in a single operation. It's ideal for bulk email management tasks.
+
+**Common Use Cases**:
+- Archive multiple emails at once
+- Mark multiple emails as read
+- Star a group of important emails
+- Apply custom labels to multiple messages
+- Clean up inbox by bulk archiving
+
+**System Labels**:
+- \`INBOX\` - Inbox (remove to archive)
+- \`UNREAD\` - Unread status (remove to mark as read)
+- \`STARRED\` - Starred/important
+- \`SPAM\` - Spam folder
+- \`TRASH\` - Trash folder
+- \`IMPORTANT\` - Important marker
+
+**Parameters**:
+- \`message_ids\` (array, required): Array of message IDs to modify (max 1000)
+- \`add_labels\` (array, optional): Label IDs to add to all messages
+- \`remove_labels\` (array, optional): Label IDs to remove from all messages
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns**:
+- \`modified_count\`: Number of messages modified
+- \`message_ids\`: Array of message IDs that were modified
+- \`added_labels\`: Labels that were added
+- \`removed_labels\`: Labels that were removed
+- \`success\`: Always true on success
+
+**Examples**:
+- Archive multiple emails: \`{ "message_ids": ["id1", "id2", "id3"], "remove_labels": ["INBOX"] }\`
+- Bulk mark as read: \`{ "message_ids": ["id1", "id2"], "remove_labels": ["UNREAD"] }\`
+- Star multiple emails: \`{ "message_ids": ["id1", "id2"], "add_labels": ["STARRED"] }\`
+- Archive and mark read: \`{ "message_ids": ["id1", "id2"], "remove_labels": ["INBOX", "UNREAD"] }\`
+
+**Limits**:
+- Maximum 1000 messages per batch operation
+- For larger operations, split into multiple batches
+
+**Error Handling**:
+- Returns error if any message ID is invalid
+- Returns error if label ID is invalid
+- Returns error if authentication lacks modify permissions
+- Requires at least one of add_labels or remove_labels
+- Operation is atomic: all messages are modified or none are
+
+**Workflow**:
+1. Use \`search_emails\` to find messages matching criteria
+2. Extract message IDs from search results
+3. Use this tool to batch modify labels on all found messages
+
+**Performance**:
+- Much faster than modifying messages individually
+- Single API call regardless of message count
+- Recommended for operations affecting more than 5 messages`;
+
+// src/tools/calendar-create.ts
+import { z as z2 } from "zod";
+
+// src/utils/markdown.ts
+import json2md2 from "json2md";
+function emailToJson2md(email) {
+  const elements = [
+    { h2: email.subject },
+    {
+      ul: [
+        `**From**: ${email.from}`,
+        `**To**: ${email.to}`,
+        `**Date**: ${email.date}`,
+        `**ID**: ${email.id}`,
+        `**Thread ID**: ${email.thread_id}`,
+        ...email.labels && email.labels.length > 0 ? [`**Labels**: ${email.labels.join(", ")}`] : []
+      ]
+    },
+    { p: `**Snippet**: ${email.snippet}` }
+  ];
+  if (email.body) {
+    const bodyPreview = email.body.length > 500 ? `${email.body.substring(0, 500)}...` : email.body;
+    elements.push({ p: "**Body**:" }, { code: { content: bodyPreview } });
+  }
+  elements.push({ hr: "" });
+  return elements;
+}
+function searchResultsToMarkdown(query, data) {
+  const elements = [
+    { h1: `Gmail Search Results: "${query}"` },
+    {
+      p: `Found approximately ${data.total_estimate} emails (showing ${data.count})`
+    }
+  ];
+  if (data.emails.length === 0) {
+    elements.push({ p: "No emails found matching the query." });
+  } else {
+    for (const email of data.emails) {
+      elements.push(...emailToJson2md(email));
+    }
+    if (data.has_more && data.next_page_token) {
+      elements.push({
+        p: `**Note**: More results available. Use page_token: "${data.next_page_token}" to fetch the next page.`
+      });
+    }
+  }
+  return json2md2(elements);
+}
+function calendarListToMarkdown(data) {
+  const sections = [
+    { h1: "Google Calendars" },
+    { p: `**Total Calendars:** ${data.count}` }
+  ];
+  if (data.calendars.length === 0) {
+    sections.push({ p: "No calendars found." });
+  } else {
+    for (const calendar of data.calendars) {
+      sections.push({ h2: calendar.summary });
+      const details = [
+        `**ID:** ${calendar.id}`,
+        `**Timezone:** ${calendar.timezone || "Not set"}`,
+        `**Access Role:** ${calendar.access_role || "Unknown"}`
+      ];
+      if (calendar.primary) {
+        details.push("**Primary:** Yes");
+      }
+      if (calendar.description) {
+        details.push(`**Description:** ${calendar.description}`);
+      }
+      sections.push({ ul: details });
+    }
+  }
+  return json2md2(sections);
+}
+function formatEventTime(time) {
+  if (time.date) {
+    return `\uD83D\uDCC5 ${time.date} (All day)`;
+  }
+  if (time.dateTime) {
+    const tz = time.timeZone ? ` (${time.timeZone})` : "";
+    return `\uD83D\uDD50 ${time.dateTime}${tz}`;
+  }
+  return "Not set";
+}
+function buildEventDetails(event) {
+  const details = [
+    `**Event ID:** ${event.id}`,
+    `**Start:** ${formatEventTime(event.start)}`,
+    `**End:** ${formatEventTime(event.end)}`
+  ];
+  if (event.location) {
+    details.push(`**Location:** ${event.location}`);
+  }
+  if (event.status) {
+    details.push(`**Status:** ${event.status}`);
+  }
+  if (event.hangout_link) {
+    details.push(`**Google Meet:** ${event.hangout_link}`);
+  }
+  if (event.html_link) {
+    details.push(`**View in Calendar:** ${event.html_link}`);
+  }
+  return details;
+}
+function formatAttendee(att) {
+  const name = att.display_name || att.email;
+  const status = att.response_status ? ` (${att.response_status})` : "";
+  const optional = att.optional ? " [Optional]" : "";
+  return `${name}${status}${optional}`;
+}
+function addEventSummary(sections, event) {
+  sections.push({ h2: event.summary });
+  sections.push({ ul: buildEventDetails(event) });
+  if (event.description) {
+    sections.push({ p: `**Description:** ${event.description}` });
+  }
+  if (event.attendees && event.attendees.length > 0) {
+    sections.push({ h3: "Attendees" });
+    sections.push({ ul: event.attendees.map(formatAttendee) });
+  }
+  if (event.recurrence && event.recurrence.length > 0) {
+    sections.push({ p: `**Recurrence:** ${event.recurrence.join(", ")}` });
+  }
+}
+function eventListToMarkdown(data) {
+  const sections = [
+    { h1: "Calendar Events" },
+    {
+      p: `**Calendar:** ${data.calendar_id} | **Events Found:** ${data.count}`
+    }
+  ];
+  if (data.events.length === 0) {
+    sections.push({ p: "No events found matching the criteria." });
+  } else {
+    for (const event of data.events) {
+      addEventSummary(sections, event);
+      sections.push({ hr: "" });
+    }
+  }
+  return json2md2(sections);
+}
+function formatAttendeeDetailed(att) {
+  const name = att.display_name || att.email;
+  const status = att.response_status ? ` - ${att.response_status}` : "";
+  const optional = att.optional ? " [Optional]" : "";
+  return `**${name}**${status}${optional}`;
+}
+function addEventMetadata(sections, event) {
+  if (event.creator) {
+    sections.push({
+      p: `**Created by:** ${event.creator.display_name || event.creator.email}`
+    });
+  }
+  if (event.organizer) {
+    sections.push({
+      p: `**Organized by:** ${event.organizer.display_name || event.organizer.email}`
+    });
+  }
+  if (event.recurrence && event.recurrence.length > 0) {
+    sections.push({ h2: "Recurrence" });
+    sections.push({ ul: event.recurrence });
+  }
+  if (event.created || event.updated) {
+    const metadata = [];
+    if (event.created) {
+      metadata.push(`**Created:** ${event.created}`);
+    }
+    if (event.updated) {
+      metadata.push(`**Last Updated:** ${event.updated}`);
+    }
+    sections.push({ p: metadata.join(" | ") });
+  }
+}
+function eventToMarkdown(event, successMessage) {
+  const sections = [];
+  sections.push({ h1: successMessage || "Calendar Event" });
+  sections.push({ h2: event.summary });
+  sections.push({ ul: buildEventDetails(event) });
+  if (event.description) {
+    sections.push({ h2: "Description" });
+    sections.push({ p: event.description });
+  }
+  if (event.attendees && event.attendees.length > 0) {
+    sections.push({ h2: "Attendees" });
+    sections.push({ ul: event.attendees.map(formatAttendeeDetailed) });
+  }
+  addEventMetadata(sections, event);
+  return json2md2(sections);
+}
+
+// src/tools/calendar-create.ts
+var CalendarCreateEventInputSchema = z2.object({
+  calendar_id: z2.string().default("primary").describe('Calendar ID to create event in (default: "primary")'),
+  summary: z2.string().min(1, "Event title is required").describe("Event title/summary (required)"),
+  start: z2.string().min(1, "Start time is required").describe('Start time: RFC3339 (e.g., "2024-01-15T09:00:00-08:00") or date for all-day (e.g., "2024-01-15")'),
+  end: z2.string().min(1, "End time is required").describe('End time: RFC3339 (e.g., "2024-01-15T10:00:00-08:00") or date for all-day (e.g., "2024-01-15")'),
+  description: z2.string().optional().describe("Event description (optional)"),
+  location: z2.string().optional().describe("Event location (optional)"),
+  attendees: z2.array(z2.string().email()).optional().describe("Array of attendee email addresses (optional)"),
+  timezone: z2.string().optional().describe('IANA timezone (e.g., "America/Los_Angeles", optional)'),
+  recurrence: z2.array(z2.string()).optional().describe('Recurrence rules as RRULE strings (e.g., ["RRULE:FREQ=WEEKLY;COUNT=10"], optional)'),
+  add_meet: z2.boolean().default(false).describe("Auto-create Google Meet conference link (default: false)"),
+  confirm: z2.boolean().default(false).describe("Must be true to create the event (safety check)"),
+  output_format: z2.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+async function calendarCreateEventTool(calendarClient, params) {
+  if (!params.confirm) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "❌ Event creation requires explicit confirmation. Please set `confirm: true` in the parameters to proceed.\n\nThis safety measure prevents accidental event creation."
+        }
+      ],
+      structuredContent: {
+        error: "Confirmation required",
+        message: "Set confirm: true to create the event. This prevents accidental creation."
+      }
+    };
+  }
+  try {
+    const event = await calendarClient.createEvent(params.calendar_id, params.summary, params.start, params.end, params.description, params.location, params.attendees, params.timezone, params.recurrence, params.add_meet);
+    const output = {
+      id: event.id,
+      summary: event.summary,
+      description: event.description,
+      location: event.location,
+      start: event.start,
+      end: event.end,
+      status: event.status,
+      html_link: event.htmlLink,
+      hangout_link: event.hangoutLink,
+      attendees: event.attendees?.map((attendee) => ({
+        email: attendee.email,
+        display_name: attendee.displayName,
+        response_status: attendee.responseStatus
+      })),
+      organizer: event.organizer,
+      recurrence: event.recurrence,
+      created: event.created
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : eventToMarkdown(output, "Event created successfully!");
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse(`creating event "${params.summary}" in calendar ${params.calendar_id}`, error);
+  }
+}
+var CALENDAR_CREATE_EVENT_DESCRIPTION = `Create a new event in Google Calendar.
+
+This tool creates a new calendar event with support for attendees, recurring events, Google Meet links, and more.
+
+**IMPORTANT**: You must set \`confirm: true\` to create the event. This prevents accidental event creation.
+
+**Parameters**:
+- \`calendar_id\` (string, optional): Calendar ID (default: "primary")
+- \`summary\` (string, required): Event title
+- \`start\` (string, required): Start time (see formats below)
+- \`end\` (string, required): End time (see formats below)
+- \`description\` (string, optional): Event description
+- \`location\` (string, optional): Event location
+- \`attendees\` (array, optional): Array of attendee email addresses
+- \`timezone\` (string, optional): IANA timezone (e.g., "America/Los_Angeles")
+- \`recurrence\` (array, optional): RRULE strings for recurring events
+- \`add_meet\` (boolean, optional): Auto-create Google Meet link (default: false)
+- \`confirm\` (boolean, required): Must be true to create event (safety check)
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Time Formats**:
+- **Timed event**: RFC3339 with timezone
+  - \`"2024-01-15T09:00:00-08:00"\` (Pacific Time)
+  - \`"2024-01-15T17:00:00Z"\` (UTC)
+- **All-day event**: Date only (YYYY-MM-DD)
+  - \`"2024-01-15"\` (all day)
+
+**Recurrence Examples**:
+- Weekly for 10 weeks: \`["RRULE:FREQ=WEEKLY;COUNT=10"]\`
+- Daily on weekdays: \`["RRULE:FREQ=DAILY;BYDAY=MO,TU,WE,TH,FR"]\`
+- Monthly on 15th: \`["RRULE:FREQ=MONTHLY;BYMONTHDAY=15"]\`
+
+**Returns**:
+Created event object containing:
+- \`id\`: Event ID (use for updates/deletes)
+- \`summary\`: Event title
+- \`start\`/\`end\`: Event times
+- \`html_link\`: Link to view in Google Calendar
+- \`hangout_link\`: Google Meet link (if add_meet was true)
+- \`attendees\`: List of attendees
+- All other event details
+
+**Examples**:
+- Simple event:
+  \`\`\`json
+  {
+    "summary": "Team Meeting",
+    "start": "2024-01-15T14:00:00-08:00",
+    "end": "2024-01-15T15:00:00-08:00",
+    "confirm": true
+  }
+  \`\`\`
+
+- All-day event:
+  \`\`\`json
+  {
+    "summary": "Conference",
+    "start": "2024-01-20",
+    "end": "2024-01-21",
+    "location": "San Francisco",
+    "confirm": true
+  }
+  \`\`\`
+
+- Meeting with attendees and Google Meet:
+  \`\`\`json
+  {
+    "summary": "Sprint Planning",
+    "start": "2024-01-15T10:00:00-08:00",
+    "end": "2024-01-15T11:30:00-08:00",
+    "description": "Q1 sprint planning session",
+    "attendees": ["alice@example.com", "bob@example.com"],
+    "add_meet": true,
+    "confirm": true
+  }
+  \`\`\`
+
+- Recurring weekly meeting:
+  \`\`\`json
+  {
+    "summary": "Weekly Standup",
+    "start": "2024-01-15T09:00:00-08:00",
+    "end": "2024-01-15T09:30:00-08:00",
+    "recurrence": ["RRULE:FREQ=WEEKLY;COUNT=10"],
+    "add_meet": true,
+    "confirm": true
+  }
+  \`\`\`
+
+**Common Use Cases**:
+- Create meetings with automatic Google Meet links
+- Schedule recurring events (daily standups, weekly meetings)
+- Create all-day events for conferences or holidays
+- Add attendees to events
+- Schedule events in shared calendars
+
+**Error Handling**:
+- Returns error if confirm is not true
+- Returns error if authentication fails
+- Returns error if calendar not accessible
+- Returns error if time format is invalid
+- Returns error if Calendar API request fails`;
+
+// src/tools/calendar-events.ts
+import { z as z3 } from "zod";
+var CalendarEventsInputSchema = z3.object({
+  calendar_id: z3.string().default("primary").describe('Calendar ID to list events from (default: "primary")'),
+  time_min: z3.string().optional().describe("Lower bound for event start time (RFC3339, e.g., 2024-01-01T00:00:00Z)"),
+  time_max: z3.string().optional().describe("Upper bound for event start time (RFC3339, e.g., 2024-12-31T23:59:59Z)"),
+  max_results: z3.number().int().min(1).max(250).default(10).describe("Maximum number of events to return (default: 10, max: 250)"),
+  query: z3.string().optional().describe("Free text search query to filter events"),
+  single_events: z3.boolean().default(true).describe("Expand recurring events into individual instances (default: true)"),
+  order_by: z3.enum(["startTime", "updated"]).default("startTime").describe('Sort order: "startTime" (default) or "updated"'),
+  output_format: z3.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+async function calendarEventsTool(calendarClient, params) {
+  try {
+    const events = await calendarClient.listEvents(params.calendar_id, params.time_min, params.time_max, params.max_results, params.query, params.single_events, params.order_by);
+    const output = {
+      calendar_id: params.calendar_id,
+      count: events.length,
+      events: events.map((event) => ({
+        id: event.id,
+        summary: event.summary,
+        description: event.description,
+        location: event.location,
+        start: event.start,
+        end: event.end,
+        status: event.status,
+        html_link: event.htmlLink,
+        hangout_link: event.hangoutLink,
+        attendees: event.attendees?.map((attendee) => ({
+          email: attendee.email,
+          display_name: attendee.displayName,
+          response_status: attendee.responseStatus,
+          optional: attendee.optional
+        })),
+        creator: event.creator,
+        organizer: event.organizer,
+        recurrence: event.recurrence,
+        recurring_event_id: event.recurringEventId
+      }))
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : eventListToMarkdown(output);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("listing calendar events", error);
+  }
+}
+var CALENDAR_EVENTS_DESCRIPTION = `List events from a Google Calendar with flexible filtering options.
+
+This tool retrieves events from a specified calendar with support for time ranges, text search, and various filtering options.
+
+**Parameters**:
+- \`calendar_id\` (string, optional): Calendar ID (default: "primary" for main calendar)
+- \`time_min\` (string, optional): Lower bound for event start time (RFC3339 timestamp)
+- \`time_max\` (string, optional): Upper bound for event start time (RFC3339 timestamp)
+- \`max_results\` (number, optional): Max events to return (1-250, default: 10)
+- \`query\` (string, optional): Free text search to filter events
+- \`single_events\` (boolean, optional): Expand recurring events (default: true)
+- \`order_by\` (string, optional): Sort by "startTime" (default) or "updated"
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns**:
+- \`calendar_id\`: The calendar ID used for the query
+- \`count\`: Number of events returned
+- \`events\`: Array of event objects containing:
+  - \`id\`: Event ID
+  - \`summary\`: Event title
+  - \`description\`: Event description
+  - \`location\`: Event location
+  - \`start\`: Start time (date or dateTime with timezone)
+  - \`end\`: End time (date or dateTime with timezone)
+  - \`status\`: Event status (confirmed, tentative, cancelled)
+  - \`html_link\`: Link to view event in Google Calendar
+  - \`hangout_link\`: Google Meet link if available
+  - \`attendees\`: List of attendees with response status
+  - \`creator\`: Event creator information
+  - \`organizer\`: Event organizer information
+  - \`recurrence\`: RRULE array for recurring events
+  - \`recurring_event_id\`: ID of recurring event series
+
+**RFC3339 Timestamp Format**:
+- Full datetime: \`2024-01-15T09:00:00-08:00\` or \`2024-01-15T17:00:00Z\`
+- Note: Use timezone offset or Z for UTC
+
+**Examples**:
+- Next 10 events: \`{ "calendar_id": "primary" }\`
+- Events this week: \`{ "time_min": "2024-01-15T00:00:00Z", "time_max": "2024-01-22T23:59:59Z" }\`
+- Search meetings: \`{ "query": "standup" }\`
+- Recent updates: \`{ "order_by": "updated", "max_results": 20 }\`
+- From shared calendar: \`{ "calendar_id": "team@example.com" }\`
+- JSON output: \`{ "output_format": "json" }\`
+
+**Common Use Cases**:
+- View upcoming events for today/week/month
+- Search for specific meetings or topics
+- Get event IDs for modification
+- Check availability and schedules
+- Monitor recently updated events
+
+**Error Handling**:
+- Returns error if authentication fails
+- Returns error if calendar doesn't exist or not accessible
+- Returns error if Calendar API request fails
+- Returns empty array if no events match filters`;
+
+// src/tools/calendar-get-event.ts
+import { z as z4 } from "zod";
+var CalendarGetEventInputSchema = z4.object({
+  calendar_id: z4.string().default("primary").describe('Calendar ID (default: "primary")'),
+  event_id: z4.string().min(1, "Event ID is required").describe("Event ID to retrieve"),
+  output_format: z4.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+async function calendarGetEventTool(calendarClient, params) {
+  try {
+    const event = await calendarClient.getEvent(params.calendar_id, params.event_id);
+    const output = {
+      id: event.id,
+      summary: event.summary,
+      description: event.description,
+      location: event.location,
+      start: event.start,
+      end: event.end,
+      status: event.status,
+      html_link: event.htmlLink,
+      hangout_link: event.hangoutLink,
+      attendees: event.attendees?.map((attendee) => ({
+        email: attendee.email,
+        display_name: attendee.displayName,
+        response_status: attendee.responseStatus,
+        optional: attendee.optional,
+        organizer: attendee.organizer,
+        self: attendee.self
+      })),
+      creator: event.creator,
+      organizer: event.organizer,
+      recurrence: event.recurrence,
+      recurring_event_id: event.recurringEventId,
+      created: event.created,
+      updated: event.updated
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : eventToMarkdown(output);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse(`getting event ${params.event_id} from calendar ${params.calendar_id}`, error);
+  }
+}
+var CALENDAR_GET_EVENT_DESCRIPTION = `Get detailed information about a specific calendar event by ID.
+
+This tool retrieves complete details for a single event, including all attendees, recurrence rules, and metadata.
+
+**Parameters**:
+- \`calendar_id\` (string, optional): Calendar ID (default: "primary")
+- \`event_id\` (string, required): Event ID to retrieve
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns**:
+Complete event object containing:
+- \`id\`: Event ID
+- \`summary\`: Event title
+- \`description\`: Full event description
+- \`location\`: Event location
+- \`start\`: Start time (date or dateTime with timezone)
+- \`end\`: End time (date or dateTime with timezone)
+- \`status\`: Event status (confirmed, tentative, cancelled)
+- \`html_link\`: Link to view/edit event in Google Calendar
+- \`hangout_link\`: Google Meet link if available
+- \`attendees\`: Complete attendee list with:
+  - \`email\`: Attendee email address
+  - \`display_name\`: Attendee name
+  - \`response_status\`: needsAction, declined, tentative, or accepted
+  - \`optional\`: Whether attendance is optional
+  - \`organizer\`: Whether this attendee is the organizer
+  - \`self\`: Whether this is the authenticated user
+- \`creator\`: Event creator (email and display name)
+- \`organizer\`: Event organizer (email and display name)
+- \`recurrence\`: RRULE array for recurring events
+- \`recurring_event_id\`: Parent event ID if this is a recurring instance
+- \`created\`: Event creation timestamp
+- \`updated\`: Last update timestamp
+
+**Examples**:
+- Get event from primary calendar: \`{ "event_id": "abc123xyz" }\`
+- Get from shared calendar: \`{ "calendar_id": "team@example.com", "event_id": "abc123xyz" }\`
+- JSON output: \`{ "event_id": "abc123xyz", "output_format": "json" }\`
+
+**Common Use Cases**:
+- View full event details including description
+- Check attendee responses
+- Get Google Meet link for a meeting
+- Retrieve recurrence rules
+- Check event metadata (created/updated times)
+
+**Error Handling**:
+- Returns error if authentication fails
+- Returns error if event doesn't exist
+- Returns error if calendar not accessible
+- Returns error if Calendar API request fails`;
+
+// src/tools/calendar-list.ts
+import { z as z5 } from "zod";
+var CalendarListInputSchema = z5.object({
+  show_hidden: z5.boolean().default(false).describe("Include hidden calendars in the results (default: false)"),
+  output_format: z5.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+async function calendarListTool(calendarClient, params) {
+  try {
+    const calendars = await calendarClient.listCalendars(params.show_hidden);
+    const output = {
+      count: calendars.length,
+      calendars: calendars.map((cal) => ({
+        id: cal.id,
+        summary: cal.summary,
+        description: cal.description,
+        timezone: cal.timeZone,
+        primary: cal.primary,
+        access_role: cal.accessRole,
+        background_color: cal.backgroundColor,
+        foreground_color: cal.foregroundColor
+      }))
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : calendarListToMarkdown(output);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("listing calendars", error);
+  }
+}
+var CALENDAR_LIST_DESCRIPTION = `List all calendars for the authenticated Google account.
+
+This tool retrieves all calendars accessible by the authenticated user, including their primary calendar, shared calendars, and subscribed calendars.
+
+**Parameters**:
+- \`show_hidden\` (boolean, optional): Include hidden calendars (default: false)
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns**:
+- \`count\`: Number of calendars found
+- \`calendars\`: Array of calendar objects containing:
+  - \`id\`: Calendar ID (use this for other calendar operations)
+  - \`summary\`: Calendar name/title
+  - \`description\`: Calendar description
+  - \`timezone\`: Calendar timezone (IANA format)
+  - \`primary\`: Whether this is the user's primary calendar
+  - \`access_role\`: User's access level (owner, writer, reader, freeBusyReader)
+  - \`background_color\`: Calendar background color (hex)
+  - \`foreground_color\`: Calendar foreground color (hex)
+
+**Examples**:
+- List visible calendars: \`{ "show_hidden": false }\`
+- List all calendars including hidden: \`{ "show_hidden": true }\`
+- JSON output: \`{ "output_format": "json" }\`
+
+**Common Use Cases**:
+- Get calendar IDs for use with other calendar tools
+- Discover shared calendars
+- Verify calendar access permissions
+
+**Error Handling**:
+- Returns error if authentication fails
+- Returns error if Calendar API request fails`;
+
+// src/tools/create-draft.ts
+import json2md3 from "json2md";
+import { z as z6 } from "zod";
+var CreateDraftInputSchema = z6.object({
+  to: z6.email("Must be a valid email address").describe("Recipient email address"),
+  subject: z6.string().min(1, "Subject cannot be empty").describe("Email subject"),
+  body: z6.string().min(1, "Body cannot be empty").describe("Email body content"),
+  content_type: z6.enum(["text/plain", "text/html"]).default("text/plain").describe("Content type: text/plain (default) or text/html for HTML emails"),
+  cc: z6.email("CC must be a valid email address").optional().describe("CC (carbon copy) email address"),
+  bcc: z6.email("BCC must be a valid email address").optional().describe("BCC (blind carbon copy) email address"),
+  output_format: z6.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function draftCreatedToMarkdown(params, result) {
+  const sections = [
+    { h1: "✅ Draft Created Successfully" },
+    { h2: "Draft Details" },
+    {
+      ul: [
+        `**To:** ${params.to}`,
+        ...params.cc ? [`**CC:** ${params.cc}`] : [],
+        ...params.bcc ? [`**BCC:** ${params.bcc}`] : [],
+        `**Subject:** ${params.subject}`,
+        `**Draft ID:** ${result.id}`,
+        `**Message ID:** ${result.message.id}`
+      ]
+    },
+    {
+      p: "The draft has been saved and will appear in your Drafts folder. You can edit and send it later from Gmail."
+    }
+  ];
+  return json2md3(sections);
+}
+async function createDraftTool(gmailClient, params) {
+  try {
+    const result = await gmailClient.createDraft(params.to, params.subject, params.body, params.content_type, params.cc, params.bcc);
+    const output = {
+      created: true,
+      draft_id: result.id,
+      message_id: result.message.id,
+      thread_id: result.message.threadId,
+      to: params.to,
+      cc: params.cc,
+      bcc: params.bcc,
+      subject: params.subject,
+      content_type: params.content_type
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : draftCreatedToMarkdown(params, result);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("creating draft", error);
+  }
+}
+var CREATE_DRAFT_DESCRIPTION = `Create a Gmail draft email that can be edited and sent later.
+
+This tool creates a draft email in your Gmail Drafts folder. Unlike sending an email directly, drafts are saved but not sent, allowing you to review, edit, or send them later through the Gmail interface.
+
+**Use Case**:
+- Compose emails for later review
+- Prepare emails that need approval before sending
+- Create email templates
+- Save work-in-progress emails
+
+**Parameters**:
+- \`to\` (string, required): Recipient email address
+- \`subject\` (string, required): Email subject line
+- \`body\` (string, required): Email body content
+- \`content_type\` (string, optional): "text/plain" (default) or "text/html" for HTML emails
+- \`cc\` (string, optional): CC email address
+- \`bcc\` (string, optional): BCC email address
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns**:
+- \`created\`: Always true on success
+- \`draft_id\`: Draft ID (for future operations)
+- \`message_id\`: Associated message ID
+- \`thread_id\`: Thread ID
+- \`to\`, \`cc\`, \`bcc\`: Recipients
+- \`subject\`: Email subject
+- \`content_type\`: Content type used
+
+**Examples**:
+- Simple draft: \`{ "to": "user@example.com", "subject": "Follow up", "body": "Hi there!" }\`
+- HTML draft: \`{ "to": "user@example.com", "subject": "Newsletter", "body": "<h1>News</h1>", "content_type": "text/html" }\`
+- With CC/BCC: \`{ "to": "user@example.com", "cc": "manager@example.com", "bcc": "archive@example.com", "subject": "Report", "body": "Quarterly report attached" }\`
+
+**HTML Emails**:
+- Set \`content_type: "text/html"\`
+- Body should contain valid HTML
+- Supported tags: h1-h6, p, a, strong, em, ul, ol, li, br, img
+
+**Comparison with send_email**:
+- \`create_draft\`: Saves to Drafts folder, does not send
+- \`send_email\`: Sends immediately (with confirmation)
+
+**Draft Management**:
+- Created drafts appear in Gmail's Drafts folder
+- Can be edited in Gmail web or mobile app
+- Can be sent later using Gmail interface
+- Draft ID can be used with other draft tools (update_draft, delete_draft)
+
+**Error Handling**:
+- Returns error if email addresses are invalid
+- Returns error if authentication lacks compose permissions
+- Returns error if Gmail API fails
+
+**Permissions**:
+- Requires \`gmail.compose\` or \`gmail.modify\` scope
+
+**Workflow**:
+1. Create draft with email content
+2. Draft is saved to Drafts folder
+3. Review/edit in Gmail if needed
+4. Send from Gmail when ready
+
+**Benefits**:
+- Safe: No risk of accidentally sending
+- Flexible: Can be edited before sending
+- Convenient: Pre-compose emails for later
+- Collaborative: Others with access can review drafts`;
+
+// src/tools/create-label.ts
+import json2md4 from "json2md";
+import { z as z7 } from "zod";
+var CreateLabelInputSchema = z7.object({
+  name: z7.string().min(1, "Label name cannot be empty").describe("The label name (e.g., 'Work', 'Personal/Family'). Use '/' for nested labels."),
+  message_list_visibility: z7.enum(["show", "hide"]).optional().describe("How label appears in message list. Default: 'show'. Use 'hide' to hide messages with this label from message list."),
+  label_list_visibility: z7.enum(["labelShow", "labelShowIfUnread", "labelHide"]).optional().describe("How label appears in label list. Default: 'labelShow'. Options: 'labelShow' (always visible), 'labelShowIfUnread' (only when unread), 'labelHide' (hidden)."),
+  background_color: z7.string().optional().describe("Background color in hex format (e.g., '#ff0000'). Must provide both background and text color together."),
+  text_color: z7.string().optional().describe("Text color in hex format (e.g., '#ffffff'). Must provide both background and text color together."),
+  output_format: z7.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function createdLabelToMarkdown(label) {
+  const sections = [
+    { h1: "Label Created Successfully" },
+    { h2: "Details" },
+    {
+      ul: [
+        `**Name:** ${label.name}`,
+        `**ID:** ${label.id}`,
+        "**Type:** Custom Label"
+      ]
+    }
+  ];
+  if (label.messageListVisibility || label.labelListVisibility) {
+    sections.push({ h2: "Visibility Settings" });
+    const visibilityItems = [];
+    if (label.messageListVisibility) {
+      visibilityItems.push(`**Message List:** ${label.messageListVisibility}`);
+    }
+    if (label.labelListVisibility) {
+      visibilityItems.push(`**Label List:** ${label.labelListVisibility}`);
+    }
+    sections.push({ ul: visibilityItems });
+  }
+  if (label.color) {
+    sections.push({ h2: "Color" });
+    sections.push({
+      ul: [
+        `**Text Color:** ${label.color.textColor}`,
+        `**Background Color:** ${label.color.backgroundColor}`
+      ]
+    });
+  }
+  sections.push({
+    p: `You can now use this label ID (${label.id}) with other tools like modify_labels or batch_modify.`
+  });
+  return json2md4(sections);
+}
+async function createLabelTool(gmailClient, params) {
+  try {
+    if (params.background_color && !params.text_color || !params.background_color && params.text_color) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Error: Both background_color and text_color must be provided together"
+          }
+        ],
+        isError: true
+      };
+    }
+    const label = await gmailClient.createLabel(params.name, params.message_list_visibility, params.label_list_visibility, params.background_color, params.text_color);
+    const output = {
+      id: label.id,
+      name: label.name,
+      type: label.type,
+      message_list_visibility: label.messageListVisibility || null,
+      label_list_visibility: label.labelListVisibility || null,
+      color: label.color || null,
+      created: true
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : createdLabelToMarkdown(label);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("creating label", error);
+  }
+}
+var CREATE_LABEL_DESCRIPTION = `Create a new custom Gmail label for organizing emails.
+
+This tool creates a new label with customizable visibility and color settings. Labels are used to organize and categorize emails in Gmail.
+
+**Parameters**:
+- \`name\` (string, required): The label name. Can include "/" for nested labels (e.g., "Work/Projects")
+- \`message_list_visibility\` (string, optional): How label appears in message list
+  - "show" (default): Messages with this label appear in message list
+  - "hide": Messages with this label are hidden from message list
+- \`label_list_visibility\` (string, optional): How label appears in label list (sidebar)
+  - "labelShow" (default): Always visible in label list
+  - "labelShowIfUnread": Only visible when there are unread messages
+  - "labelHide": Hidden from label list
+- \`background_color\` (string, optional): Background color in hex format (e.g., "#ff0000")
+- \`text_color\` (string, optional): Text color in hex format (e.g., "#ffffff")
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Color Settings**:
+- Both \`background_color\` and \`text_color\` must be provided together
+- Colors should be in hex format (e.g., "#ff0000" for red)
+- Gmail API will validate colors and may reject invalid combinations
+
+**Nested Labels**:
+- Use "/" in label name to create nested labels (e.g., "Work/Projects/2024")
+- Gmail automatically creates parent labels if they don't exist
+- Nested labels appear hierarchically in the label list
+
+**Returns**:
+- \`id\`: The newly created label ID (e.g., "Label_123")
+- \`name\`: The label name
+- \`type\`: Always "user" for custom labels
+- \`message_list_visibility\`: Applied message list visibility
+- \`label_list_visibility\`: Applied label list visibility
+- \`color\`: Applied color settings (if provided)
+- \`created\`: Always true on success
+
+**Use Cases**:
+- Create organizational labels (Work, Personal, Projects, etc.)
+- Create nested label hierarchies for detailed organization
+- Set up labels with custom colors for visual organization
+- Create labels to use with filters and automation
+
+**Examples**:
+- Simple label: \`{ "name": "Important" }\`
+- Nested label: \`{ "name": "Work/Projects/Q1-2024" }\`
+- Colored label: \`{ "name": "Urgent", "background_color": "#ff0000", "text_color": "#ffffff" }\`
+- Hidden label: \`{ "name": "Archive", "label_list_visibility": "labelHide" }\`
+
+**Error Handling**:
+- Returns error if label name already exists
+- Returns error if colors are invalid or only one color is provided
+- Returns error if authentication lacks gmail.labels scope
+- Requires \`gmail.labels\` scope for label creation
+
+**Scope Requirements**:
+- Requires \`gmail.labels\` or \`gmail.modify\` scope`;
+
+// src/tools/delete-label.ts
+import json2md5 from "json2md";
+import { z as z8 } from "zod";
+var SYSTEM_LABELS = [
+  "INBOX",
+  "SENT",
+  "DRAFT",
+  "TRASH",
+  "SPAM",
+  "STARRED",
+  "IMPORTANT",
+  "UNREAD",
+  "CATEGORY_PERSONAL",
+  "CATEGORY_SOCIAL",
+  "CATEGORY_PROMOTIONS",
+  "CATEGORY_UPDATES",
+  "CATEGORY_FORUMS"
+];
+var DeleteLabelInputSchema = z8.object({
+  label_id: z8.string().min(1, "Label ID cannot be empty").describe("The label ID to delete (e.g., 'Label_123'). Cannot delete system labels."),
+  output_format: z8.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function deletionToMarkdown(labelId) {
+  const sections = [
+    { h1: "Label Deleted Successfully" },
+    {
+      p: `Label with ID **${labelId}** has been permanently deleted from your Gmail account.`
+    },
+    { h2: "Important Notes" },
+    {
+      ul: [
+        "The label has been removed from all messages",
+        "Messages are not deleted, only the label is removed",
+        "This action cannot be undone",
+        "Label will no longer appear in label lists or on messages"
+      ]
+    }
+  ];
+  return json2md5(sections);
+}
+async function deleteLabelTool(gmailClient, params) {
+  try {
+    if (SYSTEM_LABELS.includes(params.label_id)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Cannot delete system label ${params.label_id}. Only user-created labels can be deleted.`
+          }
+        ],
+        isError: true
+      };
+    }
+    if (params.label_id.startsWith("CATEGORY_") || params.label_id === params.label_id.toUpperCase()) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Cannot delete system label ${params.label_id}. Only user-created labels can be deleted.`
+          }
+        ],
+        isError: true
+      };
+    }
+    await gmailClient.deleteLabel(params.label_id);
+    const output = {
+      label_id: params.label_id,
+      deleted: true,
+      message: "Label deleted successfully. The label has been removed from all messages."
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : deletionToMarkdown(params.label_id);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("cannot") || errorMessage.includes("system") || errorMessage.includes("permission")) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Cannot delete label ${params.label_id}. This appears to be a system label. Only user-created labels can be deleted.`
+          }
+        ],
+        isError: true
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error deleting label: ${errorMessage}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+var DELETE_LABEL_DESCRIPTION = `Delete a custom Gmail label permanently.
+
+This tool permanently deletes a user-created label from your Gmail account. System labels cannot be deleted. The label is removed from all messages, but the messages themselves are not deleted.
+
+**IMPORTANT: This is a destructive operation that cannot be undone.**
+
+**Parameters**:
+- \`label_id\` (string, required): The label ID to delete (e.g., "Label_123")
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**System Label Protection**:
+- System labels (INBOX, SENT, TRASH, STARRED, etc.) **cannot** be deleted
+- Category labels (CATEGORY_PERSONAL, CATEGORY_SOCIAL, etc.) **cannot** be deleted
+- Only user-created custom labels can be deleted
+- Attempting to delete a system label returns a clear error message
+
+**What Happens When You Delete a Label**:
+1. The label is permanently removed from your Gmail account
+2. The label is removed from all messages that had it
+3. Messages are **not** deleted - only the label is removed
+4. This action **cannot be undone**
+5. The label will no longer appear in:
+   - Label lists
+   - Message labels
+   - Filters or automation rules
+
+**Returns**:
+- \`label_id\`: The deleted label ID
+- \`deleted\`: Always true on success
+- \`message\`: Confirmation message
+
+**Use Cases**:
+- Remove unused custom labels
+- Clean up label organization
+- Delete obsolete or incorrectly created labels
+- Remove labels that are no longer needed
+
+**Examples**:
+- Delete custom label: \`{ "label_id": "Label_123" }\`
+- Delete with JSON output: \`{ "label_id": "Label_456", "output_format": "json" }\`
+
+**Error Handling**:
+- Returns error if label ID doesn't exist
+- Returns error if trying to delete system labels
+- Returns error if authentication lacks gmail.labels scope
+- Returns clear error message explaining why deletion failed
+
+**Safety Considerations**:
+- This is a destructive operation marked with \`destructiveHint: true\`
+- Consider using \`get_label\` first to verify which label you're deleting
+- Use \`list_labels\` to see all labels before deletion
+- There is no "undo" - once deleted, the label is gone permanently
+- Messages with the label are not affected, only the label itself is removed
+
+**Scope Requirements**:
+- Requires \`gmail.labels\` or \`gmail.modify\` scope
+
+**Alternative to Deletion**:
+If you want to hide a label instead of deleting it, consider using the \`update_label\` tool to set \`label_list_visibility\` to "labelHide" instead.`;
+
+// src/tools/get-attachment.ts
+import { z as z9 } from "zod";
+var GetAttachmentInputSchema = z9.object({
+  message_id: z9.string().min(1, "Message ID cannot be empty").describe("The Gmail message ID containing the attachment"),
+  attachment_id: z9.string().min(1, "Attachment ID cannot be empty").describe("The attachment ID to download (from list_attachments)"),
+  output_format: z9.enum(["base64", "json"]).default("base64").describe("Output format: base64 (default, returns raw base64url string) or json (returns structured object)")
+});
+async function getAttachmentTool(gmailClient, params) {
+  try {
+    const attachmentData = await gmailClient.getAttachment(params.message_id, params.attachment_id);
+    const output = {
+      message_id: params.message_id,
+      attachment_id: params.attachment_id,
+      data: attachmentData,
+      encoding: "base64url",
+      note: "Data is base64url encoded. To decode: replace - with +, _ with /, then base64 decode."
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : attachmentData;
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("getting attachment", error);
+  }
+}
+var GET_ATTACHMENT_DESCRIPTION = `Download a Gmail attachment by its attachment ID.
+
+This tool downloads the content of a specific attachment from a Gmail message. The attachment is returned as base64url-encoded data.
+
+**Parameters**:
+- \`message_id\` (string, required): The Gmail message ID containing the attachment
+- \`attachment_id\` (string, required): The attachment ID (obtained from list_attachments tool)
+- \`output_format\` (string, optional): Output format: "base64" (default) or "json"
+
+**Returns**:
+- \`message_id\`: The message ID
+- \`attachment_id\`: The attachment ID
+- \`data\`: Base64url-encoded attachment data
+- \`encoding\`: Always "base64url"
+- \`note\`: Decoding instructions
+
+**Base64url Encoding**:
+Gmail uses base64url encoding (URL-safe variant):
+- Characters \`-\` and \`_\` replace \`+\` and \`/\`
+- No padding with \`=\`
+
+To decode:
+1. Replace \`-\` with \`+\`
+2. Replace \`_\` with \`/\`
+3. Base64 decode the result
+
+**Examples**:
+- Get attachment: \`{ "message_id": "18f3c5d4e8a2b1c0", "attachment_id": "ANGjdJ8..." }\`
+- JSON output: \`{ "message_id": "18f3c5d4e8a2b1c0", "attachment_id": "ANGjdJ8...", "output_format": "json" }\`
+
+**Error Handling**:
+- Returns error if message ID doesn't exist
+- Returns error if attachment ID doesn't exist or is invalid
+- Returns error if authentication fails
+
+**Use Cases**:
+- Download email attachments programmatically
+- Extract attachment data for processing
+- Save attachments to disk after decoding
+
+**Workflow**:
+1. Use \`list_attachments\` to get attachment IDs and metadata
+2. Use this tool to download specific attachments by ID
+3. Decode base64url data to get original file content`;
+
+// src/tools/get-email.ts
+import json2md6 from "json2md";
+import { z as z10 } from "zod";
+var GetEmailInputSchema = z10.object({
+  message_id: z10.string().min(1, "Message ID cannot be empty").describe("The Gmail message ID to retrieve"),
+  include_body: z10.boolean().default(true).describe("Whether to include full email body in results (default: true)"),
+  output_format: z10.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function emailToMarkdown(email) {
+  const sections = [
+    { h1: email.subject },
+    {
+      ul: [
+        `**From:** ${email.from}`,
+        `**To:** ${email.to}`,
+        `**Date:** ${email.date}`,
+        `**Message ID:** ${email.id}`,
+        `**Thread ID:** ${email.thread_id}`
+      ]
+    }
+  ];
+  if (email.labels && email.labels.length > 0) {
+    sections.push({
+      p: `**Labels:** ${email.labels.join(", ")}`
+    });
+  }
+  if (email.body) {
+    sections.push({ h2: "Body" });
+    sections.push({ p: email.body });
+  } else {
+    sections.push({ h2: "Snippet" });
+    sections.push({ p: email.snippet });
+  }
+  return json2md6(sections);
+}
+async function getEmailTool(gmailClient, params) {
+  try {
+    const email = await gmailClient.getMessage(params.message_id, params.include_body);
+    const output = formatEmailForOutput(email);
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : emailToMarkdown(output);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("getting email", error);
+  }
+}
+var GET_EMAIL_DESCRIPTION = `Get a single Gmail email by its message ID with full details.
+
+This tool retrieves a specific email message from Gmail using its unique message ID. It returns detailed information including headers, body content, labels, and thread information.
+
+**Parameters**:
+- \`message_id\` (string, required): The Gmail message ID to retrieve
+- \`include_body\` (boolean, optional): Include full email body (default: true)
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns**:
+- \`id\`: Message ID
+- \`thread_id\`: Thread ID (for conversation grouping)
+- \`subject\`: Email subject line
+- \`from\`: Sender email address
+- \`to\`: Recipient email address(es)
+- \`date\`: Email date
+- \`snippet\`: Short preview of email content
+- \`body\`: Full email body (if include_body is true)
+- \`labels\`: Array of Gmail labels applied to the email
+
+**Examples**:
+- Get email with body: \`{ "message_id": "18f3c5d4e8a2b1c0" }\`
+- Get email metadata only: \`{ "message_id": "18f3c5d4e8a2b1c0", "include_body": false }\`
+- JSON output: \`{ "message_id": "18f3c5d4e8a2b1c0", "output_format": "json" }\`
+
+**Error Handling**:
+- Returns error if message ID doesn't exist
+- Returns error if authentication fails
+- Returns error if Gmail API request fails
+
+**Use Cases**:
+- View full content of a specific email
+- Get detailed email headers and metadata
+- Retrieve email for further processing or analysis`;
+
+// src/tools/get-label.ts
+import json2md7 from "json2md";
+import { z as z11 } from "zod";
+var GetLabelInputSchema = z11.object({
+  label_id: z11.string().min(1, "Label ID cannot be empty").describe("The label ID to retrieve (e.g., 'INBOX', 'Label_123')"),
+  output_format: z11.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function labelToMarkdown(label) {
+  const sections = [
+    { h1: `Label: ${label.name}` },
+    { h2: "Details" },
+    {
+      ul: [
+        `**ID:** ${label.id}`,
+        `**Type:** ${label.type === "system" ? "System Label" : "Custom Label"}`,
+        `**Total Messages:** ${label.messagesTotal || 0}`,
+        `**Unread Messages:** ${label.messagesUnread || 0}`
+      ]
+    }
+  ];
+  if (label.messageListVisibility || label.labelListVisibility) {
+    sections.push({ h2: "Visibility Settings" });
+    const visibilityItems = [];
+    if (label.messageListVisibility) {
+      visibilityItems.push(`**Message List:** ${label.messageListVisibility}`);
+    }
+    if (label.labelListVisibility) {
+      visibilityItems.push(`**Label List:** ${label.labelListVisibility}`);
+    }
+    sections.push({ ul: visibilityItems });
+  }
+  if (label.color) {
+    sections.push({ h2: "Color" });
+    sections.push({
+      ul: [
+        `**Text Color:** ${label.color.textColor}`,
+        `**Background Color:** ${label.color.backgroundColor}`
+      ]
+    });
+  }
+  return json2md7(sections);
+}
+async function getLabelTool(gmailClient, params) {
+  try {
+    const label = await gmailClient.getLabel(params.label_id);
+    const output = {
+      id: label.id,
+      name: label.name,
+      type: label.type,
+      message_list_visibility: label.messageListVisibility || null,
+      label_list_visibility: label.labelListVisibility || null,
+      messages_total: label.messagesTotal || 0,
+      messages_unread: label.messagesUnread || 0,
+      color: label.color || null
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : labelToMarkdown(label);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("getting label", error);
+  }
+}
+var GET_LABEL_DESCRIPTION = `Get detailed information about a specific Gmail label.
+
+This tool retrieves comprehensive details about a label, including its name, type, visibility settings, message counts, and color configuration.
+
+**Parameters**:
+- \`label_id\` (string, required): The label ID to retrieve (e.g., "INBOX", "Label_123")
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns**:
+- \`id\`: Label ID
+- \`name\`: Label name
+- \`type\`: "system" or "user"
+- \`message_list_visibility\`: How label appears in message list ("show" or "hide")
+- \`label_list_visibility\`: How label appears in label list ("labelShow", "labelShowIfUnread", or "labelHide")
+- \`messages_total\`: Total number of messages with this label
+- \`messages_unread\`: Number of unread messages with this label
+- \`color\`: Label color configuration (textColor and backgroundColor)
+
+**Label Types**:
+- **System Labels**: Predefined Gmail labels like INBOX, SENT, TRASH, STARRED, etc.
+- **Custom Labels**: User-created labels with IDs like "Label_123"
+
+**Visibility Settings**:
+- \`messageListVisibility\`: Controls if messages with this label show in message list
+- \`labelListVisibility\`: Controls how label appears in left sidebar label list
+
+**Use Cases**:
+- Check message counts for a specific label
+- View label configuration and settings
+- Verify label exists before using in other operations
+- Check color settings for custom labels
+
+**Examples**:
+- Get inbox details: \`{ "label_id": "INBOX" }\`
+- Get custom label: \`{ "label_id": "Label_123" }\`
+- Get starred label info: \`{ "label_id": "STARRED" }\`
+
+**Error Handling**:
+- Returns error if label ID doesn't exist
+- Returns error if authentication fails
+- System labels and custom labels are both supported`;
+
+// src/tools/get-thread.ts
+import json2md8 from "json2md";
+import { z as z12 } from "zod";
+var GetThreadInputSchema = z12.object({
+  thread_id: z12.string().min(1, "Thread ID cannot be empty").describe("The Gmail thread ID to retrieve"),
+  include_body: z12.boolean().default(false).describe("Whether to include full email body for all messages (default: false)"),
+  output_format: z12.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function threadToMarkdown(threadId, messages) {
+  const sections = [
+    { h1: `Thread: ${messages[0]?.subject || "Conversation"}` },
+    {
+      p: `**Thread ID:** ${threadId} | **Messages:** ${messages.length}`
+    }
+  ];
+  for (const [index, message] of messages.entries()) {
+    sections.push({ h2: `Message ${index + 1}` });
+    sections.push({
+      ul: [
+        `**From:** ${message.from}`,
+        `**To:** ${message.to}`,
+        `**Date:** ${message.date}`,
+        `**Message ID:** ${message.id}`
+      ]
+    });
+    if (message.labels && message.labels.length > 0) {
+      sections.push({
+        p: `**Labels:** ${message.labels.join(", ")}`
+      });
+    }
+    if (message.body) {
+      sections.push({ h3: "Body" });
+      sections.push({ p: message.body });
+    } else {
+      sections.push({ h3: "Snippet" });
+      sections.push({ p: message.snippet });
+    }
+    if (index < messages.length - 1) {
+      sections.push({ p: "---" });
+    }
+  }
+  return json2md8(sections);
+}
+async function getThreadTool(gmailClient, params) {
+  try {
+    const messages = await gmailClient.getThread(params.thread_id, params.include_body);
+    const output = {
+      thread_id: params.thread_id,
+      message_count: messages.length,
+      messages: messages.map(formatEmailForOutput)
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : threadToMarkdown(params.thread_id, output.messages);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("getting thread", error);
+  }
+}
+var GET_THREAD_DESCRIPTION = `Get an entire Gmail conversation thread by its thread ID.
+
+This tool retrieves all messages in a Gmail conversation thread (email chain). Threads group related messages together, including original emails and all replies.
+
+**Parameters**:
+- \`thread_id\` (string, required): The Gmail thread ID to retrieve
+- \`include_body\` (boolean, optional): Include full email body for all messages (default: false, only snippets)
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns**:
+- \`thread_id\`: The thread ID
+- \`message_count\`: Number of messages in the thread
+- \`messages\`: Array of email messages in chronological order, each containing:
+  - \`id\`: Message ID
+  - \`thread_id\`: Thread ID
+  - \`subject\`: Email subject
+  - \`from\`: Sender email address
+  - \`to\`: Recipient email address(es)
+  - \`date\`: Email date
+  - \`snippet\`: Short preview
+  - \`body\`: Full body (if include_body is true)
+  - \`labels\`: Gmail labels
+
+**Examples**:
+- Get thread with snippets: \`{ "thread_id": "18f3c5d4e8a2b1c0" }\`
+- Get thread with full bodies: \`{ "thread_id": "18f3c5d4e8a2b1c0", "include_body": true }\`
+- JSON output: \`{ "thread_id": "18f3c5d4e8a2b1c0", "output_format": "json" }\`
+
+**Error Handling**:
+- Returns error if thread ID doesn't exist
+- Returns error if authentication fails
+- Returns error if Gmail API request fails
+
+**Use Cases**:
+- View complete email conversation history
+- Analyze email chains and reply patterns
+- Extract all messages from a discussion thread`;
+
+// src/tools/list-attachments.ts
+import json2md9 from "json2md";
+import { z as z13 } from "zod";
+var ListAttachmentsInputSchema = z13.object({
+  message_id: z13.string().min(1, "Message ID cannot be empty").describe("The Gmail message ID to list attachments from"),
+  output_format: z13.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function formatBytes(bytes) {
+  if (bytes === 0) {
+    return "0 B";
+  }
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${Number.parseFloat((bytes / k ** i).toFixed(2))} ${sizes[i]}`;
+}
+function attachmentsToMarkdown(messageId, attachments) {
+  const sections = [
+    { h1: "Email Attachments" },
+    {
+      p: `**Message ID:** ${messageId} | **Total Attachments:** ${attachments.length}`
+    }
+  ];
+  if (attachments.length === 0) {
+    sections.push({ p: "*No attachments found in this email.*" });
+  } else {
+    for (const [index, attachment] of attachments.entries()) {
+      sections.push({ h2: `${index + 1}. ${attachment.filename}` });
+      sections.push({
+        ul: [
+          `**Type:** ${attachment.mimeType}`,
+          `**Size:** ${formatBytes(attachment.size)}`,
+          `**Attachment ID:** ${attachment.attachmentId}`
+        ]
+      });
+    }
+  }
+  return json2md9(sections);
+}
+async function listAttachmentsTool(gmailClient, params) {
+  try {
+    const attachments = await gmailClient.listAttachments(params.message_id);
+    const output = {
+      message_id: params.message_id,
+      attachment_count: attachments.length,
+      attachments: attachments.map((att) => ({
+        filename: att.filename,
+        mime_type: att.mimeType,
+        size: att.size,
+        size_formatted: formatBytes(att.size),
+        attachment_id: att.attachmentId
+      }))
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : attachmentsToMarkdown(params.message_id, attachments);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("listing attachments", error);
+  }
+}
+var LIST_ATTACHMENTS_DESCRIPTION = `List all attachments for a Gmail email message.
+
+This tool retrieves metadata about all attachments in a specific email message, including filenames, MIME types, sizes, and attachment IDs needed to download them.
+
+**Parameters**:
+- \`message_id\` (string, required): The Gmail message ID to list attachments from
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns**:
+- \`message_id\`: The message ID
+- \`attachment_count\`: Number of attachments found
+- \`attachments\`: Array of attachment metadata objects:
+  - \`filename\`: Original filename
+  - \`mime_type\`: MIME type (e.g., "application/pdf", "image/jpeg")
+  - \`size\`: Size in bytes
+  - \`size_formatted\`: Human-readable size (e.g., "2.5 MB")
+  - \`attachment_id\`: ID needed to download the attachment
+
+**Examples**:
+- List attachments: \`{ "message_id": "18f3c5d4e8a2b1c0" }\`
+- JSON output: \`{ "message_id": "18f3c5d4e8a2b1c0", "output_format": "json" }\`
+
+**Error Handling**:
+- Returns error if message ID doesn't exist
+- Returns error if authentication fails
+- Returns empty array if message has no attachments
+
+**Use Cases**:
+- Check if an email has attachments before downloading
+- Get attachment metadata for processing decisions
+- List attachment IDs for use with get_attachment tool`;
+
+// src/tools/list-labels.ts
+import json2md10 from "json2md";
+import { z as z14 } from "zod";
+var ListLabelsInputSchema = z14.object({
+  output_format: z14.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function labelsToMarkdown(labels) {
+  const sections = [{ h1: "Gmail Labels" }];
+  if (labels.system.length > 0) {
+    sections.push({ h2: "System Labels" });
+    const systemLabels = labels.system.map((label) => `**${label.name}** (${label.id}) - ${label.total} total, ${label.unread} unread`);
+    sections.push({ ul: systemLabels });
+  }
+  if (labels.user.length > 0) {
+    sections.push({ h2: "Custom Labels" });
+    const userLabels = labels.user.map((label) => `**${label.name}** (${label.id}) - ${label.total} total, ${label.unread} unread`);
+    sections.push({ ul: userLabels });
+  }
+  if (labels.system.length === 0 && labels.user.length === 0) {
+    sections.push({ p: "*No labels found*" });
+  }
+  return json2md10(sections);
+}
+async function listLabelsTool(gmailClient, params) {
+  try {
+    const labels = await gmailClient.listLabels();
+    const systemLabels = labels.filter((label) => label.type === "system").map((label) => ({
+      id: label.id,
+      name: label.name,
+      total: label.messagesTotal || 0,
+      unread: label.messagesUnread || 0
+    }));
+    const userLabels = labels.filter((label) => label.type === "user").map((label) => ({
+      id: label.id,
+      name: label.name,
+      total: label.messagesTotal || 0,
+      unread: label.messagesUnread || 0
+    }));
+    const output = {
+      total_count: labels.length,
+      system_count: systemLabels.length,
+      user_count: userLabels.length,
+      system: systemLabels,
+      user: userLabels
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : labelsToMarkdown({ system: systemLabels, user: userLabels });
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("listing labels", error);
+  }
+}
+var LIST_LABELS_DESCRIPTION = `List all Gmail labels (both system and custom labels).
+
+This tool retrieves all labels in your Gmail account, including system labels (INBOX, SENT, etc.) and user-created custom labels. Each label includes message counts (total and unread).
+
+**Returns**:
+- \`total_count\`: Total number of labels
+- \`system_count\`: Number of system labels
+- \`user_count\`: Number of custom user labels
+- \`system\`: Array of system labels with id, name, total, and unread counts
+- \`user\`: Array of custom labels with id, name, total, and unread counts
+
+**System Labels**:
+System labels are predefined by Gmail and include:
+- \`INBOX\` - Inbox
+- \`SENT\` - Sent mail
+- \`DRAFT\` - Drafts
+- \`TRASH\` - Trash
+- \`SPAM\` - Spam
+- \`STARRED\` - Starred messages
+- \`IMPORTANT\` - Important marker
+- \`UNREAD\` - Unread status
+- \`CATEGORY_*\` - Category labels (PERSONAL, SOCIAL, PROMOTIONS, etc.)
+
+**Custom Labels**:
+Custom labels are created by users for organizing emails. They have IDs like \`Label_123\` and can have any name, including nested labels using "/" (e.g., "Work/Projects").
+
+**Parameters**:
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Use Cases**:
+- Discover available labels for organizing emails
+- Find label IDs for use with modify_labels or other tools
+- Check message counts per label
+- List all custom organizational labels
+
+**Error Handling**:
+- Returns error if authentication fails
+- Returns error if Gmail API is unreachable`;
+
+// src/tools/modify-labels.ts
+import json2md11 from "json2md";
+import { z as z15 } from "zod";
+var ModifyLabelsInputSchema = z15.object({
+  message_id: z15.string().min(1, "Message ID cannot be empty").describe("The Gmail message ID to modify labels for"),
+  add_labels: z15.array(z15.string()).optional().describe("Label IDs to add (e.g., ['STARRED', 'INBOX', 'UNREAD'] or custom label IDs)"),
+  remove_labels: z15.array(z15.string()).optional().describe("Label IDs to remove (e.g., ['UNREAD', 'INBOX'] to mark read and archive)"),
+  output_format: z15.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function labelModificationToMarkdown(email, addedLabels, removedLabels) {
+  const sections = [
+    { h1: "Label Modification Successful" },
+    { h2: "Message Details" },
+    {
+      ul: [
+        `**Subject:** ${email.subject}`,
+        `**From:** ${email.from}`,
+        `**Message ID:** ${email.id}`
+      ]
+    }
+  ];
+  if (addedLabels && addedLabels.length > 0) {
+    sections.push({ h2: "Added Labels" });
+    sections.push({ ul: addedLabels });
+  }
+  if (removedLabels && removedLabels.length > 0) {
+    sections.push({ h2: "Removed Labels" });
+    sections.push({ ul: removedLabels });
+  }
+  sections.push({ h2: "Current Labels" });
+  sections.push({
+    p: email.labels.length > 0 ? email.labels.join(", ") : "*No labels on this message*"
+  });
+  return json2md11(sections);
+}
+async function modifyLabelsTool(gmailClient, params) {
+  try {
+    if (!(params.add_labels || params.remove_labels)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Error: Must specify at least one of add_labels or remove_labels"
+          }
+        ],
+        isError: true
+      };
+    }
+    const email = await gmailClient.modifyLabels(params.message_id, params.add_labels, params.remove_labels);
+    const output = {
+      message_id: params.message_id,
+      subject: email.subject,
+      modified: true,
+      added_labels: params.add_labels || [],
+      removed_labels: params.remove_labels || [],
+      current_labels: email.labels || []
+    };
+    const formattedEmail = formatEmailForOutput(email);
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : labelModificationToMarkdown({
+      ...formattedEmail,
+      labels: email.labels || []
+    }, params.add_labels, params.remove_labels);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("modifying labels", error);
+  }
+}
+var MODIFY_LABELS_DESCRIPTION = `Modify Gmail labels on a single message (add or remove labels).
+
+This tool allows you to add or remove labels from a Gmail message. Labels are used for organizing emails, marking read/unread status, starring, archiving, and more.
+
+**Common Gmail System Labels**:
+- \`INBOX\` - Inbox (remove to archive)
+- \`UNREAD\` - Unread status (remove to mark as read)
+- \`STARRED\` - Starred/important
+- \`SPAM\` - Spam folder
+- \`TRASH\` - Trash folder
+- \`SENT\` - Sent mail
+- \`DRAFT\` - Draft messages
+- \`IMPORTANT\` - Important marker
+- \`CATEGORY_PERSONAL\`, \`CATEGORY_SOCIAL\`, \`CATEGORY_PROMOTIONS\`, etc.
+
+**Custom Labels**:
+- User-created labels have IDs like \`Label_123\`
+- Use the list_labels tool to discover custom label IDs
+
+**Parameters**:
+- \`message_id\` (string, required): The Gmail message ID to modify
+- \`add_labels\` (array, optional): Label IDs to add
+- \`remove_labels\` (array, optional): Label IDs to remove
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns**:
+- \`message_id\`: The message ID
+- \`subject\`: Email subject
+- \`modified\`: Always true on success
+- \`added_labels\`: Labels that were added
+- \`removed_labels\`: Labels that were removed
+- \`current_labels\`: All current labels on the message
+
+**Examples**:
+- Mark as read and archive: \`{ "message_id": "18f3c5d4e8a2b1c0", "remove_labels": ["UNREAD", "INBOX"] }\`
+- Star an email: \`{ "message_id": "18f3c5d4e8a2b1c0", "add_labels": ["STARRED"] }\`
+- Mark as unread: \`{ "message_id": "18f3c5d4e8a2b1c0", "add_labels": ["UNREAD"] }\`
+- Add to inbox: \`{ "message_id": "18f3c5d4e8a2b1c0", "add_labels": ["INBOX"] }\`
+- Apply custom label: \`{ "message_id": "18f3c5d4e8a2b1c0", "add_labels": ["Label_123"] }\`
+
+**Error Handling**:
+- Returns error if message ID doesn't exist
+- Returns error if label ID is invalid
+- Returns error if authentication lacks modify permissions
+- Requires at least one of add_labels or remove_labels
+
+**Use Cases**:
+- Mark emails as read or unread
+- Archive emails (remove INBOX label)
+- Star important messages
+- Apply custom labels for organization
+- Move messages to trash or spam`;
+
+// src/tools/reply.ts
+import json2md12 from "json2md";
+import { z as z16 } from "zod";
+var ReplyInputSchema = z16.object({
+  message_id: z16.string().min(1, "Message ID cannot be empty").describe("The Gmail message ID to reply to"),
+  body: z16.string().min(1, "Reply body cannot be empty").describe("Reply message body"),
+  content_type: z16.enum(["text/plain", "text/html"]).default("text/plain").describe("Content type: text/plain (default) or text/html for HTML replies"),
+  cc: z16.email("CC must be a valid email address").optional().describe("CC (carbon copy) email address"),
+  confirm: z16.boolean().default(false).describe("Set to true to confirm and send the reply. If false, returns preview only."),
+  output_format: z16.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function replyPreviewToMarkdown(originalEmail, replyBody, contentType, cc) {
+  const sections = [
+    { h1: "Reply Preview - NOT SENT" },
+    {
+      p: "⚠️ **This reply has not been sent yet.** Set `confirm: true` to send."
+    },
+    { h2: "Original Message" },
+    {
+      ul: [
+        `**From:** ${originalEmail.from}`,
+        `**Subject:** ${originalEmail.subject}`,
+        `**Date:** ${originalEmail.date}`
+      ]
+    },
+    { h2: "Your Reply" },
+    {
+      ul: [
+        `**To:** ${originalEmail.from}`,
+        ...cc ? [`**CC:** ${cc}`] : [],
+        `**Subject:** Re: ${originalEmail.subject}`,
+        `**Content Type:** ${contentType}`
+      ]
+    },
+    { h2: "Reply Body" },
+    { p: replyBody }
+  ];
+  return json2md12(sections);
+}
+function replySentToMarkdown(originalEmail, result, cc) {
+  const sections = [
+    { h1: "✅ Reply Sent Successfully" },
+    { h2: "Reply Details" },
+    {
+      ul: [
+        `**To:** ${originalEmail.from}`,
+        ...cc ? [`**CC:** ${cc}`] : [],
+        `**Subject:** Re: ${originalEmail.subject}`,
+        `**Message ID:** ${result.id}`,
+        `**Thread ID:** ${result.threadId}`
+      ]
+    },
+    {
+      p: "Your reply has been sent and added to the conversation thread."
+    }
+  ];
+  return json2md12(sections);
+}
+async function replyTool(gmailClient, params) {
+  try {
+    const originalMessage = await gmailClient.getMessage(params.message_id);
+    if (!params.confirm) {
+      const output2 = {
+        status: "preview",
+        sent: false,
+        original_message: {
+          id: originalMessage.id,
+          thread_id: originalMessage.threadId,
+          subject: originalMessage.subject,
+          from: originalMessage.from,
+          date: originalMessage.date
+        },
+        reply: {
+          to: originalMessage.from,
+          cc: params.cc,
+          subject: `Re: ${originalMessage.subject}`,
+          body: params.body,
+          content_type: params.content_type
+        },
+        warning: "Reply NOT sent. Set confirm:true to actually send this reply."
+      };
+      const textContent2 = params.output_format === "json" ? JSON.stringify(output2, null, 2) : replyPreviewToMarkdown(originalMessage, params.body, params.content_type, params.cc);
+      return {
+        content: [{ type: "text", text: textContent2 }],
+        structuredContent: output2
+      };
+    }
+    const result = await gmailClient.replyToEmail(originalMessage.from, originalMessage.subject, params.body, originalMessage.threadId, originalMessage.id, params.content_type, params.cc);
+    const output = {
+      status: "sent",
+      sent: true,
+      message_id: result.id,
+      thread_id: result.threadId,
+      original_message_id: params.message_id,
+      to: originalMessage.from,
+      cc: params.cc,
+      subject: `Re: ${originalMessage.subject}`,
+      label_ids: result.labelIds
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : replySentToMarkdown(originalMessage, result, params.cc);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("sending reply", error);
+  }
+}
+var REPLY_DESCRIPTION = `Reply to an existing Gmail email in its conversation thread.
+
+This tool sends a reply to an existing email, automatically threading it in the conversation. It includes a safety feature: by default it shows a preview without sending. You must explicitly set \`confirm: true\` to actually send the reply.
+
+**Safety Feature**:
+- Default behavior: Shows preview only, does NOT send
+- To actually send: Set \`confirm: true\`
+- This prevents accidental sends
+
+**Automatic Threading**:
+- Reply is automatically added to the conversation thread
+- Subject line gets "Re:" prefix
+- Recipient is the sender of the original message
+- Thread ID is preserved for conversation continuity
+
+**Parameters**:
+- \`message_id\` (string, required): The message ID to reply to
+- \`body\` (string, required): Your reply message body
+- \`content_type\` (string, optional): "text/plain" (default) or "text/html"
+- \`cc\` (string, optional): CC email address
+- \`confirm\` (boolean, required): Must be true to actually send (default: false)
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns** (preview mode):
+- \`status\`: "preview"
+- \`sent\`: false
+- \`original_message\`: Details of message being replied to
+- \`reply\`: Preview of your reply
+- Warning message
+
+**Returns** (sent mode):
+- \`status\`: "sent"
+- \`sent\`: true
+- \`message_id\`: Reply message ID
+- \`thread_id\`: Conversation thread ID
+- \`original_message_id\`: Original message ID
+- \`label_ids\`: Applied labels
+
+**Examples**:
+- Preview: \`{ "message_id": "18f3c5d4e8a2b1c0", "body": "Thanks for your email!" }\`
+- Send reply: \`{ "message_id": "18f3c5d4e8a2b1c0", "body": "Thanks!", "confirm": true }\`
+- HTML reply: \`{ "message_id": "18f3c5d4e8a2b1c0", "body": "<p>Thanks!</p>", "content_type": "text/html", "confirm": true }\`
+- With CC: \`{ "message_id": "18f3c5d4e8a2b1c0", "body": "Noted", "cc": "boss@example.com", "confirm": true }\`
+
+**How It Works**:
+1. Fetches original message to get sender, subject, and thread ID
+2. Constructs reply with proper headers (In-Reply-To, References)
+3. Sends reply in the same thread
+4. Reply appears in Gmail as part of the conversation
+
+**Error Handling**:
+- Returns error if message ID doesn't exist
+- Returns error if authentication lacks send permissions
+- Returns error if Gmail API fails
+
+**Permissions**:
+- Requires \`gmail.send\` or \`gmail.compose\` scope
+- Requires \`gmail.readonly\` to fetch original message
+
+**Use Cases**:
+- Respond to customer inquiries
+- Continue email conversations
+- Send acknowledgments
+- Reply to notifications
+
+**Workflow**:
+1. Use \`search_emails\` or \`get_email\` to find message
+2. Call without \`confirm\` to preview reply
+3. Review the preview
+4. Call with \`confirm: true\` to send`;
+
+// src/tools/search.ts
+import { z as z17 } from "zod";
+var SearchEmailsInputSchema = z17.object({
+  query: z17.string().min(1, "Query cannot be empty").describe('Gmail search query using Gmail search syntax (e.g., "from:user@example.com subject:test is:unread")'),
+  max_results: z17.number().int().min(1).max(100).default(10).describe("Maximum number of emails to return (default: 10, max: 100)"),
+  include_body: z17.boolean().default(false).describe("Whether to include full email body in results (default: false)"),
+  page_token: z17.string().optional().describe("Token for pagination to fetch next page of results"),
+  output_format: z17.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+async function searchEmailsTool(gmailClient, params) {
+  try {
+    const result = await gmailClient.searchEmails(params.query, params.max_results, params.include_body, params.page_token);
+    const output = {
+      total_estimate: result.total_estimate,
+      count: result.emails.length,
+      has_more: result.has_more,
+      ...result.next_page_token ? { next_page_token: result.next_page_token } : {},
+      emails: result.emails.map(formatEmailForOutput)
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : searchResultsToMarkdown(params.query, output);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("searching emails", error);
+  }
+}
+var SEARCH_EMAILS_DESCRIPTION = `Search for emails in Gmail using Gmail's search syntax.
+
+This tool allows you to search through your Gmail messages using the same query syntax available in Gmail's web interface. It supports various search operators and returns structured results with email metadata.
+
+**Gmail Search Operators**:
+- \`from:user@example.com\` - emails from specific sender
+- \`to:user@example.com\` - emails to specific recipient
+- \`subject:keyword\` - emails with keyword in subject
+- \`is:unread\` - unread emails
+- \`is:starred\` - starred emails
+- \`has:attachment\` - emails with attachments
+- \`after:2024/01/01\` - emails after date
+- \`before:2024/12/31\` - emails before date
+- \`label:labelname\` - emails with specific label
+- \`filename:pdf\` - emails with specific file type
+- \`larger:5M\` - emails larger than size
+- \`newer_than:7d\` - emails newer than duration
+
+**Combining Operators**:
+- Use \`AND\`, \`OR\`, and \`-\` (NOT) to combine operators
+- Example: \`from:boss@example.com is:unread -label:archive\`
+
+**Parameters**:
+- \`query\` (string, required): Gmail search query
+- \`max_results\` (number, optional): Max emails to return (1-100, default: 10)
+- \`include_body\` (boolean, optional): Include full email body (default: false, only snippet)
+- \`page_token\` (string, optional): Pagination token for next page
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns**:
+- \`total_estimate\`: Approximate total matching emails
+- \`count\`: Number of emails in this response
+- \`has_more\`: Whether more results are available
+- \`next_page_token\`: Token for fetching next page (if has_more is true)
+- \`emails\`: Array of email objects with id, thread_id, subject, from, to, date, snippet, and optionally body
+
+**Examples**:
+- Search unread emails: \`{ "query": "is:unread" }\`
+- Search by sender: \`{ "query": "from:alerts@service.com" }\`
+- Recent attachments: \`{ "query": "has:attachment newer_than:7d" }\`
+- With body: \`{ "query": "subject:invoice", "include_body": true }\`
+- JSON output: \`{ "query": "is:unread", "output_format": "json" }\`
+
+**Error Handling**:
+- Returns error message if authentication fails
+- Returns error if Gmail API request fails
+- Empty results if no emails match the query`;
+
+// src/tools/send-email.ts
+import json2md13 from "json2md";
+import { z as z18 } from "zod";
+var SendEmailInputSchema = z18.object({
+  to: z18.email("Must be a valid email address").describe("Recipient email address"),
+  subject: z18.string().min(1, "Subject cannot be empty").describe("Email subject"),
+  body: z18.string().min(1, "Body cannot be empty").describe("Email body content"),
+  content_type: z18.enum(["text/plain", "text/html"]).default("text/plain").describe("Content type: text/plain (default) or text/html for HTML emails"),
+  cc: z18.email("CC must be a valid email address").optional().describe("CC (carbon copy) email address"),
+  bcc: z18.email("BCC must be a valid email address").optional().describe("BCC (blind carbon copy) email address"),
+  confirm: z18.boolean().default(false).describe("Set to true to confirm and send the email. If false, returns preview only."),
+  output_format: z18.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function emailPreviewToMarkdown(params) {
+  const sections = [
+    { h1: "Email Preview - NOT SENT" },
+    {
+      p: "⚠️ **This email has not been sent yet.** Set `confirm: true` to send."
+    },
+    { h2: "Email Details" },
+    {
+      ul: [
+        `**To:** ${params.to}`,
+        ...params.cc ? [`**CC:** ${params.cc}`] : [],
+        ...params.bcc ? [`**BCC:** ${params.bcc}`] : [],
+        `**Subject:** ${params.subject}`,
+        `**Content Type:** ${params.content_type}`
+      ]
+    },
+    { h2: "Body" },
+    { p: params.body }
+  ];
+  return json2md13(sections);
+}
+function emailSentToMarkdown(params, result) {
+  const sections = [
+    { h1: "✅ Email Sent Successfully" },
+    { h2: "Message Details" },
+    {
+      ul: [
+        `**To:** ${params.to}`,
+        ...params.cc ? [`**CC:** ${params.cc}`] : [],
+        ...params.bcc ? [`**BCC:** ${params.bcc}`] : [],
+        `**Subject:** ${params.subject}`,
+        `**Message ID:** ${result.id}`,
+        `**Thread ID:** ${result.threadId}`
+      ]
+    },
+    {
+      p: "The email has been sent and will appear in your Sent folder."
+    }
+  ];
+  return json2md13(sections);
+}
+async function sendEmailTool(gmailClient, params) {
+  try {
+    if (!params.confirm) {
+      const output2 = {
+        status: "preview",
+        sent: false,
+        to: params.to,
+        cc: params.cc,
+        bcc: params.bcc,
+        subject: params.subject,
+        body: params.body,
+        content_type: params.content_type,
+        warning: "Email NOT sent. Set confirm:true to actually send this email."
+      };
+      const textContent2 = params.output_format === "json" ? JSON.stringify(output2, null, 2) : emailPreviewToMarkdown(params);
+      return {
+        content: [{ type: "text", text: textContent2 }],
+        structuredContent: output2
+      };
+    }
+    const result = await gmailClient.sendEmail(params.to, params.subject, params.body, params.content_type, params.cc, params.bcc);
+    const output = {
+      status: "sent",
+      sent: true,
+      message_id: result.id,
+      thread_id: result.threadId,
+      to: params.to,
+      cc: params.cc,
+      bcc: params.bcc,
+      subject: params.subject,
+      label_ids: result.labelIds
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : emailSentToMarkdown(params, result);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("sending email", error);
+  }
+}
+var SEND_EMAIL_DESCRIPTION = `Send a new Gmail email with optional CC/BCC and HTML support.
+
+This tool sends email through your Gmail account. It includes a safety feature: by default it shows a preview without sending. You must explicitly set \`confirm: true\` to actually send the email.
+
+**Safety Feature**:
+- Default behavior: Shows preview only, does NOT send
+- To actually send: Set \`confirm: true\`
+- This prevents accidental sends
+
+**Parameters**:
+- \`to\` (string, required): Recipient email address
+- \`subject\` (string, required): Email subject line
+- \`body\` (string, required): Email body content
+- \`content_type\` (string, optional): "text/plain" (default) or "text/html" for HTML emails
+- \`cc\` (string, optional): CC email address
+- \`bcc\` (string, optional): BCC email address
+- \`confirm\` (boolean, required): Must be true to actually send (default: false)
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**Returns** (preview mode):
+- \`status\`: "preview"
+- \`sent\`: false
+- Email details for review
+- Warning message
+
+**Returns** (sent mode):
+- \`status\`: "sent"
+- \`sent\`: true
+- \`message_id\`: Sent message ID
+- \`thread_id\`: Thread ID
+- \`label_ids\`: Applied labels
+
+**Examples**:
+- Preview: \`{ "to": "user@example.com", "subject": "Hello", "body": "Hi there!" }\`
+- Send plain text: \`{ "to": "user@example.com", "subject": "Hello", "body": "Hi!", "confirm": true }\`
+- Send HTML: \`{ "to": "user@example.com", "subject": "Newsletter", "body": "<h1>Hello</h1>", "content_type": "text/html", "confirm": true }\`
+- With CC: \`{ "to": "user@example.com", "cc": "boss@example.com", "subject": "Report", "body": "See attached", "confirm": true }\`
+
+**HTML Emails**:
+- Set \`content_type: "text/html"\`
+- Body should contain valid HTML
+- Basic HTML tags supported: h1-h6, p, a, strong, em, ul, ol, li, br
+
+**Error Handling**:
+- Returns error if email addresses are invalid
+- Returns error if authentication lacks send permissions
+- Returns error if Gmail API fails
+
+**Permissions**:
+- Requires \`gmail.send\` or \`gmail.compose\` scope
+
+**Use Cases**:
+- Send automated email notifications
+- Reply to inquiries
+- Send reports or summaries
+- Compose and send HTML newsletters
+
+**Workflow**:
+1. First call without \`confirm\` to preview
+2. Review the preview output
+3. Call again with \`confirm: true\` to send`;
+
+// src/tools/update-label.ts
+import json2md14 from "json2md";
+import { z as z19 } from "zod";
+var SYSTEM_LABELS2 = [
+  "INBOX",
+  "SENT",
+  "DRAFT",
+  "TRASH",
+  "SPAM",
+  "STARRED",
+  "IMPORTANT",
+  "UNREAD"
+];
+var UpdateLabelInputSchema = z19.object({
+  label_id: z19.string().min(1, "Label ID cannot be empty").describe("The label ID to update (e.g., 'Label_123' or 'INBOX')"),
+  name: z19.string().optional().describe("New label name. Cannot rename system labels. Use '/' for nested labels."),
+  message_list_visibility: z19.enum(["show", "hide"]).optional().describe("How label appears in message list"),
+  label_list_visibility: z19.enum(["labelShow", "labelShowIfUnread", "labelHide"]).optional().describe("How label appears in label list (sidebar)"),
+  background_color: z19.string().optional().describe("Background color in hex format (e.g., '#ff0000'). Must provide both background and text color together."),
+  text_color: z19.string().optional().describe("Text color in hex format (e.g., '#ffffff'). Must provide both background and text color together."),
+  output_format: z19.enum(["markdown", "json"]).default("markdown").describe("Output format: markdown (default) or json")
+});
+function updatedLabelToMarkdown(label, updates) {
+  const sections = [
+    { h1: "Label Updated Successfully" },
+    { h2: "Details" },
+    {
+      ul: [
+        `**Name:** ${label.name}`,
+        `**ID:** ${label.id}`,
+        `**Type:** ${label.type === "system" ? "System Label" : "Custom Label"}`
+      ]
+    }
+  ];
+  const changedItems = [];
+  if (updates.name) {
+    changedItems.push("Name");
+  }
+  if (updates.visibility) {
+    changedItems.push("Visibility settings");
+  }
+  if (updates.color) {
+    changedItems.push("Color");
+  }
+  if (changedItems.length > 0) {
+    sections.push({ h2: "Changes Applied" });
+    sections.push({ ul: changedItems });
+  }
+  if (label.messageListVisibility || label.labelListVisibility) {
+    sections.push({ h2: "Current Visibility Settings" });
+    const visibilityItems = [];
+    if (label.messageListVisibility) {
+      visibilityItems.push(`**Message List:** ${label.messageListVisibility}`);
+    }
+    if (label.labelListVisibility) {
+      visibilityItems.push(`**Label List:** ${label.labelListVisibility}`);
+    }
+    sections.push({ ul: visibilityItems });
+  }
+  if (label.color) {
+    sections.push({ h2: "Current Color" });
+    sections.push({
+      ul: [
+        `**Text Color:** ${label.color.textColor}`,
+        `**Background Color:** ${label.color.backgroundColor}`
+      ]
+    });
+  }
+  return json2md14(sections);
+}
+async function updateLabelTool(gmailClient, params) {
+  try {
+    if (params.name && SYSTEM_LABELS2.includes(params.label_id)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Cannot rename system label ${params.label_id}. System labels can only have visibility settings updated, not renamed.`
+          }
+        ],
+        isError: true
+      };
+    }
+    if (params.background_color && !params.text_color || !params.background_color && params.text_color) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Error: Both background_color and text_color must be provided together"
+          }
+        ],
+        isError: true
+      };
+    }
+    if (!(params.name || params.message_list_visibility || params.label_list_visibility || params.background_color || params.text_color)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Error: At least one field to update must be provided (name, visibility, or color)"
+          }
+        ],
+        isError: true
+      };
+    }
+    const label = await gmailClient.updateLabel(params.label_id, params.name, params.message_list_visibility, params.label_list_visibility, params.background_color, params.text_color);
+    const updates = {
+      name: !!params.name,
+      visibility: !!(params.message_list_visibility || params.label_list_visibility),
+      color: !!(params.background_color && params.text_color)
+    };
+    const output = {
+      id: label.id,
+      name: label.name,
+      type: label.type,
+      message_list_visibility: label.messageListVisibility || null,
+      label_list_visibility: label.labelListVisibility || null,
+      color: label.color || null,
+      updated: true,
+      changes: updates
+    };
+    const textContent = params.output_format === "json" ? JSON.stringify(output, null, 2) : updatedLabelToMarkdown(label, updates);
+    return {
+      content: [{ type: "text", text: textContent }],
+      structuredContent: output
+    };
+  } catch (error) {
+    return createErrorResponse("updating label", error);
+  }
+}
+var UPDATE_LABEL_DESCRIPTION = `Update an existing Gmail label's name, visibility, or color settings.
+
+This tool modifies label properties. System labels (INBOX, SENT, etc.) can only have visibility updated, not renamed. Custom labels can have all properties updated.
+
+**Parameters**:
+- \`label_id\` (string, required): The label ID to update (e.g., "Label_123" or "INBOX")
+- \`name\` (string, optional): New label name. Use "/" for nested labels. Cannot rename system labels.
+- \`message_list_visibility\` (string, optional): How label appears in message list
+  - "show": Messages with this label appear in message list
+  - "hide": Messages with this label are hidden from message list
+- \`label_list_visibility\` (string, optional): How label appears in label list (sidebar)
+  - "labelShow": Always visible in label list
+  - "labelShowIfUnread": Only visible when there are unread messages
+  - "labelHide": Hidden from label list
+- \`background_color\` (string, optional): Background color in hex format (e.g., "#ff0000")
+- \`text_color\` (string, optional): Text color in hex format (e.g., "#ffffff")
+- \`output_format\` (string, optional): Output format: "markdown" (default) or "json"
+
+**System Label Restrictions**:
+- System labels (INBOX, SENT, DRAFT, TRASH, SPAM, STARRED, IMPORTANT, UNREAD) cannot be renamed
+- System labels can have visibility settings updated
+- Some system labels may reject certain visibility changes based on Gmail's rules
+- Attempting to rename a system label returns an error
+
+**Custom Label Updates**:
+- Custom labels can be renamed, including changing nested structure
+- All visibility and color properties can be updated
+- Renaming to include "/" creates nested label hierarchy
+
+**Color Settings**:
+- Both \`background_color\` and \`text_color\` must be provided together
+- Colors should be in hex format (e.g., "#ff0000" for red)
+- To remove colors, omit both color parameters (not currently supported by Gmail API)
+
+**Returns**:
+- \`id\`: The label ID
+- \`name\`: Updated label name
+- \`type\`: "system" or "user"
+- \`message_list_visibility\`: Current message list visibility
+- \`label_list_visibility\`: Current label list visibility
+- \`color\`: Current color settings
+- \`updated\`: Always true on success
+- \`changes\`: Object indicating which properties were updated
+
+**Use Cases**:
+- Rename custom labels for better organization
+- Change label colors for visual distinction
+- Update visibility settings to hide/show labels
+- Restructure labels by changing nested hierarchy
+
+**Examples**:
+- Rename label: \`{ "label_id": "Label_123", "name": "Work/Important" }\`
+- Change color: \`{ "label_id": "Label_123", "background_color": "#ff0000", "text_color": "#ffffff" }\`
+- Hide from sidebar: \`{ "label_id": "Label_123", "label_list_visibility": "labelHide" }\`
+- Update system label visibility: \`{ "label_id": "INBOX", "label_list_visibility": "labelShowIfUnread" }\`
+
+**Error Handling**:
+- Returns error if trying to rename system labels
+- Returns error if label ID doesn't exist
+- Returns error if colors are invalid or only one color is provided
+- Returns error if no update parameters are provided
+- Returns error if authentication lacks gmail.labels scope
+- Requires at least one field to update
+
+**Scope Requirements**:
+- Requires \`gmail.labels\` or \`gmail.modify\` scope`;
+
+// src/index.ts
+async function main() {
+  const logger = createLogger();
+  logger.info({ version: "1.0.0" }, "GMCP Server starting");
+  const { credentialsPath, tokenPath, scopes } = getEnvConfig();
+  logger.info({
+    credentialsPath,
+    tokenPath,
+    scopeCount: scopes.length,
+    scopes
+  }, "Environment configuration loaded");
+  logger.info("Authenticating with Google APIs");
+  const oauth2Client = await createAuthenticatedClient(credentialsPath, tokenPath, logger);
+  const gmailClient = createGmailClient(oauth2Client, logger);
+  const calendarClient = createCalendarClient(oauth2Client, logger);
+  logger.info("Gmail and Calendar clients initialized");
+  const server = new McpServer({
+    name: "gmcp-server",
+    version: "1.0.0"
+  });
+  const tools = [
+    {
+      name: "gmcp_gmail_search_emails",
+      title: "Search Gmail Emails",
+      description: SEARCH_EMAILS_DESCRIPTION,
+      inputSchema: SearchEmailsInputSchema,
+      annotations: READ_ONLY_ANNOTATIONS,
+      handler: searchEmailsTool
+    },
+    {
+      name: "gmcp_gmail_get_email",
+      title: "Get Gmail Email",
+      description: GET_EMAIL_DESCRIPTION,
+      inputSchema: GetEmailInputSchema,
+      annotations: READ_ONLY_ANNOTATIONS,
+      handler: getEmailTool
+    },
+    {
+      name: "gmcp_gmail_get_thread",
+      title: "Get Gmail Thread",
+      description: GET_THREAD_DESCRIPTION,
+      inputSchema: GetThreadInputSchema,
+      annotations: READ_ONLY_ANNOTATIONS,
+      handler: getThreadTool
+    },
+    {
+      name: "gmcp_gmail_list_attachments",
+      title: "List Gmail Attachments",
+      description: LIST_ATTACHMENTS_DESCRIPTION,
+      inputSchema: ListAttachmentsInputSchema,
+      annotations: READ_ONLY_ANNOTATIONS,
+      handler: listAttachmentsTool
+    },
+    {
+      name: "gmcp_gmail_get_attachment",
+      title: "Get Gmail Attachment",
+      description: GET_ATTACHMENT_DESCRIPTION,
+      inputSchema: GetAttachmentInputSchema,
+      annotations: READ_ONLY_ANNOTATIONS,
+      handler: getAttachmentTool
+    },
+    {
+      name: "gmcp_gmail_modify_labels",
+      title: "Modify Gmail Labels",
+      description: MODIFY_LABELS_DESCRIPTION,
+      inputSchema: ModifyLabelsInputSchema,
+      annotations: MODIFY_ANNOTATIONS,
+      handler: modifyLabelsTool
+    },
+    {
+      name: "gmcp_gmail_batch_modify",
+      title: "Batch Modify Gmail Labels",
+      description: BATCH_MODIFY_DESCRIPTION,
+      inputSchema: BatchModifyInputSchema,
+      annotations: MODIFY_ANNOTATIONS,
+      handler: batchModifyTool
+    },
+    {
+      name: "gmcp_gmail_send_email",
+      title: "Send Gmail Email",
+      description: SEND_EMAIL_DESCRIPTION,
+      inputSchema: SendEmailInputSchema,
+      annotations: SEND_ANNOTATIONS,
+      handler: sendEmailTool
+    },
+    {
+      name: "gmcp_gmail_reply",
+      title: "Reply to Gmail Email",
+      description: REPLY_DESCRIPTION,
+      inputSchema: ReplyInputSchema,
+      annotations: SEND_ANNOTATIONS,
+      handler: replyTool
+    },
+    {
+      name: "gmcp_gmail_create_draft",
+      title: "Create Gmail Draft",
+      description: CREATE_DRAFT_DESCRIPTION,
+      inputSchema: CreateDraftInputSchema,
+      annotations: SEND_ANNOTATIONS,
+      handler: createDraftTool
+    },
+    {
+      name: "gmcp_gmail_list_labels",
+      title: "List Gmail Labels",
+      description: LIST_LABELS_DESCRIPTION,
+      inputSchema: ListLabelsInputSchema,
+      annotations: READ_ONLY_ANNOTATIONS,
+      handler: listLabelsTool
+    },
+    {
+      name: "gmcp_gmail_get_label",
+      title: "Get Gmail Label",
+      description: GET_LABEL_DESCRIPTION,
+      inputSchema: GetLabelInputSchema,
+      annotations: READ_ONLY_ANNOTATIONS,
+      handler: getLabelTool
+    },
+    {
+      name: "gmcp_gmail_create_label",
+      title: "Create Gmail Label",
+      description: CREATE_LABEL_DESCRIPTION,
+      inputSchema: CreateLabelInputSchema,
+      annotations: MODIFY_ANNOTATIONS,
+      handler: createLabelTool
+    },
+    {
+      name: "gmcp_gmail_update_label",
+      title: "Update Gmail Label",
+      description: UPDATE_LABEL_DESCRIPTION,
+      inputSchema: UpdateLabelInputSchema,
+      annotations: MODIFY_ANNOTATIONS,
+      handler: updateLabelTool
+    },
+    {
+      name: "gmcp_gmail_delete_label",
+      title: "Delete Gmail Label",
+      description: DELETE_LABEL_DESCRIPTION,
+      inputSchema: DeleteLabelInputSchema,
+      annotations: DESTRUCTIVE_ANNOTATIONS,
+      handler: deleteLabelTool
+    }
+  ];
+  const calendarTools = [
+    {
+      name: "gmcp_calendar_list_calendars",
+      title: "List Google Calendars",
+      description: CALENDAR_LIST_DESCRIPTION,
+      inputSchema: CalendarListInputSchema,
+      annotations: READ_ONLY_ANNOTATIONS,
+      handler: calendarListTool
+    },
+    {
+      name: "gmcp_calendar_list_events",
+      title: "List Calendar Events",
+      description: CALENDAR_EVENTS_DESCRIPTION,
+      inputSchema: CalendarEventsInputSchema,
+      annotations: READ_ONLY_ANNOTATIONS,
+      handler: calendarEventsTool
+    },
+    {
+      name: "gmcp_calendar_get_event",
+      title: "Get Calendar Event",
+      description: CALENDAR_GET_EVENT_DESCRIPTION,
+      inputSchema: CalendarGetEventInputSchema,
+      annotations: READ_ONLY_ANNOTATIONS,
+      handler: calendarGetEventTool
+    },
+    {
+      name: "gmcp_calendar_create_event",
+      title: "Create Calendar Event",
+      description: CALENDAR_CREATE_EVENT_DESCRIPTION,
+      inputSchema: CalendarCreateEventInputSchema,
+      annotations: SEND_ANNOTATIONS,
+      handler: calendarCreateEventTool
+    }
+  ];
+  registerTools(server, gmailClient, tools, logger);
+  registerTools(server, calendarClient, calendarTools, logger);
+  const totalTools = tools.length + calendarTools.length;
+  logger.info({
+    gmailTools: tools.length,
+    calendarTools: calendarTools.length,
+    totalTools
+  }, "Tools registered");
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+  logger.info("MCP server connected via stdio");
+  logger.info("Ready to accept requests");
+}
+main().catch((error) => {
+  const logger = createLogger();
+  logger.error({
+    error: error instanceof Error ? error.message : String(error),
+    stack: error instanceof Error ? error.stack : undefined
+  }, "Fatal error");
+  process.exit(1);
+});