@tool-bridge/server 0.21.1 → 0.22.1

package/dist/gmail-KQSDEB47.js

@@ -0,0 +1,1887 @@
+import {
+  createAuthedClient
+} from "./chunk-RTW5VRTK.js";
+import "./chunk-BNMLA2RC.js";
+import {
+  asJsonObject
+} from "./chunk-JXHMDBAY.js";
+import {
+  createProviderPlugin,
+  upstreamError
+} from "./chunk-X7ZUTKHR.js";
+import "./chunk-7ISGFRC6.js";
+import "./chunk-UY6ANCOY.js";
+import {
+  TBError
+} from "./chunk-HA4BGL6C.js";
+import "./chunk-U67V476Y.js";
+
+// ../plugins/src/gmail/api/shared.ts
+var SERVICE = "gmail";
+var API_BASE = "https://gmail.googleapis.com/gmail/v1";
+var USER_ID = "me";
+var RATE_LIMIT_REASONS = /* @__PURE__ */ new Set([
+  "dailyLimitExceeded",
+  "quotaExceeded",
+  "rateLimitExceeded",
+  "userRateLimitExceeded"
+]);
+function trimmedString(value) {
+  return String(value ?? "").trim();
+}
+function toStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => String(item).trim()).filter(Boolean);
+}
+function normalizeFormat(value, fallback) {
+  return trimmedString(value) || fallback;
+}
+var record = asJsonObject;
+function requireRecord(value, label) {
+  const result = record(value);
+  if (result === void 0) throw new TBError("unavailable", `Gmail \u7684 ${label} \u4E0D\u662F\u5BF9\u8C61`, { retryable: true });
+  return result;
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function recordArray(value, label) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    throw new TBError("unavailable", `Gmail \u7684 ${label} \u4E0D\u662F\u6570\u7EC4`, { retryable: true });
+  }
+  return value.map((item) => requireRecord(item, `${label} \u7684\u5143\u7D20`));
+}
+function nullableRecord(value, label) {
+  if (value === null) return {};
+  return requireRecord(value, label);
+}
+function asObject(value) {
+  return record(value) ?? {};
+}
+function labelMutationPayload(input) {
+  return {
+    addLabelIds: toStringArray(input.addLabelIds),
+    removeLabelIds: toStringArray(input.removeLabelIds)
+  };
+}
+function bodyFromInput(input, drop = []) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([key, value]) => key !== "userId" && !drop.includes(key) && value !== void 0)
+  );
+}
+async function hydrateInBatches(items, hydrate, batchSize = 10) {
+  const hydrated = [];
+  for (let index = 0; index < items.length; index += batchSize) {
+    const batch = items.slice(index, index + batchSize);
+    hydrated.push(...await Promise.all(batch.map((item) => hydrate(item))));
+  }
+  return hydrated;
+}
+function buildPath(path) {
+  const segments = path.map((segment) => encodeURIComponent(segment)).join("/");
+  return `users/${encodeURIComponent(USER_ID)}${segments === "" ? "" : `/${segments}`}`;
+}
+function errorMessage(payload) {
+  const error = record(payload)?.error;
+  if (typeof error === "string") return trimmedString(error) || void 0;
+  return trimmedString(record(error)?.message) || void 0;
+}
+function errorReasons(payload) {
+  const errors = record(record(payload)?.error)?.errors;
+  if (!Array.isArray(errors)) return [];
+  return errors.map((item) => trimmedString(record(item)?.reason)).filter(Boolean);
+}
+function gmailError(status, payload) {
+  const message = errorMessage(payload) ?? `Gmail \u8FD4\u56DE HTTP ${status}`;
+  if (status === 403 && errorReasons(payload).some((reason) => RATE_LIMIT_REASONS.has(reason))) {
+    return upstreamError(429, message);
+  }
+  return upstreamError(status, message);
+}
+var http = createAuthedClient({
+  baseUrl: `${API_BASE}/`,
+  service: SERVICE,
+  auth: { kind: "bearer" },
+  mapError: ({ bodyKind, data, status }) => gmailError(
+    status,
+    bodyKind === "json" ? data : null
+  )
+});
+async function send(ctx, input) {
+  const hasBody = input.body !== void 0;
+  const response = await http.request(ctx, {
+    method: input.method ?? "GET",
+    path: buildPath(input.path),
+    query: Object.entries(input.query ?? {}),
+    ...hasBody ? { json: input.body } : {},
+    invalidJson: "text"
+  });
+  if (response.bodyKind === "invalid-json") {
+    throw new TBError("unavailable", "Gmail \u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94", { retryable: true });
+  }
+  return { payload: response.bodyKind === "empty" ? null : response.data };
+}
+async function requestJson(ctx, input) {
+  return (await send(ctx, input)).payload;
+}
+async function requestEmpty(ctx, input) {
+  await send(ctx, input);
+}
+async function requestRecord(ctx, input, label) {
+  return requireRecord(await requestJson(ctx, input), label);
+}
+
+// ../plugins/src/gmail/api/message.ts
+function encodeBase64(value) {
+  const bytes = new TextEncoder().encode(value);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function encodeBase64Url(value) {
+  return encodeBase64(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function decodeBase64Url(value) {
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = normalized.padEnd(normalized.length + (4 - normalized.length % 4) % 4, "=");
+  let binary;
+  try {
+    binary = atob(padded);
+  } catch {
+    return "";
+  }
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  return new TextDecoder().decode(bytes);
+}
+function joinAddresses(addresses) {
+  return addresses.filter(Boolean).join(", ");
+}
+function headerLine(name, value) {
+  return value ? `${name}: ${value}` : "";
+}
+function encodeSubject(subject) {
+  return [...subject].every((char) => char.charCodeAt(0) <= 127) ? subject : `=?UTF-8?B?${encodeBase64(subject)}?=`;
+}
+function normalizeReplySubject(subject) {
+  if (!subject) return "Re:";
+  return /^re:/i.test(subject) ? subject : `Re: ${subject}`;
+}
+function toMessageTimestamp(internalDate, fallbackDate) {
+  if (internalDate) {
+    const parsed = Number(internalDate);
+    if (Number.isFinite(parsed)) {
+      const date = new Date(parsed);
+      if (!Number.isNaN(date.getTime())) return date.toISOString();
+    }
+  }
+  if (fallbackDate) {
+    const parsed = new Date(fallbackDate);
+    if (!Number.isNaN(parsed.getTime())) return parsed.toISOString();
+  }
+  return "";
+}
+function collectAttachments(payload) {
+  if (!payload) return [];
+  const attachments = [];
+  if (payload.filename) {
+    attachments.push({
+      attachmentId: payload.body?.attachmentId ?? null,
+      filename: payload.filename,
+      mimeType: payload.mimeType ?? "application/octet-stream",
+      size: payload.body?.size ?? 0
+    });
+  }
+  for (const part of payload.parts ?? []) attachments.push(...collectAttachments(part));
+  return attachments;
+}
+function parseAddressList(value) {
+  const addresses = [];
+  let current = "";
+  let inQuotes = false;
+  let angleDepth = 0;
+  let escaped = false;
+  for (const char of value) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      current += char;
+      if (inQuotes) escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      current += char;
+      continue;
+    }
+    if (!inQuotes) {
+      if (char === "<") {
+        angleDepth += 1;
+      } else if (char === ">" && angleDepth > 0) {
+        angleDepth -= 1;
+      } else if (char === "," && angleDepth === 0) {
+        const address2 = current.trim();
+        if (address2) addresses.push(address2);
+        current = "";
+        continue;
+      }
+    }
+    current += char;
+  }
+  const address = current.trim();
+  if (address) addresses.push(address);
+  return addresses;
+}
+function firstAddress(value) {
+  return parseAddressList(value)[0] ?? "";
+}
+function readHeader(headers, name) {
+  return headers.find((header) => header.name.toLowerCase() === name.toLowerCase())?.value ?? "";
+}
+function extractBodyContent(payload) {
+  if (!payload) return { body: "", isHtml: false };
+  if (payload.mimeType === "text/plain" && payload.body?.data) {
+    return { body: decodeBase64Url(payload.body.data), isHtml: false };
+  }
+  if (payload.mimeType === "text/html" && payload.body?.data) {
+    return { body: decodeBase64Url(payload.body.data), isHtml: true };
+  }
+  for (const part of payload.parts ?? []) {
+    const content = extractBodyContent(part);
+    if (content.body) return content;
+  }
+  if (payload.body?.data && (!payload.mimeType || payload.mimeType.startsWith("text/"))) {
+    return { body: decodeBase64Url(payload.body.data), isHtml: payload.mimeType === "text/html" };
+  }
+  return { body: "", isHtml: false };
+}
+function normalizeThreadId(value) {
+  return String(value ?? "").replace(/^thread-f:/i, "").replace(/^msg-f:/i, "").trim();
+}
+function normalizeMessageId(value) {
+  return String(value ?? "").trim();
+}
+function summarizeGmailMessage(resource) {
+  const headers = resource.payload?.headers ?? [];
+  return {
+    messageId: resource.id,
+    threadId: resource.threadId,
+    labelIds: resource.labelIds ?? [],
+    subject: readHeader(headers, "Subject"),
+    sender: readHeader(headers, "From"),
+    to: readHeader(headers, "To"),
+    messageTimestamp: toMessageTimestamp(resource.internalDate, readHeader(headers, "Date"))
+  };
+}
+function normalizeGmailMessage(resource) {
+  const payload = resource.payload ?? null;
+  const summary = summarizeGmailMessage(resource);
+  const messageText = extractBodyContent(payload).body;
+  return {
+    ...summary,
+    preview: {
+      subject: summary.subject,
+      // Gmail 自己的 snippet 优先(它已经做过 HTML 剥离);没有才从正文截 200 字。
+      body: resource.snippet ?? messageText.slice(0, 200)
+    },
+    payload,
+    messageText,
+    attachmentList: collectAttachments(payload),
+    ...resource.raw ? { raw: resource.raw } : {}
+  };
+}
+function resolveReplyHeaders(resource) {
+  const headers = resource.payload?.headers ?? [];
+  return {
+    subject: normalizeReplySubject(readHeader(headers, "Subject")),
+    to: firstAddress(readHeader(headers, "Reply-To")) || firstAddress(readHeader(headers, "From")),
+    references: readHeader(headers, "References") || readHeader(headers, "Message-ID") || resource.id,
+    inReplyTo: readHeader(headers, "Message-ID") || resource.id
+  };
+}
+function encodeMimeMessage(input) {
+  const headers = [
+    headerLine("From", joinAddresses(input.from ? [input.from] : [])),
+    headerLine("To", joinAddresses(input.to)),
+    headerLine("Cc", joinAddresses(input.cc ?? [])),
+    headerLine("Bcc", joinAddresses(input.bcc ?? [])),
+    headerLine("Subject", encodeSubject(input.subject ?? "")),
+    headerLine("In-Reply-To", input.inReplyTo),
+    headerLine("References", input.references),
+    "MIME-Version: 1.0",
+    `Content-Type: ${input.isHtml ? "text/html" : "text/plain"}; charset=UTF-8`,
+    "Content-Transfer-Encoding: base64"
+  ].filter(Boolean);
+  return encodeBase64Url(`${headers.join("\r\n")}\r
+\r
+${encodeBase64(input.body ?? "")}`);
+}
+function optionalAddressList(value) {
+  if (Array.isArray(value)) return value.map((item) => String(item).trim()).filter(Boolean);
+  const stringValue = String(value ?? "").trim();
+  return stringValue ? [stringValue] : [];
+}
+function buildRecipients(input) {
+  return {
+    to: [
+      ...optionalAddressList(input.to),
+      ...optionalAddressList(input.recipientEmail),
+      ...optionalAddressList(input.extraRecipients)
+    ],
+    cc: optionalAddressList(input.cc),
+    bcc: optionalAddressList(input.bcc)
+  };
+}
+
+// ../plugins/src/gmail/api/mailbox.ts
+var SETTINGS_AUTO_FORWARDING = "autoForwarding";
+var SETTINGS_IMAP = "imap";
+var SETTINGS_LANGUAGE = "language";
+var SETTINGS_POP = "pop";
+var SETTINGS_VACATION = "vacation";
+function getSettings(resource, ctx) {
+  return requestRecord(ctx, { path: ["settings", resource] }, `settings/${resource} \u54CD\u5E94`);
+}
+function updateSettings(resource, input, ctx) {
+  return requestRecord(ctx, {
+    method: "PUT",
+    path: ["settings", resource],
+    body: bodyFromInput(input)
+  }, `settings/${resource} \u54CD\u5E94`);
+}
+async function getProfile(_input, ctx) {
+  return requestRecord(ctx, { path: ["profile"] }, "profile \u54CD\u5E94");
+}
+async function listHistory(input, ctx) {
+  const startHistoryId = normalizeMessageId(input.startHistoryId);
+  const historyTypes = toStringArray(input.historyTypes);
+  const payload = requireRecord(await requestJson(ctx, {
+    path: ["history"],
+    query: {
+      startHistoryId,
+      pageToken: input.pageToken,
+      maxResults: input.maxResults,
+      labelId: input.labelId,
+      historyTypes: historyTypes.length > 0 ? historyTypes : void 0
+    }
+  }), "history \u54CD\u5E94");
+  return {
+    history: recordArray(payload.history, "history"),
+    // 没有变更时 Gmail 不回 historyId;把入参那个原样报回去,调用方下一轮才有可用的水位。
+    historyId: optionalString(payload.historyId) ?? startHistoryId,
+    nextPageToken: optionalString(payload.nextPageToken) ?? null
+  };
+}
+async function listFilters(_input, ctx) {
+  const payload = nullableRecord(
+    await requestJson(ctx, { path: ["settings", "filters"] }),
+    "filters \u54CD\u5E94"
+  );
+  return { filters: recordArray(payload.filter, "filters") };
+}
+async function getFilter(input, ctx) {
+  return requestRecord(
+    ctx,
+    { path: ["settings", "filters", normalizeMessageId(input.filterId)] },
+    "filter \u54CD\u5E94"
+  );
+}
+async function createFilter(input, ctx) {
+  return requestRecord(ctx, {
+    method: "POST",
+    path: ["settings", "filters"],
+    // 只发 criteria 与 action 两个键:filters.create 不认别的字段(userId 尤其会被拒)。
+    body: { criteria: asObject(input.criteria), action: asObject(input.action) }
+  }, "filter \u54CD\u5E94");
+}
+async function deleteFilter(input, ctx) {
+  await requestEmpty(ctx, {
+    method: "DELETE",
+    path: ["settings", "filters", normalizeMessageId(input.filterId)]
+  });
+  return { success: true };
+}
+async function listForwardingAddresses(_input, ctx) {
+  const payload = nullableRecord(
+    await requestJson(ctx, { path: ["settings", "forwardingAddresses"] }),
+    "forwardingAddresses \u54CD\u5E94"
+  );
+  return { forwardingAddresses: recordArray(payload.forwardingAddresses, "forwardingAddresses") };
+}
+function getLanguageSettings(_input, ctx) {
+  return getSettings(SETTINGS_LANGUAGE, ctx);
+}
+function updateLanguageSettings(input, ctx) {
+  return updateSettings(SETTINGS_LANGUAGE, input, ctx);
+}
+function getVacationSettings(_input, ctx) {
+  return getSettings(SETTINGS_VACATION, ctx);
+}
+function updateVacationSettings(input, ctx) {
+  return updateSettings(SETTINGS_VACATION, input, ctx);
+}
+function getAutoForwarding(_input, ctx) {
+  return getSettings(SETTINGS_AUTO_FORWARDING, ctx);
+}
+function settingsGetImap(_input, ctx) {
+  return getSettings(SETTINGS_IMAP, ctx);
+}
+function updateImapSettings(input, ctx) {
+  return updateSettings(SETTINGS_IMAP, input, ctx);
+}
+function settingsGetPop(_input, ctx) {
+  return getSettings(SETTINGS_POP, ctx);
+}
+function updatePopSettings(input, ctx) {
+  return updateSettings(SETTINGS_POP, input, ctx);
+}
+async function stopWatch(_input, ctx) {
+  await requestEmpty(ctx, { method: "POST", path: ["stop"] });
+  return { success: true };
+}
+
+// ../plugins/src/gmail/api/resources.ts
+function shapeError(label, detail) {
+  return new TBError("unavailable", `Gmail \u7684 ${label} ${detail}`, { retryable: true });
+}
+function asMessageResource(payload, label) {
+  const value = requireRecord(payload, label);
+  if (typeof value.id !== "string" || typeof value.threadId !== "string") {
+    throw shapeError(label, "\u7F3A id \u6216 threadId");
+  }
+  return value;
+}
+function asThreadResource(payload, label) {
+  const value = requireRecord(payload, label);
+  if (typeof value.id !== "string") throw shapeError(label, "\u7F3A id");
+  return value;
+}
+function asDraftResource(payload, label) {
+  const value = requireRecord(payload, label);
+  if (typeof value.id !== "string") throw shapeError(label, "\u7F3A id");
+  asMessageResource(value.message, `${label} \u7684 message`);
+  return value;
+}
+async function getMessageResource(ctx, messageId, format) {
+  return asMessageResource(
+    await requestJson(ctx, { path: ["messages", messageId], query: { format } }),
+    "message \u54CD\u5E94"
+  );
+}
+async function getThreadResource(ctx, threadId, format) {
+  return asThreadResource(
+    await requestJson(ctx, { path: ["threads", threadId], query: { format } }),
+    "thread \u54CD\u5E94"
+  );
+}
+async function getDraftResource(ctx, draftId, format) {
+  return asDraftResource(
+    await requestJson(ctx, { path: ["drafts", draftId], query: { format } }),
+    "draft \u54CD\u5E94"
+  );
+}
+
+// ../plugins/src/gmail/api/messages.ts
+var DEFAULT_FETCH_EMAILS_MAX_RESULTS = 20;
+function threadSummary(thread) {
+  return {
+    threadId: thread.id,
+    snippet: thread.snippet ?? "",
+    historyId: thread.historyId ?? null,
+    messages: (thread.messages ?? []).map((message) => normalizeGmailMessage(message))
+  };
+}
+async function listThreads(input, ctx) {
+  const query = trimmedString(input.query);
+  const payload = requireRecord(await requestJson(ctx, {
+    path: ["threads"],
+    query: {
+      q: query === "" ? void 0 : query,
+      pageToken: input.pageToken,
+      maxResults: input.maxResults
+    }
+  }), "threads \u54CD\u5E94");
+  const threads = recordArray(payload.threads, "threads");
+  const nextPageToken = optionalString(payload.nextPageToken) ?? null;
+  if (input.verbose === true) {
+    const hydrated = await hydrateInBatches(threads, (thread) => getThreadResource(ctx, String(thread.id), "full"));
+    return {
+      threads: hydrated.map((thread) => threadSummary(thread)),
+      nextPageToken,
+      resultSizeEstimate: payload.resultSizeEstimate ?? hydrated.length
+    };
+  }
+  return {
+    threads: threads.map((thread) => ({
+      threadId: String(thread.id),
+      snippet: optionalString(thread.snippet) ?? "",
+      historyId: optionalString(thread.historyId) ?? null
+    })),
+    nextPageToken,
+    resultSizeEstimate: payload.resultSizeEstimate ?? threads.length
+  };
+}
+async function searchThreads(input, ctx) {
+  const output = await listThreads(input, ctx);
+  return {
+    threads: output.threads.map((thread) => ({
+      threadId: thread.threadId,
+      snippet: thread.snippet
+    }))
+  };
+}
+async function listThreadsAction(input, ctx) {
+  return { ...await listThreads(input, ctx) };
+}
+async function fetchEmails(input, ctx) {
+  const query = trimmedString(input.query);
+  const labelIds = toStringArray(input.labelIds);
+  const payload = requireRecord(await requestJson(ctx, {
+    path: ["messages"],
+    query: {
+      q: query === "" ? void 0 : query,
+      labelIds: labelIds.length > 0 ? labelIds : void 0,
+      pageToken: input.pageToken,
+      // 上游还做了一次 1..500 的范围校验;那层现在由 schema 的 `z.int().min(1).max(500)` 承担,
+      // 越界在进 handler 前就已经是 invalid_argument 了。
+      maxResults: input.maxResults ?? DEFAULT_FETCH_EMAILS_MAX_RESULTS,
+      includeSpamTrash: input.includeSpamTrash
+    }
+  }), "messages \u54CD\u5E94");
+  const messages = recordArray(payload.messages, "messages");
+  const nextPageToken = optionalString(payload.nextPageToken) ?? null;
+  const detail = trimmedString(input.detail) || "summary";
+  if (detail === "ids") {
+    return {
+      messages: messages.map((message) => ({
+        messageId: String(message.id),
+        threadId: String(message.threadId)
+      })),
+      nextPageToken,
+      resultSizeEstimate: payload.resultSizeEstimate ?? messages.length
+    };
+  }
+  const includeFullMessage = detail === "full";
+  const hydrated = await hydrateInBatches(messages, (message) => getMessageResource(ctx, String(message.id), includeFullMessage ? "full" : "metadata"));
+  return {
+    messages: hydrated.map((message) => includeFullMessage ? normalizeGmailMessage(message) : summarizeGmailMessage(message)),
+    nextPageToken,
+    resultSizeEstimate: payload.resultSizeEstimate ?? hydrated.length
+  };
+}
+async function getMessage(input, ctx) {
+  const message = await getMessageResource(ctx, normalizeMessageId(input.messageId), "full");
+  const output = normalizeGmailMessage(message);
+  return {
+    messageId: output.messageId,
+    threadId: output.threadId,
+    subject: output.subject,
+    from: output.sender,
+    to: output.to,
+    // date 取的是原始 `Date` 头,而不是 normalize 出来的 ISO 时间戳 —— 两者是不同的东西。
+    date: readHeader(message.payload?.headers ?? [], "Date"),
+    body: output.messageText
+  };
+}
+async function fetchMessageByMessageId(input, ctx) {
+  const message = await getMessageResource(
+    ctx,
+    normalizeMessageId(input.messageId),
+    normalizeFormat(input.format, "full")
+  );
+  return { ...normalizeGmailMessage(message) };
+}
+async function fetchMessageByThreadId(input, ctx) {
+  const thread = await getThreadResource(ctx, normalizeThreadId(input.threadId), "full");
+  return {
+    threadId: thread.id,
+    historyId: thread.historyId ?? null,
+    messages: (thread.messages ?? []).map((message) => normalizeGmailMessage(message))
+  };
+}
+async function addLabelToEmail(input, ctx) {
+  const message = asMessageResource(await requestJson(ctx, {
+    method: "POST",
+    path: ["messages", normalizeMessageId(input.messageId), "modify"],
+    body: labelMutationPayload(input)
+  }), "message \u54CD\u5E94");
+  return { ...normalizeGmailMessage(message) };
+}
+async function batchModifyMessages(input, ctx) {
+  await requestEmpty(ctx, {
+    method: "POST",
+    path: ["messages", "batchModify"],
+    body: { ids: toStringArray(input.messageIds), ...labelMutationPayload(input) }
+  });
+  return { success: true };
+}
+async function messageAction(messageId, action, ctx) {
+  const message = asMessageResource(await requestJson(ctx, {
+    method: "POST",
+    path: ["messages", normalizeMessageId(messageId), action]
+  }), "message \u54CD\u5E94");
+  return { ...normalizeGmailMessage(message) };
+}
+async function threadAction(threadId, action, ctx, body) {
+  const thread = asThreadResource(await requestJson(ctx, {
+    method: "POST",
+    path: ["threads", normalizeThreadId(threadId), action],
+    body
+  }), "thread \u54CD\u5E94");
+  return {
+    threadId: thread.id,
+    historyId: thread.historyId ?? null,
+    messages: (thread.messages ?? []).map((message) => normalizeGmailMessage(message))
+  };
+}
+function moveToTrash(input, ctx) {
+  return messageAction(input.messageId, "trash", ctx);
+}
+function untrashMessage(input, ctx) {
+  return messageAction(input.messageId, "untrash", ctx);
+}
+function modifyThreadLabels(input, ctx) {
+  return threadAction(input.threadId, "modify", ctx, labelMutationPayload(input));
+}
+function moveThreadToTrash(input, ctx) {
+  return threadAction(input.threadId, "trash", ctx);
+}
+function untrashThread(input, ctx) {
+  return threadAction(input.threadId, "untrash", ctx);
+}
+
+// ../plugins/src/gmail/api/drafts.ts
+function asSentMessage(payload) {
+  const value = requireRecord(payload, "send \u54CD\u5E94");
+  if (typeof value.id !== "string") {
+    throw new TBError("unavailable", "Gmail \u7684 send \u54CD\u5E94\u7F3A id", { retryable: true });
+  }
+  return { id: value.id, threadId: optionalString(value.threadId) };
+}
+function asDraftMutation(payload) {
+  const draft = requireRecord(payload, "draft \u54CD\u5E94");
+  const message = record(draft.message);
+  if (typeof draft.id !== "string") {
+    throw new TBError("unavailable", "Gmail \u7684 draft \u54CD\u5E94\u7F3A id", { retryable: true });
+  }
+  return {
+    draftId: draft.id,
+    messageId: optionalString(message?.id) ?? "",
+    threadId: optionalString(message?.threadId) ?? ""
+  };
+}
+async function sendThreadMessage(ctx, threadId, raw) {
+  return asSentMessage(await requestJson(ctx, {
+    method: "POST",
+    path: ["messages", "send"],
+    body: { threadId, raw }
+  }));
+}
+async function createDraftResource(input, ctx) {
+  const recipients = buildRecipients(input);
+  return asDraftMutation(await requestJson(ctx, {
+    method: "POST",
+    path: ["drafts"],
+    body: {
+      message: {
+        raw: encodeMimeMessage({
+          to: recipients.to,
+          cc: recipients.cc,
+          bcc: recipients.bcc,
+          subject: trimmedString(input.subject),
+          body: trimmedString(input.body) || trimmedString(input.messageBody),
+          isHtml: input.isHtml === true,
+          from: trimmedString(input.fromEmail)
+        }),
+        threadId: trimmedString(input.threadId) ? normalizeThreadId(input.threadId) : void 0
+      }
+    }
+  }));
+}
+async function sendEmail(input, ctx) {
+  const recipients = buildRecipients(input);
+  const sent = asSentMessage(await requestJson(ctx, {
+    method: "POST",
+    path: ["messages", "send"],
+    body: {
+      raw: encodeMimeMessage({
+        to: recipients.to,
+        cc: recipients.cc,
+        bcc: recipients.bcc,
+        subject: trimmedString(input.subject),
+        body: trimmedString(input.body) || trimmedString(input.messageBody),
+        isHtml: input.isHtml === true,
+        from: trimmedString(input.fromEmail)
+      })
+    }
+  }));
+  return { messageId: sent.id };
+}
+async function replyEmail(input, ctx) {
+  const message = await getMessageResource(ctx, normalizeMessageId(input.messageId), "full");
+  const replyHeaders = resolveReplyHeaders(message);
+  const threadId = normalizeThreadId(message.threadId || input.threadId);
+  const sent = await sendThreadMessage(ctx, threadId, encodeMimeMessage({
+    to: [replyHeaders.to],
+    subject: replyHeaders.subject,
+    body: trimmedString(input.body),
+    inReplyTo: replyHeaders.inReplyTo,
+    references: replyHeaders.references
+  }));
+  return { messageId: sent.id };
+}
+async function replyToThread(input, ctx) {
+  const thread = await getThreadResource(ctx, normalizeThreadId(input.threadId), "full");
+  const target = thread.messages?.at(-1);
+  if (target === void 0) {
+    throw new TBError("invalid_argument", "thread \u91CC\u6CA1\u6709\u4EFB\u4F55\u6D88\u606F,\u65E0\u6CD5\u56DE\u590D");
+  }
+  const recipients = buildRecipients(input);
+  const replyHeaders = resolveReplyHeaders(target);
+  const sent = await sendThreadMessage(ctx, thread.id, encodeMimeMessage({
+    to: recipients.to.length > 0 ? recipients.to : [replyHeaders.to],
+    cc: recipients.cc,
+    bcc: recipients.bcc,
+    subject: replyHeaders.subject,
+    body: trimmedString(input.messageBody) || trimmedString(input.body),
+    isHtml: input.isHtml === true,
+    inReplyTo: replyHeaders.inReplyTo,
+    references: replyHeaders.references
+  }));
+  return { messageId: sent.id, threadId: sent.threadId ?? thread.id };
+}
+async function createDraft(input, ctx) {
+  const { draftId } = await createDraftResource(input, ctx);
+  return { draftId };
+}
+async function createEmailDraft(input, ctx) {
+  return { ...await createDraftResource(input, ctx) };
+}
+async function listDrafts(input, ctx) {
+  const payload = requireRecord(await requestJson(ctx, {
+    path: ["drafts"],
+    query: { pageToken: input.pageToken, maxResults: input.maxResults }
+  }), "drafts \u54CD\u5E94");
+  const drafts = recordArray(payload.drafts, "drafts");
+  const nextPageToken = optionalString(payload.nextPageToken) ?? null;
+  if (input.verbose === true) {
+    const hydrated = await hydrateInBatches(drafts, (draft) => getDraftResource(ctx, String(draft.id), "full"));
+    return {
+      drafts: hydrated.map((draft) => ({ id: draft.id, message: normalizeGmailMessage(draft.message) })),
+      nextPageToken
+    };
+  }
+  return {
+    drafts: drafts.map((draft) => ({
+      id: String(draft.id),
+      // 非 verbose 时列表接口只回 id 对,其余字段一律缺席 —— 用空串而不是 null 占位,
+      // 与出参声明(message 的字段都是 string)对齐。
+      message: {
+        messageId: optionalString(record(draft.message)?.id) ?? "",
+        threadId: optionalString(record(draft.message)?.threadId) ?? ""
+      }
+    })),
+    nextPageToken
+  };
+}
+async function getDraft(input, ctx) {
+  const draft = await getDraftResource(
+    ctx,
+    normalizeMessageId(input.draftId),
+    normalizeFormat(input.format, "full")
+  );
+  return { id: draft.id, message: normalizeGmailMessage(draft.message) };
+}
+async function updateDraft(input, ctx) {
+  const draftId = normalizeMessageId(input.draftId);
+  const existing = await getDraftResource(ctx, draftId, "full");
+  const headers = existing.message.payload?.headers ?? [];
+  const next = buildRecipients(input);
+  const recipients = buildRecipients({
+    to: next.to.length > 0 ? next.to : parseAddressList(readHeader(headers, "To")),
+    cc: next.cc.length > 0 ? next.cc : parseAddressList(readHeader(headers, "Cc")),
+    bcc: next.bcc.length > 0 ? next.bcc : parseAddressList(readHeader(headers, "Bcc"))
+  });
+  const existingBody = extractBodyContent(existing.message.payload ?? null);
+  const body = Object.hasOwn(input, "body") ? trimmedString(input.body) : Object.hasOwn(input, "messageBody") ? trimmedString(input.messageBody) : existingBody.body;
+  const threadId = trimmedString(input.threadId) || existing.message.threadId;
+  const mutation = asDraftMutation(await requestJson(ctx, {
+    method: "PUT",
+    path: ["drafts", draftId],
+    body: {
+      id: draftId,
+      message: {
+        raw: encodeMimeMessage({
+          to: recipients.to,
+          cc: recipients.cc,
+          bcc: recipients.bcc,
+          subject: trimmedString(input.subject) || readHeader(headers, "Subject"),
+          body,
+          // 没显式给 isHtml 就沿用原草稿的正文类型,免得一次改标题把 HTML 信降成纯文本。
+          isHtml: typeof input.isHtml === "boolean" ? input.isHtml : existingBody.isHtml,
+          from: trimmedString(input.fromEmail) || firstAddress(readHeader(headers, "From"))
+        }),
+        threadId: threadId ? normalizeThreadId(threadId) : void 0
+      }
+    }
+  }));
+  return { ...mutation };
+}
+async function sendDraft(input, ctx) {
+  const sent = asSentMessage(await requestJson(ctx, {
+    method: "POST",
+    path: ["drafts", "send"],
+    body: { id: normalizeMessageId(input.draftId) }
+  }));
+  return { messageId: sent.id, threadId: sent.threadId ?? null };
+}
+async function deleteDraft(input, ctx) {
+  await requestEmpty(ctx, { method: "DELETE", path: ["drafts", normalizeMessageId(input.draftId)] });
+  return { success: true };
+}
+
+// ../plugins/src/gmail/api/labels.ts
+async function listLabels(_input, ctx) {
+  const payload = await requestRecord(ctx, { path: ["labels"] }, "labels \u54CD\u5E94");
+  return { labels: recordArray(payload.labels, "labels") };
+}
+async function getLabel(input, ctx) {
+  return requestRecord(ctx, { path: ["labels", normalizeMessageId(input.labelId)] }, "label \u54CD\u5E94");
+}
+async function createLabel(input, ctx) {
+  return requestRecord(ctx, {
+    method: "POST",
+    path: ["labels"],
+    body: bodyFromInput(input, ["labelId"])
+  }, "label \u54CD\u5E94");
+}
+async function patchLabel(input, ctx) {
+  return requestRecord(ctx, {
+    method: "PATCH",
+    path: ["labels", normalizeMessageId(input.labelId)],
+    body: bodyFromInput(input, ["labelId"])
+  }, "label \u54CD\u5E94");
+}
+async function updateLabel(input, ctx) {
+  return requestRecord(ctx, {
+    method: "PUT",
+    path: ["labels", normalizeMessageId(input.labelId)],
+    body: bodyFromInput(input, ["labelId"])
+  }, "label \u54CD\u5E94");
+}
+async function deleteLabel(input, ctx) {
+  await requestEmpty(ctx, { method: "DELETE", path: ["labels", normalizeMessageId(input.labelId)] });
+  return { success: true };
+}
+
+// ../plugins/src/gmail/schema.ts
+import { z } from "zod/v4";
+var searchThreadsInput = z.strictObject({
+  query: z.string().describe("Gmail search query."),
+  maxResults: z.int().min(1).max(500).describe("Maximum number of results to return.").optional()
+}).describe("The input payload for this action.");
+var searchThreadsOutput = z.strictObject({
+  threads: z.array(z.looseObject({
+    threadId: z.string().min(1).describe("Gmail thread ID."),
+    historyId: z.string().describe("Mailbox history checkpoint ID.").nullable().optional(),
+    snippet: z.string().describe("Thread snippet.").optional(),
+    messages: z.array(z.looseObject({
+      messageId: z.string().min(1).describe("Gmail message ID."),
+      threadId: z.string().min(1).describe("Gmail thread ID."),
+      labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+      subject: z.string().describe("Message subject."),
+      sender: z.string().describe("Message sender."),
+      to: z.string().describe("Message recipients."),
+      messageTimestamp: z.string().describe("Message timestamp."),
+      preview: z.looseObject({}).describe("Gmail API object.").optional(),
+      payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+      messageText: z.string().describe("Extracted message body text.").optional(),
+      attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+      raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+    }).describe("Normalized Gmail message.")).describe("Messages in the thread.").optional()
+  }).describe("Gmail thread.")).describe("Matching thread summaries.")
+}).describe("Thread search result.");
+var listThreadsInput = z.strictObject({
+  query: z.string().describe("Gmail search query.").optional(),
+  verbose: z.boolean().describe("Hydrate each thread.").optional(),
+  maxResults: z.int().min(1).max(500).describe("Maximum number of results to return.").optional(),
+  pageToken: z.string().describe("Opaque pagination token returned by Gmail.").optional()
+}).describe("The input payload for this action.");
+var listThreadsOutput = z.strictObject({
+  threads: z.array(z.looseObject({
+    threadId: z.string().min(1).describe("Gmail thread ID."),
+    historyId: z.string().describe("Mailbox history checkpoint ID.").nullable().optional(),
+    snippet: z.string().describe("Thread snippet.").optional(),
+    messages: z.array(z.looseObject({
+      messageId: z.string().min(1).describe("Gmail message ID."),
+      threadId: z.string().min(1).describe("Gmail thread ID."),
+      labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+      subject: z.string().describe("Message subject."),
+      sender: z.string().describe("Message sender."),
+      to: z.string().describe("Message recipients."),
+      messageTimestamp: z.string().describe("Message timestamp."),
+      preview: z.looseObject({}).describe("Gmail API object.").optional(),
+      payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+      messageText: z.string().describe("Extracted message body text.").optional(),
+      attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+      raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+    }).describe("Normalized Gmail message.")).describe("Messages in the thread.").optional()
+  }).describe("Gmail thread.")).describe("Returned threads."),
+  nextPageToken: z.string().describe("Opaque pagination token returned by Gmail.").nullable().optional(),
+  resultSizeEstimate: z.int().describe("Approximate result count.").optional()
+}).describe("Thread list result.");
+var fetchEmailsInput = z.strictObject({
+  query: z.string().describe("Gmail search query.").optional(),
+  labelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  includeSpamTrash: z.boolean().describe("Whether to include Spam and Trash.").optional(),
+  detail: z.enum(["ids", "summary", "full"]).default("summary").describe("Message detail level.").optional(),
+  maxResults: z.int().min(1).max(500).describe("Maximum number of results to return.").optional(),
+  pageToken: z.string().describe("Opaque pagination token returned by Gmail.").optional()
+}).describe("The input payload for this action.");
+var fetchEmailsOutput = z.strictObject({
+  messages: z.array(z.union([z.looseObject({
+    messageId: z.string().min(1).describe("Gmail message ID."),
+    threadId: z.string().min(1).describe("Gmail thread ID."),
+    labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+    subject: z.string().describe("Message subject."),
+    sender: z.string().describe("Message sender."),
+    to: z.string().describe("Message recipients."),
+    messageTimestamp: z.string().describe("Message timestamp.")
+  }).describe("Normalized Gmail message summary."), z.looseObject({
+    messageId: z.string().min(1).describe("Gmail message ID."),
+    threadId: z.string().min(1).describe("Gmail thread ID."),
+    labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+    subject: z.string().describe("Message subject."),
+    sender: z.string().describe("Message sender."),
+    to: z.string().describe("Message recipients."),
+    messageTimestamp: z.string().describe("Message timestamp."),
+    preview: z.looseObject({}).describe("Gmail API object.").optional(),
+    payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+    messageText: z.string().describe("Extracted message body text.").optional(),
+    attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+    raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+  }).describe("Normalized Gmail message."), z.looseObject({}).describe("Gmail API object.")])).describe("Returned messages."),
+  nextPageToken: z.string().describe("Opaque pagination token returned by Gmail.").nullable().optional(),
+  resultSizeEstimate: z.int().describe("Approximate result count.").optional()
+}).describe("Message list result.");
+var getMessageInput = z.strictObject({
+  messageId: z.string().min(1).describe("Gmail message ID.")
+}).describe("The input payload for this action.");
+var getMessageOutput = z.strictObject({
+  messageId: z.string().min(1).describe("Gmail message ID."),
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  subject: z.string().optional(),
+  from: z.string().optional(),
+  to: z.string().optional(),
+  date: z.string().optional(),
+  body: z.string().optional()
+}).describe("Simplified Gmail message.");
+var fetchMessageByMessageIdInput = z.strictObject({
+  messageId: z.string().min(1).describe("Gmail message ID."),
+  format: z.enum(["minimal", "full", "raw", "metadata"]).describe("Gmail response format to request.").optional()
+}).describe("The input payload for this action.");
+var fetchMessageByMessageIdOutput = z.looseObject({
+  messageId: z.string().min(1).describe("Gmail message ID."),
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+  subject: z.string().describe("Message subject."),
+  sender: z.string().describe("Message sender."),
+  to: z.string().describe("Message recipients."),
+  messageTimestamp: z.string().describe("Message timestamp."),
+  preview: z.looseObject({}).describe("Gmail API object.").optional(),
+  payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+  messageText: z.string().describe("Extracted message body text.").optional(),
+  attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+  raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+}).describe("Normalized Gmail message.");
+var fetchMessageByThreadIdInput = z.strictObject({
+  threadId: z.string().min(1).describe("Gmail thread ID.")
+}).describe("The input payload for this action.");
+var fetchMessageByThreadIdOutput = z.looseObject({
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  historyId: z.string().describe("Mailbox history checkpoint ID.").nullable().optional(),
+  snippet: z.string().describe("Thread snippet.").optional(),
+  messages: z.array(z.looseObject({
+    messageId: z.string().min(1).describe("Gmail message ID."),
+    threadId: z.string().min(1).describe("Gmail thread ID."),
+    labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+    subject: z.string().describe("Message subject."),
+    sender: z.string().describe("Message sender."),
+    to: z.string().describe("Message recipients."),
+    messageTimestamp: z.string().describe("Message timestamp."),
+    preview: z.looseObject({}).describe("Gmail API object.").optional(),
+    payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+    messageText: z.string().describe("Extracted message body text.").optional(),
+    attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+    raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+  }).describe("Normalized Gmail message.")).describe("Messages in the thread.").optional()
+}).describe("Gmail thread.");
+var getProfileInput = z.strictObject({
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var getProfileOutput = z.strictObject({
+  emailAddress: z.string(),
+  messagesTotal: z.int(),
+  threadsTotal: z.int(),
+  historyId: z.string()
+}).describe("Gmail profile.");
+var sendEmailInput = z.strictObject({
+  recipientEmail: z.string().describe("Primary recipient email address.").optional(),
+  to: z.string().describe("Primary recipient email address.").optional(),
+  extraRecipients: z.array(z.string()).describe("Additional To recipients.").optional(),
+  cc: z.union([z.string(), z.array(z.string())]).describe("Cc recipients.").optional(),
+  bcc: z.union([z.string(), z.array(z.string())]).describe("Bcc recipients.").optional(),
+  subject: z.string().describe("Email subject line.").optional(),
+  body: z.string().describe("Email body content.").optional(),
+  messageBody: z.string().describe("Reply or draft body content.").optional(),
+  isHtml: z.boolean().describe("Whether the body is HTML.").optional(),
+  fromEmail: z.string().describe("Verified Gmail send-as alias.").optional()
+}).describe("The input payload for this action.");
+var sendEmailOutput = z.strictObject({
+  messageId: z.string().min(1).describe("Gmail message ID.")
+}).describe("Sent message result.");
+var replyEmailInput = z.strictObject({
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  messageId: z.string().min(1).describe("Gmail message ID."),
+  body: z.string().describe("Reply body.")
+}).describe("The input payload for this action.");
+var replyEmailOutput = z.strictObject({
+  messageId: z.string().min(1).describe("Gmail message ID.")
+}).describe("Reply result.");
+var replyToThreadInput = z.strictObject({
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  recipientEmail: z.string().describe("Primary recipient email address.").optional(),
+  to: z.string().describe("Primary recipient email address.").optional(),
+  extraRecipients: z.array(z.string()).describe("Additional To recipients.").optional(),
+  cc: z.union([z.string(), z.array(z.string())]).describe("Cc recipients.").optional(),
+  bcc: z.union([z.string(), z.array(z.string())]).describe("Bcc recipients.").optional(),
+  subject: z.string().describe("Email subject line.").optional(),
+  body: z.string().describe("Email body content.").optional(),
+  messageBody: z.string().describe("Reply or draft body content.").optional(),
+  isHtml: z.boolean().describe("Whether the body is HTML.").optional(),
+  fromEmail: z.string().describe("Verified Gmail send-as alias.").optional()
+}).describe("The input payload for this action.");
+var replyToThreadOutput = z.strictObject({
+  messageId: z.string().min(1).describe("Gmail message ID."),
+  threadId: z.string().min(1).describe("Gmail thread ID.").optional()
+}).describe("Thread reply result.");
+var createDraftInput = z.strictObject({
+  to: z.string(),
+  subject: z.string(),
+  body: z.string(),
+  cc: z.union([z.string(), z.array(z.string())]).optional()
+}).describe("The input payload for this action.");
+var createDraftOutput = z.strictObject({
+  draftId: z.string().min(1).describe("Gmail draft ID.")
+}).describe("Created draft result.");
+var createEmailDraftInput = z.strictObject({
+  recipientEmail: z.string().describe("Primary recipient email address.").optional(),
+  to: z.string().describe("Primary recipient email address.").optional(),
+  extraRecipients: z.array(z.string()).describe("Additional To recipients.").optional(),
+  cc: z.union([z.string(), z.array(z.string())]).describe("Cc recipients.").optional(),
+  bcc: z.union([z.string(), z.array(z.string())]).describe("Bcc recipients.").optional(),
+  subject: z.string().describe("Email subject line.").optional(),
+  body: z.string().describe("Email body content.").optional(),
+  messageBody: z.string().describe("Reply or draft body content.").optional(),
+  isHtml: z.boolean().describe("Whether the body is HTML.").optional(),
+  fromEmail: z.string().describe("Verified Gmail send-as alias.").optional(),
+  threadId: z.string().min(1).describe("Gmail thread ID.").optional()
+}).describe("The input payload for this action.");
+var createEmailDraftOutput = z.strictObject({
+  draftId: z.string().min(1).describe("Gmail draft ID."),
+  messageId: z.string().min(1).describe("Gmail message ID.").optional(),
+  threadId: z.string().min(1).describe("Gmail thread ID.").optional()
+}).describe("Created draft.");
+var listDraftsInput = z.strictObject({
+  verbose: z.boolean().describe("Hydrate each draft.").optional(),
+  maxResults: z.int().min(1).max(500).describe("Maximum number of results to return.").optional(),
+  pageToken: z.string().describe("Opaque pagination token returned by Gmail.").optional()
+}).describe("The input payload for this action.");
+var listDraftsOutput = z.strictObject({
+  drafts: z.array(z.looseObject({
+    id: z.string().min(1).describe("Gmail draft ID."),
+    message: z.looseObject({
+      messageId: z.string().min(1).describe("Gmail message ID."),
+      threadId: z.string().min(1).describe("Gmail thread ID."),
+      labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+      subject: z.string().describe("Message subject."),
+      sender: z.string().describe("Message sender."),
+      to: z.string().describe("Message recipients."),
+      messageTimestamp: z.string().describe("Message timestamp."),
+      preview: z.looseObject({}).describe("Gmail API object.").optional(),
+      payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+      messageText: z.string().describe("Extracted message body text.").optional(),
+      attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+      raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+    }).describe("Normalized Gmail message.")
+  }).describe("Gmail draft.")),
+  nextPageToken: z.string().describe("Opaque pagination token returned by Gmail.").nullable().optional()
+}).describe("Draft list result.");
+var getDraftInput = z.strictObject({
+  draftId: z.string().min(1).describe("Gmail draft ID."),
+  format: z.enum(["minimal", "full", "raw", "metadata"]).describe("Gmail response format to request.").optional()
+}).describe("The input payload for this action.");
+var getDraftOutput = z.looseObject({
+  id: z.string().min(1).describe("Gmail draft ID."),
+  message: z.looseObject({
+    messageId: z.string().min(1).describe("Gmail message ID."),
+    threadId: z.string().min(1).describe("Gmail thread ID."),
+    labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+    subject: z.string().describe("Message subject."),
+    sender: z.string().describe("Message sender."),
+    to: z.string().describe("Message recipients."),
+    messageTimestamp: z.string().describe("Message timestamp."),
+    preview: z.looseObject({}).describe("Gmail API object.").optional(),
+    payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+    messageText: z.string().describe("Extracted message body text.").optional(),
+    attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+    raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+  }).describe("Normalized Gmail message.")
+}).describe("Gmail draft.");
+var updateDraftInput = z.strictObject({
+  draftId: z.string().min(1).describe("Gmail draft ID."),
+  recipientEmail: z.string().describe("Primary recipient email address.").optional(),
+  to: z.string().describe("Primary recipient email address.").optional(),
+  extraRecipients: z.array(z.string()).describe("Additional To recipients.").optional(),
+  cc: z.union([z.string(), z.array(z.string())]).describe("Cc recipients.").optional(),
+  bcc: z.union([z.string(), z.array(z.string())]).describe("Bcc recipients.").optional(),
+  subject: z.string().describe("Email subject line.").optional(),
+  body: z.string().describe("Email body content.").optional(),
+  messageBody: z.string().describe("Reply or draft body content.").optional(),
+  isHtml: z.boolean().describe("Whether the body is HTML.").optional(),
+  fromEmail: z.string().describe("Verified Gmail send-as alias.").optional(),
+  threadId: z.string().min(1).describe("Gmail thread ID.").optional()
+}).describe("The input payload for this action.");
+var updateDraftOutput = z.strictObject({
+  draftId: z.string().min(1).describe("Gmail draft ID."),
+  messageId: z.string().min(1).describe("Gmail message ID.").optional(),
+  threadId: z.string().min(1).describe("Gmail thread ID.").optional()
+}).describe("Updated draft.");
+var sendDraftInput = z.strictObject({
+  draftId: z.string().min(1).describe("Gmail draft ID.")
+}).describe("The input payload for this action.");
+var sendDraftOutput = z.strictObject({
+  messageId: z.string().min(1).describe("Gmail message ID."),
+  threadId: z.string().min(1).describe("Gmail thread ID.").nullable().optional()
+}).describe("Sent draft result.");
+var deleteDraftInput = z.strictObject({
+  draftId: z.string().min(1).describe("Gmail draft ID."),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var deleteDraftOutput = z.strictObject({
+  success: z.boolean().describe("Whether the operation completed successfully.")
+}).describe("Operation result.");
+var listLabelsInput = z.strictObject({
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var listLabelsOutput = z.strictObject({
+  labels: z.array(z.looseObject({
+    id: z.string().min(1).describe("Gmail label ID."),
+    name: z.string().describe("Label display name."),
+    type: z.string().describe("Label type."),
+    messageListVisibility: z.enum(["show", "hide"]).describe("Whether messages with this label appear in the message list.").optional(),
+    labelListVisibility: z.enum(["labelShow", "labelShowIfUnread", "labelHide"]).describe("Whether the label appears in the label list.").optional(),
+    color: z.strictObject({
+      textColor: z.string().describe("Hex text color.").optional(),
+      backgroundColor: z.string().describe("Hex background color.").optional()
+    }).describe("Gmail label color.").optional()
+  }).describe("Gmail label."))
+}).describe("Label list.");
+var getLabelInput = z.strictObject({
+  labelId: z.string().min(1).describe("Gmail label ID."),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var getLabelOutput = z.looseObject({
+  id: z.string().min(1).describe("Gmail label ID."),
+  name: z.string().describe("Label display name."),
+  type: z.string().describe("Label type."),
+  messageListVisibility: z.enum(["show", "hide"]).describe("Whether messages with this label appear in the message list.").optional(),
+  labelListVisibility: z.enum(["labelShow", "labelShowIfUnread", "labelHide"]).describe("Whether the label appears in the label list.").optional(),
+  color: z.strictObject({
+    textColor: z.string().describe("Hex text color.").optional(),
+    backgroundColor: z.string().describe("Hex background color.").optional()
+  }).describe("Gmail label color.").optional()
+}).describe("Gmail label.");
+var createLabelInput = z.strictObject({
+  name: z.string().min(1).describe("Display name for the new label."),
+  labelListVisibility: z.enum(["labelShow", "labelShowIfUnread", "labelHide"]).optional(),
+  messageListVisibility: z.enum(["show", "hide"]).optional(),
+  color: z.strictObject({
+    textColor: z.string().describe("Hex text color.").optional(),
+    backgroundColor: z.string().describe("Hex background color.").optional()
+  }).describe("Gmail label color.").optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var createLabelOutput = z.looseObject({
+  id: z.string().min(1).describe("Gmail label ID."),
+  name: z.string().describe("Label display name."),
+  type: z.string().describe("Label type."),
+  messageListVisibility: z.enum(["show", "hide"]).describe("Whether messages with this label appear in the message list.").optional(),
+  labelListVisibility: z.enum(["labelShow", "labelShowIfUnread", "labelHide"]).describe("Whether the label appears in the label list.").optional(),
+  color: z.strictObject({
+    textColor: z.string().describe("Hex text color.").optional(),
+    backgroundColor: z.string().describe("Hex background color.").optional()
+  }).describe("Gmail label color.").optional()
+}).describe("Gmail label.");
+var patchLabelInput = z.strictObject({
+  labelId: z.string().min(1).describe("Gmail label ID."),
+  name: z.string().describe("Updated display name for the label.").optional(),
+  labelListVisibility: z.enum(["labelShow", "labelShowIfUnread", "labelHide"]).optional(),
+  messageListVisibility: z.enum(["show", "hide"]).optional(),
+  color: z.strictObject({
+    textColor: z.string().describe("Hex text color.").optional(),
+    backgroundColor: z.string().describe("Hex background color.").optional()
+  }).describe("Gmail label color.").optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var patchLabelOutput = z.looseObject({
+  id: z.string().min(1).describe("Gmail label ID."),
+  name: z.string().describe("Label display name."),
+  type: z.string().describe("Label type."),
+  messageListVisibility: z.enum(["show", "hide"]).describe("Whether messages with this label appear in the message list.").optional(),
+  labelListVisibility: z.enum(["labelShow", "labelShowIfUnread", "labelHide"]).describe("Whether the label appears in the label list.").optional(),
+  color: z.strictObject({
+    textColor: z.string().describe("Hex text color.").optional(),
+    backgroundColor: z.string().describe("Hex background color.").optional()
+  }).describe("Gmail label color.").optional()
+}).describe("Gmail label.");
+var updateLabelInput = z.strictObject({
+  labelId: z.string().min(1).describe("Gmail label ID."),
+  name: z.string().describe("Updated display name for the label.").optional(),
+  labelListVisibility: z.enum(["labelShow", "labelShowIfUnread", "labelHide"]).optional(),
+  messageListVisibility: z.enum(["show", "hide"]).optional(),
+  color: z.strictObject({
+    textColor: z.string().describe("Hex text color.").optional(),
+    backgroundColor: z.string().describe("Hex background color.").optional()
+  }).describe("Gmail label color.").optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var updateLabelOutput = z.looseObject({
+  id: z.string().min(1).describe("Gmail label ID."),
+  name: z.string().describe("Label display name."),
+  type: z.string().describe("Label type."),
+  messageListVisibility: z.enum(["show", "hide"]).describe("Whether messages with this label appear in the message list.").optional(),
+  labelListVisibility: z.enum(["labelShow", "labelShowIfUnread", "labelHide"]).describe("Whether the label appears in the label list.").optional(),
+  color: z.strictObject({
+    textColor: z.string().describe("Hex text color.").optional(),
+    backgroundColor: z.string().describe("Hex background color.").optional()
+  }).describe("Gmail label color.").optional()
+}).describe("Gmail label.");
+var deleteLabelInput = z.strictObject({
+  labelId: z.string().min(1).describe("Gmail label ID."),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var deleteLabelOutput = z.strictObject({
+  success: z.boolean().describe("Whether the operation completed successfully.")
+}).describe("Operation result.");
+var addLabelToEmailInput = z.strictObject({
+  messageId: z.string().min(1).describe("Gmail message ID."),
+  addLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  removeLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var addLabelToEmailOutput = z.looseObject({
+  messageId: z.string().min(1).describe("Gmail message ID."),
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+  subject: z.string().describe("Message subject."),
+  sender: z.string().describe("Message sender."),
+  to: z.string().describe("Message recipients."),
+  messageTimestamp: z.string().describe("Message timestamp."),
+  preview: z.looseObject({}).describe("Gmail API object.").optional(),
+  payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+  messageText: z.string().describe("Extracted message body text.").optional(),
+  attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+  raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+}).describe("Normalized Gmail message.");
+var batchModifyMessagesInput = z.strictObject({
+  messageIds: z.array(z.string().min(1).describe("Gmail message ID.")).describe("Message IDs to modify."),
+  addLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  removeLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var batchModifyMessagesOutput = z.strictObject({
+  success: z.boolean().describe("Whether the operation completed successfully.")
+}).describe("Operation result.");
+var moveToTrashInput = z.strictObject({
+  messageId: z.string().min(1).describe("Gmail message ID."),
+  addLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  removeLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var moveToTrashOutput = z.looseObject({
+  messageId: z.string().min(1).describe("Gmail message ID."),
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+  subject: z.string().describe("Message subject."),
+  sender: z.string().describe("Message sender."),
+  to: z.string().describe("Message recipients."),
+  messageTimestamp: z.string().describe("Message timestamp."),
+  preview: z.looseObject({}).describe("Gmail API object.").optional(),
+  payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+  messageText: z.string().describe("Extracted message body text.").optional(),
+  attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+  raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+}).describe("Normalized Gmail message.");
+var untrashMessageInput = z.strictObject({
+  messageId: z.string().min(1).describe("Gmail message ID."),
+  addLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  removeLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var untrashMessageOutput = z.looseObject({
+  messageId: z.string().min(1).describe("Gmail message ID."),
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+  subject: z.string().describe("Message subject."),
+  sender: z.string().describe("Message sender."),
+  to: z.string().describe("Message recipients."),
+  messageTimestamp: z.string().describe("Message timestamp."),
+  preview: z.looseObject({}).describe("Gmail API object.").optional(),
+  payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+  messageText: z.string().describe("Extracted message body text.").optional(),
+  attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+  raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+}).describe("Normalized Gmail message.");
+var modifyThreadLabelsInput = z.strictObject({
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  addLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  removeLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var modifyThreadLabelsOutput = z.looseObject({
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  historyId: z.string().describe("Mailbox history checkpoint ID.").nullable().optional(),
+  snippet: z.string().describe("Thread snippet.").optional(),
+  messages: z.array(z.looseObject({
+    messageId: z.string().min(1).describe("Gmail message ID."),
+    threadId: z.string().min(1).describe("Gmail thread ID."),
+    labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+    subject: z.string().describe("Message subject."),
+    sender: z.string().describe("Message sender."),
+    to: z.string().describe("Message recipients."),
+    messageTimestamp: z.string().describe("Message timestamp."),
+    preview: z.looseObject({}).describe("Gmail API object.").optional(),
+    payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+    messageText: z.string().describe("Extracted message body text.").optional(),
+    attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+    raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+  }).describe("Normalized Gmail message.")).describe("Messages in the thread.").optional()
+}).describe("Gmail thread.");
+var moveThreadToTrashInput = z.strictObject({
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  addLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  removeLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var moveThreadToTrashOutput = z.looseObject({
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  historyId: z.string().describe("Mailbox history checkpoint ID.").nullable().optional(),
+  snippet: z.string().describe("Thread snippet.").optional(),
+  messages: z.array(z.looseObject({
+    messageId: z.string().min(1).describe("Gmail message ID."),
+    threadId: z.string().min(1).describe("Gmail thread ID."),
+    labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+    subject: z.string().describe("Message subject."),
+    sender: z.string().describe("Message sender."),
+    to: z.string().describe("Message recipients."),
+    messageTimestamp: z.string().describe("Message timestamp."),
+    preview: z.looseObject({}).describe("Gmail API object.").optional(),
+    payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+    messageText: z.string().describe("Extracted message body text.").optional(),
+    attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+    raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+  }).describe("Normalized Gmail message.")).describe("Messages in the thread.").optional()
+}).describe("Gmail thread.");
+var untrashThreadInput = z.strictObject({
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  addLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  removeLabelIds: z.array(z.string().min(1)).describe("Gmail label IDs.").optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var untrashThreadOutput = z.looseObject({
+  threadId: z.string().min(1).describe("Gmail thread ID."),
+  historyId: z.string().describe("Mailbox history checkpoint ID.").nullable().optional(),
+  snippet: z.string().describe("Thread snippet.").optional(),
+  messages: z.array(z.looseObject({
+    messageId: z.string().min(1).describe("Gmail message ID."),
+    threadId: z.string().min(1).describe("Gmail thread ID."),
+    labelIds: z.array(z.string().min(1)).describe("Gmail label IDs."),
+    subject: z.string().describe("Message subject."),
+    sender: z.string().describe("Message sender."),
+    to: z.string().describe("Message recipients."),
+    messageTimestamp: z.string().describe("Message timestamp."),
+    preview: z.looseObject({}).describe("Gmail API object.").optional(),
+    payload: z.looseObject({}).describe("Gmail API object.").nullable().optional(),
+    messageText: z.string().describe("Extracted message body text.").optional(),
+    attachmentList: z.array(z.looseObject({}).describe("Gmail API object.")).describe("Message attachments.").optional(),
+    raw: z.string().describe("Raw RFC 2822 message when requested.").optional()
+  }).describe("Normalized Gmail message.")).describe("Messages in the thread.").optional()
+}).describe("Gmail thread.");
+var listHistoryInput = z.strictObject({
+  startHistoryId: z.string().min(1).describe("History checkpoint."),
+  pageToken: z.string().describe("Opaque pagination token returned by Gmail.").optional(),
+  maxResults: z.int().min(1).max(500).describe("Maximum number of results to return.").optional(),
+  labelId: z.string().min(1).describe("Gmail label ID.").optional(),
+  historyTypes: z.array(z.string()).describe("History event types to include.").optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var listHistoryOutput = z.strictObject({
+  history: z.array(z.looseObject({}).describe("Gmail API object.")),
+  historyId: z.string(),
+  nextPageToken: z.string().describe("Opaque pagination token returned by Gmail.").nullable().optional()
+}).describe("Mailbox history result.");
+var listFiltersInput = z.strictObject({
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var listFiltersOutput = z.strictObject({
+  filters: z.array(z.looseObject({
+    id: z.string().min(1).describe("Gmail filter ID."),
+    criteria: z.looseObject({}).describe("Gmail API object.").optional(),
+    action: z.looseObject({}).describe("Gmail API object.").optional()
+  }).describe("Gmail filter."))
+}).describe("Filter list.");
+var getFilterInput = z.strictObject({
+  filterId: z.string().min(1).describe("Gmail filter ID."),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var getFilterOutput = z.looseObject({
+  id: z.string().min(1).describe("Gmail filter ID."),
+  criteria: z.looseObject({}).describe("Gmail API object.").optional(),
+  action: z.looseObject({}).describe("Gmail API object.").optional()
+}).describe("Gmail filter.");
+var createFilterInput = z.strictObject({
+  criteria: z.looseObject({}).describe("Gmail API object."),
+  action: z.looseObject({}).describe("Gmail API object."),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var createFilterOutput = z.looseObject({
+  id: z.string().min(1).describe("Gmail filter ID."),
+  criteria: z.looseObject({}).describe("Gmail API object.").optional(),
+  action: z.looseObject({}).describe("Gmail API object.").optional()
+}).describe("Gmail filter.");
+var deleteFilterInput = z.strictObject({
+  filterId: z.string().min(1).describe("Gmail filter ID."),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var deleteFilterOutput = z.strictObject({
+  success: z.boolean().describe("Whether the operation completed successfully.")
+}).describe("Operation result.");
+var getLanguageSettingsInput = z.strictObject({
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var getLanguageSettingsOutput = z.looseObject({}).describe("Gmail API object.");
+var updateLanguageSettingsInput = z.strictObject({
+  displayLanguage: z.string().min(1).describe("Language code."),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var updateLanguageSettingsOutput = z.looseObject({}).describe("Gmail API object.");
+var getVacationSettingsInput = z.strictObject({
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var getVacationSettingsOutput = z.looseObject({}).describe("Gmail API object.");
+var updateVacationSettingsInput = z.strictObject({
+  enableAutoReply: z.boolean().optional(),
+  responseSubject: z.string().optional(),
+  responseBodyPlainText: z.string().optional(),
+  responseBodyHtml: z.string().optional(),
+  restrictToContacts: z.boolean().optional(),
+  restrictToDomain: z.boolean().optional(),
+  startTime: z.string().optional(),
+  endTime: z.string().optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var updateVacationSettingsOutput = z.looseObject({}).describe("Gmail API object.");
+var getAutoForwardingInput = z.strictObject({
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var getAutoForwardingOutput = z.looseObject({}).describe("Gmail API object.");
+var listForwardingAddressesInput = z.strictObject({
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var listForwardingAddressesOutput = z.looseObject({}).describe("Gmail API object.");
+var settingsGetImapInput = z.strictObject({
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var settingsGetImapOutput = z.looseObject({}).describe("Gmail API object.");
+var settingsGetPopInput = z.strictObject({
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var settingsGetPopOutput = z.looseObject({}).describe("Gmail API object.");
+var stopWatchInput = z.strictObject({
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var stopWatchOutput = z.strictObject({
+  success: z.boolean().describe("Whether the operation completed successfully.")
+}).describe("Operation result.");
+var updateImapSettingsInput = z.strictObject({
+  enabled: z.boolean().optional(),
+  autoExpunge: z.boolean().optional(),
+  expungeBehavior: z.string().optional(),
+  maxFolderSize: z.int().optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var updateImapSettingsOutput = z.looseObject({}).describe("Gmail API object.");
+var updatePopSettingsInput = z.strictObject({
+  accessWindow: z.string().optional(),
+  disposition: z.string().optional(),
+  userId: z.string().describe("Gmail user ID. Omit to use the connected mailbox.").optional()
+}).describe("The input payload for this action.");
+var updatePopSettingsOutput = z.looseObject({}).describe("Gmail API object.");
+var gmailActions = {
+  search_threads: {
+    description: "Search Gmail threads by query and return lightweight thread summaries. Spam and trash stay excluded unless explicitly targeted in the query.",
+    effect: "read",
+    inputSchema: searchThreadsInput,
+    outputSchema: z.toJSONSchema(searchThreadsOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_threads: {
+    description: "List Gmail threads with optional query filtering and pagination.",
+    effect: "read",
+    inputSchema: listThreadsInput,
+    outputSchema: z.toJSONSchema(listThreadsOutput, { io: "output", unrepresentable: "any" })
+  },
+  fetch_emails: {
+    description: "List Gmail messages with optional query, label, and pagination filters. Use detail to choose IDs, summaries, or full messages.",
+    effect: "read",
+    inputSchema: fetchEmailsInput,
+    outputSchema: z.toJSONSchema(fetchEmailsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_message: {
+    description: "Get a Gmail message by message ID with a simplified normalized output.",
+    effect: "read",
+    inputSchema: getMessageInput,
+    outputSchema: z.toJSONSchema(getMessageOutput, { io: "output", unrepresentable: "any" })
+  },
+  fetch_message_by_message_id: {
+    description: "Fetch a Gmail message by message ID with a controllable response format.",
+    effect: "read",
+    inputSchema: fetchMessageByMessageIdInput,
+    outputSchema: z.toJSONSchema(fetchMessageByMessageIdOutput, { io: "output", unrepresentable: "any" })
+  },
+  fetch_message_by_thread_id: {
+    description: "Fetch all messages in a Gmail thread.",
+    effect: "read",
+    inputSchema: fetchMessageByThreadIdInput,
+    outputSchema: z.toJSONSchema(fetchMessageByThreadIdOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_profile: {
+    description: "Get the connected Gmail profile, including mailbox totals and the current historyId.",
+    effect: "read",
+    inputSchema: getProfileInput,
+    outputSchema: z.toJSONSchema(getProfileOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_email: {
+    description: "Send an email from the connected Gmail account.",
+    effect: "write",
+    inputSchema: sendEmailInput,
+    outputSchema: z.toJSONSchema(sendEmailOutput, { io: "output", unrepresentable: "any" })
+  },
+  reply_email: {
+    description: "Reply to an existing Gmail thread using the original message's reply headers.",
+    effect: "write",
+    inputSchema: replyEmailInput,
+    outputSchema: z.toJSONSchema(replyEmailOutput, { io: "output", unrepresentable: "any" })
+  },
+  reply_to_thread: {
+    description: "Reply to an existing Gmail thread while preserving Gmail threading.",
+    effect: "write",
+    inputSchema: replyToThreadInput,
+    outputSchema: z.toJSONSchema(replyToThreadOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_draft: {
+    description: "Create a Gmail draft with a simplified input and output shape.",
+    effect: "write",
+    inputSchema: createDraftInput,
+    outputSchema: z.toJSONSchema(createDraftOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_email_draft: {
+    description: "Create a Gmail draft with recipients, subject, body, and optional threading.",
+    effect: "write",
+    inputSchema: createEmailDraftInput,
+    outputSchema: z.toJSONSchema(createEmailDraftOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_drafts: {
+    description: "List Gmail drafts with pagination.",
+    effect: "read",
+    inputSchema: listDraftsInput,
+    outputSchema: z.toJSONSchema(listDraftsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_draft: {
+    description: "Get a Gmail draft by draft ID.",
+    effect: "read",
+    inputSchema: getDraftInput,
+    outputSchema: z.toJSONSchema(getDraftOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_draft: {
+    description: "Update an existing Gmail draft in place.",
+    effect: "write",
+    inputSchema: updateDraftInput,
+    outputSchema: z.toJSONSchema(updateDraftOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_draft: {
+    description: "Send an existing Gmail draft as-is.",
+    effect: "write",
+    inputSchema: sendDraftInput,
+    outputSchema: z.toJSONSchema(sendDraftOutput, { io: "output", unrepresentable: "any" })
+  },
+  delete_draft: {
+    description: "Permanently delete a Gmail draft by draft ID.",
+    effect: "destructive",
+    inputSchema: deleteDraftInput,
+    outputSchema: z.toJSONSchema(deleteDraftOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_labels: {
+    description: "List all system and user-created Gmail labels.",
+    effect: "read",
+    inputSchema: listLabelsInput,
+    outputSchema: z.toJSONSchema(listLabelsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_label: {
+    description: "Get details for a Gmail label.",
+    effect: "read",
+    inputSchema: getLabelInput,
+    outputSchema: z.toJSONSchema(getLabelOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_label: {
+    description: "Create a new Gmail label and return its internal label ID.",
+    effect: "write",
+    inputSchema: createLabelInput,
+    outputSchema: z.toJSONSchema(createLabelOutput, { io: "output", unrepresentable: "any" })
+  },
+  patch_label: {
+    description: "Patch a user-created Gmail label.",
+    effect: "write",
+    inputSchema: patchLabelInput,
+    outputSchema: z.toJSONSchema(patchLabelOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_label: {
+    description: "Update an existing Gmail label.",
+    effect: "write",
+    inputSchema: updateLabelInput,
+    outputSchema: z.toJSONSchema(updateLabelOutput, { io: "output", unrepresentable: "any" })
+  },
+  delete_label: {
+    description: "Permanently delete a user-created Gmail label.",
+    effect: "destructive",
+    inputSchema: deleteLabelInput,
+    outputSchema: z.toJSONSchema(deleteLabelOutput, { io: "output", unrepresentable: "any" })
+  },
+  add_label_to_email: {
+    description: "Add and/or remove labels on a single Gmail message.",
+    effect: "write",
+    inputSchema: addLabelToEmailInput,
+    outputSchema: z.toJSONSchema(addLabelToEmailOutput, { io: "output", unrepresentable: "any" })
+  },
+  batch_modify_messages: {
+    description: "Add and/or remove labels on up to 1,000 Gmail messages.",
+    effect: "write",
+    inputSchema: batchModifyMessagesInput,
+    outputSchema: z.toJSONSchema(batchModifyMessagesOutput, { io: "output", unrepresentable: "any" })
+  },
+  move_to_trash: {
+    description: "Move a Gmail message to trash.",
+    effect: "write",
+    inputSchema: moveToTrashInput,
+    outputSchema: z.toJSONSchema(moveToTrashOutput, { io: "output", unrepresentable: "any" })
+  },
+  untrash_message: {
+    description: "Restore a previously trashed Gmail message.",
+    effect: "write",
+    inputSchema: untrashMessageInput,
+    outputSchema: z.toJSONSchema(untrashMessageOutput, { io: "output", unrepresentable: "any" })
+  },
+  modify_thread_labels: {
+    description: "Add and/or remove labels on every message in a Gmail thread.",
+    effect: "write",
+    inputSchema: modifyThreadLabelsInput,
+    outputSchema: z.toJSONSchema(modifyThreadLabelsOutput, { io: "output", unrepresentable: "any" })
+  },
+  move_thread_to_trash: {
+    description: "Move an entire Gmail thread to trash.",
+    effect: "write",
+    inputSchema: moveThreadToTrashInput,
+    outputSchema: z.toJSONSchema(moveThreadToTrashOutput, { io: "output", unrepresentable: "any" })
+  },
+  untrash_thread: {
+    description: "Restore a previously trashed Gmail thread.",
+    effect: "write",
+    inputSchema: untrashThreadInput,
+    outputSchema: z.toJSONSchema(untrashThreadOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_history: {
+    description: "List Gmail mailbox change history after a known startHistoryId.",
+    effect: "read",
+    inputSchema: listHistoryInput,
+    outputSchema: z.toJSONSchema(listHistoryOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_filters: {
+    description: "List Gmail filters for the mailbox.",
+    effect: "read",
+    inputSchema: listFiltersInput,
+    outputSchema: z.toJSONSchema(listFiltersOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_filter: {
+    description: "Get a Gmail filter by filter ID.",
+    effect: "read",
+    inputSchema: getFilterInput,
+    outputSchema: z.toJSONSchema(getFilterOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_filter: {
+    description: "Create a Gmail filter with matching criteria and resulting actions.",
+    effect: "write",
+    inputSchema: createFilterInput,
+    outputSchema: z.toJSONSchema(createFilterOutput, { io: "output", unrepresentable: "any" })
+  },
+  delete_filter: {
+    description: "Permanently delete a Gmail filter by filter ID.",
+    effect: "destructive",
+    inputSchema: deleteFilterInput,
+    outputSchema: z.toJSONSchema(deleteFilterOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_language_settings: {
+    description: "Get the Gmail display language settings.",
+    effect: "read",
+    inputSchema: getLanguageSettingsInput,
+    outputSchema: z.toJSONSchema(getLanguageSettingsOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_language_settings: {
+    description: "Update the Gmail display language settings.",
+    effect: "write",
+    inputSchema: updateLanguageSettingsInput,
+    outputSchema: z.toJSONSchema(updateLanguageSettingsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_vacation_settings: {
+    description: "Get the Gmail vacation responder settings.",
+    effect: "read",
+    inputSchema: getVacationSettingsInput,
+    outputSchema: z.toJSONSchema(getVacationSettingsOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_vacation_settings: {
+    description: "Update the Gmail vacation responder settings.",
+    effect: "write",
+    inputSchema: updateVacationSettingsInput,
+    outputSchema: z.toJSONSchema(updateVacationSettingsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_auto_forwarding: {
+    description: "Get the current Gmail auto-forwarding configuration.",
+    effect: "read",
+    inputSchema: getAutoForwardingInput,
+    outputSchema: z.toJSONSchema(getAutoForwardingOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_forwarding_addresses: {
+    description: "List registered forwarding addresses.",
+    effect: "read",
+    inputSchema: listForwardingAddressesInput,
+    outputSchema: z.toJSONSchema(listForwardingAddressesOutput, { io: "output", unrepresentable: "any" })
+  },
+  settings_get_imap: {
+    description: "Get the Gmail IMAP settings.",
+    effect: "write",
+    inputSchema: settingsGetImapInput,
+    outputSchema: z.toJSONSchema(settingsGetImapOutput, { io: "output", unrepresentable: "any" })
+  },
+  settings_get_pop: {
+    description: "Get the Gmail POP settings.",
+    effect: "write",
+    inputSchema: settingsGetPopInput,
+    outputSchema: z.toJSONSchema(settingsGetPopOutput, { io: "output", unrepresentable: "any" })
+  },
+  stop_watch: {
+    description: "Stop Gmail push watch notifications for the mailbox.",
+    effect: "write",
+    inputSchema: stopWatchInput,
+    outputSchema: z.toJSONSchema(stopWatchOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_imap_settings: {
+    description: "Update the Gmail IMAP settings.",
+    effect: "write",
+    inputSchema: updateImapSettingsInput,
+    outputSchema: z.toJSONSchema(updateImapSettingsOutput, { io: "output", unrepresentable: "any" })
+  },
+  update_pop_settings: {
+    description: "Update the Gmail POP settings.",
+    effect: "write",
+    inputSchema: updatePopSettingsInput,
+    outputSchema: z.toJSONSchema(updatePopSettingsOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/gmail/index.ts
+function createGmailPlugin() {
+  return createProviderPlugin({
+    description: "Gmail",
+    actions: gmailActions,
+    oauth: {
+      authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth",
+      tokenUrl: "https://oauth2.googleapis.com/token",
+      scopes: [
+        "https://www.googleapis.com/auth/gmail.readonly",
+        "https://www.googleapis.com/auth/gmail.modify",
+        "https://www.googleapis.com/auth/gmail.compose",
+        "https://www.googleapis.com/auth/gmail.send",
+        "https://www.googleapis.com/auth/gmail.labels",
+        "https://www.googleapis.com/auth/gmail.settings.basic"
+      ],
+      clientAuth: "client_secret_post",
+      authorizationParams: { access_type: "offline", prompt: "consent" }
+    },
+    handlers: {
+      search_threads: searchThreads,
+      list_threads: listThreadsAction,
+      fetch_emails: fetchEmails,
+      get_message: getMessage,
+      fetch_message_by_message_id: fetchMessageByMessageId,
+      fetch_message_by_thread_id: fetchMessageByThreadId,
+      get_profile: getProfile,
+      send_email: sendEmail,
+      reply_email: replyEmail,
+      reply_to_thread: replyToThread,
+      create_draft: createDraft,
+      create_email_draft: createEmailDraft,
+      list_drafts: listDrafts,
+      get_draft: getDraft,
+      update_draft: updateDraft,
+      send_draft: sendDraft,
+      delete_draft: deleteDraft,
+      list_labels: listLabels,
+      get_label: getLabel,
+      create_label: createLabel,
+      patch_label: patchLabel,
+      update_label: updateLabel,
+      delete_label: deleteLabel,
+      add_label_to_email: addLabelToEmail,
+      batch_modify_messages: batchModifyMessages,
+      move_to_trash: moveToTrash,
+      untrash_message: untrashMessage,
+      modify_thread_labels: modifyThreadLabels,
+      move_thread_to_trash: moveThreadToTrash,
+      untrash_thread: untrashThread,
+      list_history: listHistory,
+      list_filters: listFilters,
+      get_filter: getFilter,
+      create_filter: createFilter,
+      delete_filter: deleteFilter,
+      get_language_settings: getLanguageSettings,
+      update_language_settings: updateLanguageSettings,
+      get_vacation_settings: getVacationSettings,
+      update_vacation_settings: updateVacationSettings,
+      get_auto_forwarding: getAutoForwarding,
+      list_forwarding_addresses: listForwardingAddresses,
+      settings_get_imap: settingsGetImap,
+      update_imap_settings: updateImapSettings,
+      settings_get_pop: settingsGetPop,
+      update_pop_settings: updatePopSettings,
+      stop_watch: stopWatch
+    }
+  });
+}
+var gmail_default = createGmailPlugin();
+export {
+  createGmailPlugin,
+  gmail_default as default
+};