@dguido/google-workspace-mcp 1.0.0 → 1.2.0

package/dist/index.js

@@ -21,6 +21,56 @@ var init_logging = __esm({
   }
 });
 
+// src/config/services.ts
+function getEnabledServices() {
+  if (enabledServices !== null) return enabledServices;
+  const envValue = process.env.GOOGLE_WORKSPACE_SERVICES;
+  if (envValue === void 0) {
+    enabledServices = new Set(SERVICE_NAMES);
+    return enabledServices;
+  }
+  if (envValue.trim() === "") {
+    enabledServices = /* @__PURE__ */ new Set();
+    return enabledServices;
+  }
+  const requested = envValue.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  const valid = /* @__PURE__ */ new Set();
+  const unknown = [];
+  for (const service of requested) {
+    if (SERVICE_NAMES.includes(service)) {
+      valid.add(service);
+    } else {
+      unknown.push(service);
+    }
+  }
+  if (unknown.length > 0) {
+    console.warn(
+      `[google-workspace-mcp] Unknown services: ${unknown.join(", ")}. Valid: ${SERVICE_NAMES.join(", ")}`
+    );
+  }
+  enabledServices = valid;
+  return enabledServices;
+}
+function isServiceEnabled(service) {
+  return getEnabledServices().has(service);
+}
+function areUnifiedToolsEnabled() {
+  const enabled = getEnabledServices();
+  return UNIFIED_REQUIRED_SERVICES.every((s) => enabled.has(s));
+}
+function isToonEnabled() {
+  return process.env.GOOGLE_WORKSPACE_TOON_FORMAT === "true";
+}
+var SERVICE_NAMES, UNIFIED_REQUIRED_SERVICES, enabledServices;
+var init_services = __esm({
+  "src/config/services.ts"() {
+    "use strict";
+    SERVICE_NAMES = ["drive", "docs", "sheets", "slides", "calendar", "gmail"];
+    UNIFIED_REQUIRED_SERVICES = ["drive", "docs", "sheets", "slides"];
+    enabledServices = null;
+  }
+});
+
 // src/utils/responses.ts
 function truncateResponse(content) {
   if (content.length <= CHARACTER_LIMIT) {
@@ -38,11 +88,14 @@ function successResponse(text) {
   return { content: [{ type: "text", text }], isError: false };
 }
 function structuredResponse(text, data) {
-  return {
+  const response = {
     content: [{ type: "text", text }],
-    structuredContent: data,
     isError: false
   };
+  if (!isToonEnabled()) {
+    response.structuredContent = data;
+  }
+  return response;
 }
 function errorResponse(message, options) {
   log("Error", { message, ...options });
@@ -62,6 +115,7 @@ var CHARACTER_LIMIT;
 var init_responses = __esm({
   "src/utils/responses.ts"() {
     "use strict";
+    init_services();
     init_logging();
     CHARACTER_LIMIT = 25e3;
   }
@@ -137,7 +191,7 @@ function getGmailService(authClient2) {
   return gmailService;
 }
 var docsService, sheetsService, slidesService, calendarService, gmailService, lastAuthClient;
-var init_services = __esm({
+var init_services2 = __esm({
   "src/utils/services.ts"() {
     "use strict";
     docsService = null;
@@ -776,6 +830,25 @@ var init_mime = __esm({
   }
 });
 
+// src/utils/toon.ts
+import { encode } from "@toon-format/toon";
+function toToon(data) {
+  if (!isToonEnabled()) {
+    return JSON.stringify(data, null, 2);
+  }
+  try {
+    return encode(data);
+  } catch {
+    return JSON.stringify(data, null, 2);
+  }
+}
+var init_toon = __esm({
+  "src/utils/toon.ts"() {
+    "use strict";
+    init_services();
+  }
+});
+
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
@@ -807,6 +880,7 @@ __export(utils_exports, {
   structuredResponse: () => structuredResponse,
   successResponse: () => successResponse,
   supportsFormElicitation: () => supportsFormElicitation,
+  toToon: () => toToon,
   truncateResponse: () => truncateResponse,
   validateArgs: () => validateArgs,
   withProgressReporting: () => withProgressReporting,
@@ -820,13 +894,14 @@ var init_utils = __esm({
     init_logging();
     init_responses();
     init_validation();
-    init_services();
+    init_services2();
     init_timeout();
     init_retry();
     init_elicitation();
     init_progress();
     init_pathCache();
     init_mime();
+    init_toon();
   }
 });
 
@@ -850,12 +925,6 @@ import * as fs from "fs/promises";
 // src/auth/utils.ts
 import * as path from "path";
 import * as os from "os";
-import { fileURLToPath } from "url";
-function getProjectRoot() {
-  const __dirname2 = path.dirname(fileURLToPath(import.meta.url));
-  const projectRoot = path.join(__dirname2, "..", "..");
-  return path.resolve(projectRoot);
-}
 function getSecureTokenPath() {
   const customTokenPath = process.env.GOOGLE_WORKSPACE_MCP_TOKEN_PATH;
   if (customTokenPath) {
@@ -869,25 +938,12 @@ function getSecureTokenPath() {
   const tokenDir = path.join(configHome, "google-workspace-mcp");
   return path.join(tokenDir, "tokens.json");
 }
-function getLegacyTokenPath() {
-  const projectRoot = getProjectRoot();
-  return path.join(projectRoot, ".gcp-saved-tokens.json");
-}
-function getAdditionalLegacyPaths() {
-  return [
-    process.env.GOOGLE_TOKEN_PATH,
-    path.join(process.cwd(), "google-tokens.json"),
-    path.join(process.cwd(), ".gcp-saved-tokens.json")
-  ].filter(Boolean);
-}
 function getKeysFilePath() {
   const envCredentialsPath = process.env.GOOGLE_DRIVE_OAUTH_CREDENTIALS;
   if (envCredentialsPath) {
     return path.resolve(envCredentialsPath);
   }
-  const projectRoot = getProjectRoot();
-  const keysPath = path.join(projectRoot, "gcp-oauth.keys.json");
-  return keysPath;
+  return path.join(process.cwd(), "gcp-oauth.keys.json");
 }
 function generateCredentialsErrorMessage() {
   return `
@@ -1052,46 +1108,13 @@ var TokenManager = class {
       }
     });
   }
-  async migrateLegacyTokens() {
-    const legacyPaths = [getLegacyTokenPath(), ...getAdditionalLegacyPaths()];
-    for (const legacyPath of legacyPaths) {
-      try {
-        if (!await fs2.access(legacyPath).then(() => true).catch(() => false)) {
-          continue;
-        }
-        const legacyTokens = JSON.parse(await fs2.readFile(legacyPath, "utf-8"));
-        if (!legacyTokens || typeof legacyTokens !== "object") {
-          log(`Invalid legacy token format at ${legacyPath}, skipping`);
-          continue;
-        }
-        await this.ensureTokenDirectoryExists();
-        await fs2.writeFile(this.tokenPath, JSON.stringify(legacyTokens, null, 2), {
-          mode: 384
-        });
-        log(`Migrated tokens from legacy location: ${legacyPath} to: ${this.tokenPath}`);
-        try {
-          await fs2.unlink(legacyPath);
-          log("Removed legacy token file");
-        } catch (unlinkErr) {
-          log("Warning: Could not remove legacy token file:", unlinkErr);
-        }
-        return true;
-      } catch (error) {
-        log(`Error migrating legacy tokens from ${legacyPath}`, error);
-      }
-    }
-    return false;
-  }
   async loadSavedTokens() {
     try {
       await this.ensureTokenDirectoryExists();
       const tokenExists = await fs2.access(this.tokenPath).then(() => true).catch(() => false);
       if (!tokenExists) {
-        const migrated = await this.migrateLegacyTokens();
-        if (!migrated) {
-          log("No token file found at:", this.tokenPath);
-          return false;
-        }
+        log("No token file found at:", this.tokenPath);
+        return false;
       }
       const tokens = JSON.parse(await fs2.readFile(this.tokenPath, "utf-8"));
       if (!tokens || typeof tokens !== "object") {
@@ -1454,50 +1477,12 @@ async function authenticate() {
 
 // src/index.ts
 init_utils();
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath } from "url";
 import { readFileSync } from "fs";
-import { join as join3, dirname as dirname3 } from "path";
+import { join as join3, dirname as dirname2 } from "path";
 
-// src/config/services.ts
-var SERVICE_NAMES = ["drive", "docs", "sheets", "slides", "calendar", "gmail"];
-var UNIFIED_REQUIRED_SERVICES = ["drive", "docs", "sheets", "slides"];
-var enabledServices = null;
-function getEnabledServices() {
-  if (enabledServices !== null) return enabledServices;
-  const envValue = process.env.GOOGLE_WORKSPACE_SERVICES;
-  if (envValue === void 0) {
-    enabledServices = new Set(SERVICE_NAMES);
-    return enabledServices;
-  }
-  if (envValue.trim() === "") {
-    enabledServices = /* @__PURE__ */ new Set();
-    return enabledServices;
-  }
-  const requested = envValue.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
-  const valid = /* @__PURE__ */ new Set();
-  const unknown = [];
-  for (const service of requested) {
-    if (SERVICE_NAMES.includes(service)) {
-      valid.add(service);
-    } else {
-      unknown.push(service);
-    }
-  }
-  if (unknown.length > 0) {
-    console.warn(
-      `[google-workspace-mcp] Unknown services: ${unknown.join(", ")}. Valid: ${SERVICE_NAMES.join(", ")}`
-    );
-  }
-  enabledServices = valid;
-  return enabledServices;
-}
-function isServiceEnabled(service) {
-  return getEnabledServices().has(service);
-}
-function areUnifiedToolsEnabled() {
-  const enabled = getEnabledServices();
-  return UNIFIED_REQUIRED_SERVICES.every((s) => enabled.has(s));
-}
+// src/config/index.ts
+init_services();
 
 // src/tools/definitions.ts
 var driveTools = [
@@ -4463,13 +4448,13 @@ var gmailTools = [
   },
   {
     name: "modify_email",
-    description: "Add/remove labels (max 1000 IDs per request)",
+    description: "Add/remove labels on threads (max 1000 IDs per request)",
     inputSchema: {
       type: "object",
       properties: {
-        messageId: {
+        threadId: {
           oneOf: [{ type: "string" }, { type: "array", items: { type: "string" }, maxItems: 1e3 }],
-          description: "Message ID or array of IDs (max 1000)"
+          description: "Thread ID or array of IDs (max 1000)"
         },
         addLabelIds: {
           type: "array",
@@ -4482,14 +4467,14 @@ var gmailTools = [
           description: "(optional) Label IDs to remove"
         }
       },
-      required: ["messageId"]
+      required: ["threadId"]
     },
     outputSchema: {
       type: "object",
       properties: {
-        modified: { type: "number", description: "Number of messages modified" },
-        addedLabels: { type: "array", items: { type: "string" }, description: "Labels added" },
-        removedLabels: { type: "array", items: { type: "string" }, description: "Labels removed" }
+        id: { type: "string", description: "Thread ID" },
+        messageCount: { type: "number", description: "Number of messages in thread" },
+        labelIds: { type: "array", items: { type: "string" }, description: "Current labels" }
       }
     }
   },
@@ -5109,9 +5094,6 @@ function formatBytes(bytes, options = {}) {
   const formatted = value.toFixed(precision);
   return `${formatted} ${BYTE_UNITS[unitIndex]}`;
 }
-function formatBytesCompact(bytes, nullValue = "N/A") {
-  return formatBytes(bytes, { precision: 1, nullValue });
-}
 
 // src/schemas/drive.ts
 import { z } from "zod";
@@ -5841,7 +5823,7 @@ var DeleteEmailSchema = z7.object({
   messageId: z7.union([z7.string().min(1), z7.array(z7.string().min(1)).min(1).max(1e3)]).describe("Message ID or array of IDs (max 1000 for batch)")
 });
 var ModifyEmailSchema = z7.object({
-  messageId: z7.union([z7.string().min(1), z7.array(z7.string().min(1)).min(1).max(1e3)]).describe("Message ID or array of IDs (max 1000 for batch)"),
+  threadId: z7.union([z7.string().min(1), z7.array(z7.string().min(1)).min(1).max(1e3)]).describe("Thread ID or array of IDs (max 1000 for batch)"),
   addLabelIds: z7.array(z7.string()).optional().describe("Label IDs to add"),
   removeLabelIds: z7.array(z7.string()).optional().describe("Label IDs to remove")
 });
@@ -6261,19 +6243,29 @@ async function handleSearch(drive2, args) {
     includeItemsFromAllDrives: true,
     supportsAllDrives: true
   });
-  const fileList = res.data.files?.map((f) => `${f.name} (${f.mimeType})`).join("\n") || "";
+  const files = res.data.files?.map((f) => ({
+    id: f.id,
+    name: f.name,
+    mimeType: f.mimeType,
+    modifiedTime: f.modifiedTime,
+    size: f.size
+  })) || [];
   log("Search results", {
     query: userQuery,
-    resultCount: res.data.files?.length
+    resultCount: files.length
   });
-  let response = `Found ${res.data.files?.length ?? 0} files:
-${fileList}`;
+  let textResponse = `Found ${files.length} files:
+
+${toToon({ files })}`;
   if (res.data.nextPageToken) {
-    response += `
+    textResponse += `
 
 More results available. Use pageToken: ${res.data.nextPageToken}`;
   }
-  return successResponse(response);
+  return structuredResponse(textResponse, {
+    files,
+    nextPageToken: res.data.nextPageToken || null
+  });
 }
 async function handleCreateTextFile(drive2, args) {
   const validation = validateArgs(CreateTextFileSchema, args);
@@ -6736,33 +6728,23 @@ async function handleGetSharing(drive2, args) {
     "List permissions"
   );
   const permissionList = permissions.data.permissions || [];
-  const formattedPermissions = permissionList.map((p) => {
-    let target = "";
-    if (p.type === "anyone") {
-      target = "Anyone with the link";
-    } else if (p.type === "domain") {
-      target = `Anyone in ${p.domain}`;
-    } else {
-      target = p.emailAddress || p.displayName || "Unknown";
-    }
-    return `\u2022 ${target}: ${p.role} (ID: ${p.id})`;
-  }).join("\n");
+  const permissionData = permissionList.map((p) => ({
+    id: p.id,
+    role: p.role,
+    type: p.type,
+    emailAddress: p.emailAddress,
+    domain: p.domain,
+    displayName: p.displayName
+  }));
   const textResponse = `Sharing settings for "${file.data.name}":
 
-${formattedPermissions}
+${toToon({ permissions: permissionData })}
 
 Link: ${file.data.webViewLink}`;
   return structuredResponse(textResponse, {
     fileName: file.data.name,
     webViewLink: file.data.webViewLink,
-    permissions: permissionList.map((p) => ({
-      id: p.id,
-      role: p.role,
-      type: p.type,
-      emailAddress: p.emailAddress,
-      domain: p.domain,
-      displayName: p.displayName
-    }))
+    permissions: permissionData
   });
 }
 async function handleListRevisions(drive2, args) {
@@ -6796,27 +6778,22 @@ async function handleListRevisions(drive2, args) {
   if (revisionList.length === 0) {
     return successResponse(`No revisions found for "${file.data.name}".`);
   }
-  const formattedRevisions = revisionList.map((r, idx) => {
-    const author = r.lastModifyingUser?.displayName || r.lastModifyingUser?.emailAddress || "Unknown";
-    const sizeStr = formatBytes(r.size);
-    const keepForever = r.keepForever ? " (pinned)" : "";
-    return `${idx + 1}. ID: ${r.id} | ${r.modifiedTime} | ${author} | ${sizeStr}${keepForever}`;
-  }).join("\n");
+  const revisionData = revisionList.map((r) => ({
+    id: r.id,
+    modifiedTime: r.modifiedTime,
+    size: r.size,
+    keepForever: r.keepForever,
+    lastModifyingUser: r.lastModifyingUser ? {
+      displayName: r.lastModifyingUser.displayName,
+      emailAddress: r.lastModifyingUser.emailAddress
+    } : void 0
+  }));
   const textResponse = `Revisions for "${file.data.name}" (${revisionList.length} found):
 
-${formattedRevisions}`;
+${toToon({ revisions: revisionData })}`;
   return structuredResponse(textResponse, {
     fileName: file.data.name,
-    revisions: revisionList.map((r) => ({
-      id: r.id,
-      modifiedTime: r.modifiedTime,
-      size: r.size,
-      keepForever: r.keepForever,
-      lastModifyingUser: r.lastModifyingUser ? {
-        displayName: r.lastModifyingUser.displayName,
-        emailAddress: r.lastModifyingUser.emailAddress
-      } : void 0
-    }))
+    revisions: revisionData
   });
 }
 async function handleRestoreRevision(drive2, args) {
@@ -7438,22 +7415,18 @@ async function handleListTrash(drive2, args) {
       nextPageToken: null
     });
   }
-  const fileList = files.map((f) => {
-    const icon = f.mimeType === FOLDER_MIME_TYPE ? "\u{1F4C1}" : "\u{1F4C4}";
-    const size = f.mimeType === FOLDER_MIME_TYPE ? "" : ` (${formatBytesCompact(f.size)})`;
-    return `${icon} ${f.name}${size} - ID: ${f.id}`;
-  }).join("\n");
+  const fileData = files.map((f) => ({
+    id: f.id,
+    name: f.name,
+    mimeType: f.mimeType,
+    size: f.size,
+    trashedTime: f.trashedTime
+  }));
   const textResponse = `Trash contents (${files.length} items):
 
-${fileList}` + (response.data.nextPageToken ? "\n\n(More items available - use nextPageToken to continue)" : "");
+${toToon({ files: fileData })}` + (response.data.nextPageToken ? "\n\n(More items available - use nextPageToken to continue)" : "");
   return structuredResponse(textResponse, {
-    files: files.map((f) => ({
-      id: f.id,
-      name: f.name,
-      mimeType: f.mimeType,
-      size: f.size,
-      trashedTime: f.trashedTime
-    })),
+    files: fileData,
     nextPageToken: response.data.nextPageToken || null
   });
 }
@@ -8538,9 +8511,9 @@ async function listSheetTabs(sheets, spreadsheetId) {
     rowCount: sheet.properties?.gridProperties?.rowCount,
     columnCount: sheet.properties?.gridProperties?.columnCount
   })) || [];
-  const tabList = tabs.map((t) => `${t.index}: ${t.title} (${t.rowCount}x${t.columnCount})`).join("\n");
   return structuredResponse(`Spreadsheet has ${tabs.length} tab(s):
-${tabList}`, {
+
+${toToon({ tabs })}`, {
     spreadsheetId,
     tabs
   });
@@ -9749,13 +9722,6 @@ function formatEventTime(eventTime) {
   }
   return "Unknown";
 }
-function formatEventSummary(event) {
-  const start = formatEventTime(event.start);
-  const end = formatEventTime(event.end);
-  const isAllDay = !!event.start?.date;
-  const timeStr = isAllDay ? start : `${start} - ${end}`;
-  return `${event.summary || "(No title)"} | ${timeStr}`;
-}
 async function handleListCalendars(calendar, args) {
   const validation = validateArgs(ListCalendarsSchema, args);
   if (!validation.success) return validation.response;
@@ -9768,26 +9734,23 @@ async function handleListCalendars(calendar, args) {
   if (calendars.length === 0) {
     return structuredResponse("No calendars found.", { calendars: [] });
   }
-  const formattedCalendars = calendars.map((cal) => {
-    const primary = cal.primary ? " (Primary)" : "";
-    const access2 = cal.accessRole ? ` [${cal.accessRole}]` : "";
-    return `${cal.summary || cal.id}${primary}${access2} - ID: ${cal.id}`;
-  }).join("\n");
+  const calendarData = calendars.map((cal) => ({
+    id: cal.id,
+    summary: cal.summary,
+    description: cal.description,
+    primary: cal.primary,
+    accessRole: cal.accessRole,
+    backgroundColor: cal.backgroundColor,
+    foregroundColor: cal.foregroundColor,
+    timeZone: cal.timeZone
+  }));
   log("Listed calendars", { count: calendars.length });
-  return structuredResponse(`Found ${calendars.length} calendar(s):
+  return structuredResponse(
+    `Found ${calendars.length} calendar(s):
 
-${formattedCalendars}`, {
-    calendars: calendars.map((cal) => ({
-      id: cal.id,
-      summary: cal.summary,
-      description: cal.description,
-      primary: cal.primary,
-      accessRole: cal.accessRole,
-      backgroundColor: cal.backgroundColor,
-      foregroundColor: cal.foregroundColor,
-      timeZone: cal.timeZone
-    }))
-  });
+${toToon({ calendars: calendarData })}`,
+    { calendars: calendarData }
+  );
 }
 async function handleListEvents(calendar, args) {
   const validation = validateArgs(ListEventsSchema, args);
@@ -9810,10 +9773,29 @@ async function handleListEvents(calendar, args) {
       nextPageToken: null
     });
   }
-  const formattedEvents = events.map((event) => `- ${formatEventSummary(event)}`).join("\n");
+  const eventData = events.map((event) => ({
+    id: event.id,
+    summary: event.summary,
+    description: event.description,
+    location: event.location,
+    start: event.start,
+    end: event.end,
+    status: event.status,
+    htmlLink: event.htmlLink,
+    hangoutLink: event.hangoutLink,
+    attendees: event.attendees?.map((a) => ({
+      email: a.email,
+      displayName: a.displayName,
+      responseStatus: a.responseStatus,
+      optional: a.optional
+    })),
+    organizer: event.organizer,
+    creator: event.creator,
+    recurringEventId: event.recurringEventId
+  }));
   let textResponse = `Found ${events.length} event(s):
 
-${formattedEvents}`;
+${toToon({ events: eventData })}`;
   if (response.data.nextPageToken) {
     textResponse += `
 
@@ -9821,26 +9803,7 @@ More events available. Use pageToken: ${response.data.nextPageToken}`;
   }
   log("Listed events", { calendarId, count: events.length });
   return structuredResponse(textResponse, {
-    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,
-      htmlLink: event.htmlLink,
-      hangoutLink: event.hangoutLink,
-      attendees: event.attendees?.map((a) => ({
-        email: a.email,
-        displayName: a.displayName,
-        responseStatus: a.responseStatus,
-        optional: a.optional
-      })),
-      organizer: event.organizer,
-      creator: event.creator,
-      recurringEventId: event.recurringEventId
-    })),
+    events: eventData,
     nextPageToken: response.data.nextPageToken || null
   });
 }
@@ -10215,6 +10178,25 @@ var SYSTEM_LABELS = /* @__PURE__ */ new Set([
   "CATEGORY_UPDATES",
   "CATEGORY_FORUMS"
 ]);
+var THREAD_ID_PATTERN = /^[0-9a-f]{16}$/i;
+var CATEGORY_SUGGESTIONS = {
+  INVALID_FORMAT: "Use search_emails to get valid thread IDs",
+  NOT_FOUND: "Thread may have been deleted. Use search_emails to refresh",
+  PERMISSION_DENIED: "You don't have access to this thread",
+  RATE_LIMITED: "Too many requests. Wait and retry with smaller batches",
+  UNKNOWN: "Check the thread ID and try again"
+};
+function isValidThreadIdFormat(id) {
+  return THREAD_ID_PATTERN.test(id);
+}
+function categorizeError(errorMessage) {
+  const msg = errorMessage.toLowerCase();
+  if (msg.includes("invalid id") || msg.includes("invalid value")) return "INVALID_FORMAT";
+  if (msg.includes("not found")) return "NOT_FOUND";
+  if (msg.includes("permission") || msg.includes("forbidden")) return "PERMISSION_DENIED";
+  if (msg.includes("rate") || msg.includes("quota")) return "RATE_LIMITED";
+  return "UNKNOWN";
+}
 function extractEmailBody(payload) {
   if (!payload) return { text: "", html: "" };
   const result = { text: "", html: "" };
@@ -10425,10 +10407,9 @@ async function handleSearchEmails(gmail, args) {
       };
     })
   );
-  const formattedList = messageDetails.map((m) => `- [${m.id}] ${m.subject || "(No subject)"} from ${m.from || "Unknown"}`).join("\n");
   let textResponse = `Found ${response.data.resultSizeEstimate} email(s):
 
-${formattedList}`;
+${toToon({ messages: messageDetails })}`;
   if (response.data.nextPageToken) {
     textResponse += `
 
@@ -10484,36 +10465,92 @@ async function handleDeleteEmail(gmail, args) {
 async function handleModifyEmail(gmail, args) {
   const validation = validateArgs(ModifyEmailSchema, args);
   if (!validation.success) return validation.response;
-  const { messageId, addLabelIds, removeLabelIds } = validation.data;
-  const messageIds = Array.isArray(messageId) ? messageId : [messageId];
-  if (messageIds.length === 1) {
-    const response = await gmail.users.messages.modify({
+  const { threadId, addLabelIds, removeLabelIds } = validation.data;
+  const ids = Array.isArray(threadId) ? threadId : [threadId];
+  if (ids.length === 1) {
+    const response = await gmail.users.threads.modify({
       userId: "me",
-      id: messageIds[0],
+      id: ids[0],
       requestBody: { addLabelIds, removeLabelIds }
     });
-    log("Modified email labels", { messageId: messageIds[0], addLabelIds, removeLabelIds });
+    log("Modified thread labels", { threadId: ids[0], addLabelIds, removeLabelIds });
+    const messageCount = response.data.messages?.length || 0;
     return structuredResponse(
-      `Email ${messageIds[0]} labels updated.
-Current labels: ${response.data.labelIds?.join(", ") || "None"}`,
+      `Thread ${ids[0]} labels updated (${messageCount} message(s) affected).
+Current labels: ${response.data.messages?.[0]?.labelIds?.join(", ") || "None"}`,
       {
         id: response.data.id,
-        threadId: response.data.threadId,
-        labelIds: response.data.labelIds
+        historyId: response.data.historyId,
+        messageCount,
+        labelIds: response.data.messages?.[0]?.labelIds
       }
     );
   }
-  await gmail.users.messages.batchModify({
-    userId: "me",
-    requestBody: {
-      ids: messageIds,
-      addLabelIds,
-      removeLabelIds
-    }
+  const validIds = ids.filter(isValidThreadIdFormat);
+  const invalidIds = ids.filter((id) => !isValidThreadIdFormat(id));
+  const formatFailures = invalidIds.map((id) => ({
+    threadId: id,
+    category: "INVALID_FORMAT",
+    error: "Invalid thread ID format"
+  }));
+  const results = await Promise.allSettled(
+    validIds.map(
+      (id) => gmail.users.threads.modify({
+        userId: "me",
+        id,
+        requestBody: { addLabelIds, removeLabelIds }
+      })
+    )
+  );
+  const apiSucceeded = results.filter((r) => r.status === "fulfilled").length;
+  const apiFailures = results.map((r, i) => ({ id: validIds[i], result: r })).filter(
+    (item) => item.result.status === "rejected"
+  ).map((item) => {
+    const errorMsg = item.result.reason?.message || String(item.result.reason) || "Unknown error";
+    return {
+      threadId: item.id,
+      category: categorizeError(errorMsg),
+      error: errorMsg
+    };
   });
-  log("Batch modified emails", { count: messageIds.length, addLabelIds, removeLabelIds });
+  const allFailures = [...formatFailures, ...apiFailures];
+  const succeeded = apiSucceeded;
+  log("Batch modified threads", {
+    count: ids.length,
+    succeeded,
+    failed: allFailures.length,
+    preFiltered: invalidIds.length,
+    addLabelIds,
+    removeLabelIds
+  });
+  if (allFailures.length > 0) {
+    const failuresByCategory = allFailures.reduce(
+      (acc, f) => {
+        if (!acc[f.category]) acc[f.category] = [];
+        acc[f.category].push(f.threadId);
+        return acc;
+      },
+      {}
+    );
+    const categoryLines = Object.entries(failuresByCategory).map(([category, threadIds]) => {
+      const suggestion = CATEGORY_SUGGESTIONS[category];
+      const idList = threadIds.slice(0, 5).join(", ");
+      const moreText = threadIds.length > 5 ? ` (+${threadIds.length - 5} more)` : "";
+      return `- ${category} (${threadIds.length}): ${suggestion}
+  ${idList}${moreText}`;
+    }).join("\n");
+    return structuredResponse(
+      `Partially completed: ${succeeded} thread(s) modified, ${allFailures.length} failed.` + (addLabelIds ? `
+Added labels: ${addLabelIds.join(", ")}` : "") + (removeLabelIds ? `
+Removed labels: ${removeLabelIds.join(", ")}` : "") + `
+
+Failures:
+${categoryLines}`,
+      { succeeded, failed: allFailures.length, total: ids.length, failuresByCategory }
+    );
+  }
   return successResponse(
-    `Successfully modified labels for ${messageIds.length} email(s).` + (addLabelIds ? `
+    `Successfully modified labels for ${ids.length} thread(s).` + (addLabelIds ? `
 Added labels: ${addLabelIds.join(", ")}` : "") + (removeLabelIds ? `
 Removed labels: ${removeLabelIds.join(", ")}` : "")
   );
@@ -10629,28 +10666,31 @@ async function handleListLabels(gmail, args) {
   if (!includeSystemLabels) {
     labels = userLabels;
   }
-  const formattedLabels = labels.map((l) => `- ${l.name} [${l.id}] (${l.type})`).join("\n");
+  const labelData = labels.map((l) => ({
+    id: l.id,
+    name: l.name,
+    type: l.type,
+    messageListVisibility: l.messageListVisibility,
+    labelListVisibility: l.labelListVisibility,
+    color: l.color,
+    messagesTotal: l.messagesTotal,
+    messagesUnread: l.messagesUnread
+  }));
   log("Listed labels", {
     total: labels.length,
     system: systemLabels.length,
     user: userLabels.length
   });
-  return structuredResponse(`Found ${labels.length} label(s):
+  return structuredResponse(
+    `Found ${labels.length} label(s):
 
-${formattedLabels}`, {
-    labels: labels.map((l) => ({
-      id: l.id,
-      name: l.name,
-      type: l.type,
-      messageListVisibility: l.messageListVisibility,
-      labelListVisibility: l.labelListVisibility,
-      color: l.color,
-      messagesTotal: l.messagesTotal,
-      messagesUnread: l.messagesUnread
-    })),
-    systemLabelCount: systemLabels.length,
-    userLabelCount: userLabels.length
-  });
+${toToon({ labels: labelData })}`,
+    {
+      labels: labelData,
+      systemLabelCount: systemLabels.length,
+      userLabelCount: userLabels.length
+    }
+  );
 }
 async function handleGetOrCreateLabel(gmail, args) {
   const validation = validateArgs(GetOrCreateLabelSchema, args);
@@ -10823,26 +10863,20 @@ ${actionStr || "None"}`,
   if (filters.length === 0) {
     return structuredResponse("No filters found.", { filters: [] });
   }
-  const formattedFilters = filters.map((f) => {
-    const criteria = f.criteria || {};
-    const criteriaStr = [
-      criteria.from ? `from:${criteria.from}` : null,
-      criteria.to ? `to:${criteria.to}` : null,
-      criteria.subject ? `subject:${criteria.subject}` : null,
-      criteria.query ? `query:${criteria.query}` : null
-    ].filter(Boolean).join(", ");
-    return `- [${f.id}] ${criteriaStr || "(no criteria)"}`;
-  }).join("\n");
+  const filterData = filters.map((f) => ({
+    id: f.id,
+    criteria: f.criteria,
+    action: f.action
+  }));
   log("Listed filters", { count: filters.length });
-  return structuredResponse(`Found ${filters.length} filter(s):
+  return structuredResponse(
+    `Found ${filters.length} filter(s):
 
-${formattedFilters}`, {
-    filters: filters.map((f) => ({
-      id: f.id,
-      criteria: f.criteria,
-      action: f.action
-    }))
-  });
+${toToon({ filters: filterData })}`,
+    {
+      filters: filterData
+    }
+  );
 }
 async function handleDeleteFilter(gmail, args) {
   const validation = validateArgs(DeleteFilterSchema, args);
@@ -10928,8 +10962,8 @@ async function handleListTools(args) {
 var drive = null;
 var authClient = null;
 var authenticationPromise = null;
-var __filename = fileURLToPath2(import.meta.url);
-var __dirname = dirname3(__filename);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
 var packageJsonPath = join3(__dirname, "..", "package.json");
 var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
 var VERSION = packageJson.version;