@elizaos/plugin-google 2.0.0-beta.1 → 2.0.3-beta.3

package/dist/gmail.js

@@ -1,765 +0,0 @@
-const MESSAGE_METADATA_HEADERS = ["Subject", "From", "To", "Date"];
-const GMAIL_METADATA_HEADERS = [
-    "Subject",
-    "From",
-    "To",
-    "Cc",
-    "Date",
-    "Reply-To",
-    "Message-Id",
-    "References",
-    "List-Unsubscribe",
-    "List-Unsubscribe-Post",
-    "List-Id",
-    "Precedence",
-    "Auto-Submitted",
-];
-const SUBSCRIPTION_SCAN_QUERY_DEFAULT = "(category:promotions OR category:updates OR list:* OR unsubscribe) newer_than:180d";
-const GMAIL_LIST_PAGE_SIZE = 500;
-const GMAIL_METADATA_CONCURRENCY = 25;
-const MAX_GMAIL_RESULTS = 1000;
-export class GoogleGmailClient {
-    clientFactory;
-    constructor(clientFactory) {
-        this.clientFactory = clientFactory;
-    }
-    async searchMessages(params) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.read"], "gmail.searchMessages");
-        const response = await gmail.users.messages.list({
-            userId: "me",
-            q: params.query,
-            maxResults: params.limit ?? 10,
-        });
-        const messages = response.data.messages ?? [];
-        return Promise.all(messages
-            .filter((message) => message.id)
-            .map((message) => this.getMessageWithClient(gmail, {
-            accountId: params.accountId,
-            messageId: message.id,
-            includeBody: false,
-        })));
-    }
-    async getMessage(params) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.read"], "gmail.getMessage");
-        return this.getMessageWithClient(gmail, params);
-    }
-    async sendEmail(params) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.send"], "gmail.sendEmail");
-        const raw = encodeMessage(params);
-        const response = await gmail.users.messages.send({
-            userId: "me",
-            requestBody: {
-                raw,
-                threadId: params.threadId,
-            },
-        });
-        return {
-            id: response.data.id ?? "",
-            threadId: response.data.threadId ?? undefined,
-        };
-    }
-    async listGmailTriageMessages(params) {
-        return this.searchGmailMessages({
-            accountId: params.accountId,
-            selfEmail: params.selfEmail,
-            maxResults: params.maxResults,
-            query: "in:inbox",
-        });
-    }
-    async searchGmailMessages(params) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.read"], "gmail.searchGmailMessages");
-        const maxResults = normalizedLimit(params.maxResults, 20, MAX_GMAIL_RESULTS);
-        const messages = [];
-        let pageToken;
-        while (messages.length < maxResults) {
-            const response = await gmail.users.messages.list({
-                userId: "me",
-                q: params.query,
-                includeSpamTrash: params.includeSpamTrash === true,
-                maxResults: Math.min(GMAIL_LIST_PAGE_SIZE, maxResults - messages.length),
-                pageToken,
-            });
-            const pageMessages = await mapWithConcurrency(response.data.messages ?? [], GMAIL_METADATA_CONCURRENCY, async (messageRef) => {
-                const messageId = messageRef.id?.trim();
-                if (!messageId) {
-                    return null;
-                }
-                return this.getRichMessageWithClient(gmail, {
-                    accountId: params.accountId,
-                    messageId,
-                    selfEmail: params.selfEmail,
-                });
-            });
-            for (const message of pageMessages) {
-                if (message) {
-                    messages.push(message);
-                }
-            }
-            const nextPageToken = response.data.nextPageToken?.trim();
-            if (!nextPageToken || nextPageToken === pageToken) {
-                break;
-            }
-            pageToken = nextPageToken;
-        }
-        return sortGmailMessages(messages).slice(0, maxResults);
-    }
-    async getGmailMessage(params) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.read"], "gmail.getGmailMessage");
-        return this.getRichMessageWithClient(gmail, params);
-    }
-    async getGmailMessageDetail(params) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.read"], "gmail.getGmailMessageDetail");
-        const response = await gmail.users.messages.get({
-            userId: "me",
-            id: params.messageId,
-            format: "full",
-        });
-        const message = mapRichMessage(response.data, params.selfEmail ?? null);
-        if (!message) {
-            return null;
-        }
-        return {
-            message,
-            bodyText: extractGoogleGmailBody(response.data.payload).trim() || message.snippet,
-        };
-    }
-    async getGmailThread(params) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.read"], "gmail.getGmailThread");
-        const response = await gmail.users.threads.get({
-            userId: "me",
-            id: params.threadId,
-            format: "metadata",
-            metadataHeaders: [...GMAIL_METADATA_HEADERS],
-        });
-        return (response.data.messages ?? [])
-            .map((message) => mapRichMessage(message, params.selfEmail ?? null))
-            .filter((message) => message !== null)
-            .sort((left, right) => Date.parse(left.receivedAt) - Date.parse(right.receivedAt));
-    }
-    async listGmailUnrespondedThreads(params) {
-        const olderThanDays = normalizedLimit(params.olderThanDays, 3, 3650);
-        const maxResults = normalizedLimit(params.maxResults, 20, 50);
-        const selfEmail = params.selfEmail?.trim().toLowerCase() || null;
-        const sentCandidates = await this.searchGmailMessages({
-            accountId: params.accountId,
-            selfEmail,
-            maxResults: Math.min(Math.max(maxResults * 5, maxResults), 250),
-            query: `in:sent older_than:${olderThanDays}d`,
-        });
-        const seenThreads = new Set();
-        const threads = [];
-        const now = params.now ?? new Date();
-        for (const sentMessage of sentCandidates) {
-            if (seenThreads.has(sentMessage.threadId)) {
-                continue;
-            }
-            seenThreads.add(sentMessage.threadId);
-            const threadMessages = await this.getGmailThread({
-                accountId: params.accountId,
-                selfEmail,
-                threadId: sentMessage.threadId,
-            });
-            const humanMessages = threadMessages.filter((message) => !isAutomatedMessage(message));
-            const lastOutbound = [...humanMessages]
-                .reverse()
-                .find((message) => isMessageFromSelf(message, selfEmail));
-            if (!lastOutbound) {
-                continue;
-            }
-            const lastOutboundAtMs = Date.parse(lastOutbound.receivedAt);
-            if (!Number.isFinite(lastOutboundAtMs)) {
-                continue;
-            }
-            const hasLaterInbound = humanMessages.some((message) => !isMessageFromSelf(message, selfEmail) &&
-                Date.parse(message.receivedAt) > lastOutboundAtMs);
-            if (hasLaterInbound) {
-                continue;
-            }
-            const ageMs = now.getTime() - lastOutboundAtMs;
-            if (ageMs < olderThanDays * 24 * 60 * 60 * 1000) {
-                continue;
-            }
-            const lastInbound = [...humanMessages]
-                .reverse()
-                .find((message) => !isMessageFromSelf(message, selfEmail));
-            threads.push({
-                threadId: lastOutbound.threadId,
-                externalMessageId: lastOutbound.externalId,
-                subject: lastOutbound.subject,
-                to: lastOutbound.to,
-                cc: lastOutbound.cc,
-                lastOutboundAt: lastOutbound.receivedAt,
-                lastInboundAt: lastInbound?.receivedAt ?? null,
-                daysWaiting: Math.max(0, Math.floor(ageMs / (24 * 60 * 60 * 1000))),
-                snippet: lastOutbound.snippet,
-                labels: lastOutbound.labels,
-                htmlLink: lastOutbound.htmlLink,
-            });
-        }
-        return threads.sort((left, right) => right.daysWaiting - left.daysWaiting).slice(0, maxResults);
-    }
-    async modifyGmailMessages(params) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.manage"], "gmail.modifyMessages");
-        const ids = params.messageIds.map((messageId) => messageId.trim()).filter(Boolean);
-        if (ids.length === 0) {
-            throw new Error("Gmail operation requires message ids");
-        }
-        const labelIds = requireLabelIdsForOperation(params.operation, params.labelIds);
-        if (params.operation === "trash") {
-            await Promise.all(ids.map((id) => gmail.users.messages.trash({ userId: "me", id }).then(() => undefined)));
-            return;
-        }
-        if (params.operation === "delete") {
-            await gmail.users.messages.batchDelete({
-                userId: "me",
-                requestBody: { ids },
-            });
-            return;
-        }
-        const labelPatch = labelsForOperation(params.operation, labelIds);
-        await gmail.users.messages.batchModify({
-            userId: "me",
-            requestBody: {
-                ids,
-                addLabelIds: labelPatch.addLabelIds,
-                removeLabelIds: labelPatch.removeLabelIds,
-            },
-        });
-    }
-    async sendGmailReply(params) {
-        const raw = encodeRawGmailMessage([
-            `To: ${params.to.join(", ")}`,
-            ...(params.cc && params.cc.length > 0 ? [`Cc: ${params.cc.join(", ")}`] : []),
-            `Subject: ${normalizeReplySubject(params.subject)}`,
-            "MIME-Version: 1.0",
-            "Content-Type: text/plain; charset=UTF-8",
-            ...(params.inReplyTo ? [`In-Reply-To: ${params.inReplyTo}`] : []),
-            ...(params.references ? [`References: ${params.references}`] : []),
-            "",
-            params.bodyText.replace(/\r?\n/g, "\r\n"),
-        ]);
-        return this.sendRawGmailMessage(params, raw, "gmail.sendGmailReply");
-    }
-    async sendGmailMessage(params) {
-        const raw = encodeRawGmailMessage([
-            `To: ${params.to.join(", ")}`,
-            ...(params.cc && params.cc.length > 0 ? [`Cc: ${params.cc.join(", ")}`] : []),
-            ...(params.bcc && params.bcc.length > 0 ? [`Bcc: ${params.bcc.join(", ")}`] : []),
-            `Subject: ${params.subject.trim() || "(no subject)"}`,
-            "MIME-Version: 1.0",
-            "Content-Type: text/plain; charset=UTF-8",
-            "",
-            params.bodyText.replace(/\r?\n/g, "\r\n"),
-        ]);
-        return this.sendRawGmailMessage(params, raw, "gmail.sendGmailMessage");
-    }
-    async getGmailSubscriptionHeaders(params) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.read"], "gmail.getSubscriptionHeaders");
-        const query = params.query?.trim() || SUBSCRIPTION_SCAN_QUERY_DEFAULT;
-        const maxMessages = normalizedLimit(params.maxMessages, 200, MAX_GMAIL_RESULTS);
-        const results = [];
-        let pageToken;
-        while (results.length < maxMessages) {
-            const response = await gmail.users.messages.list({
-                userId: "me",
-                q: query,
-                includeSpamTrash: false,
-                maxResults: Math.min(100, maxMessages - results.length),
-                pageToken,
-            });
-            const batch = await mapWithConcurrency(response.data.messages ?? [], GMAIL_METADATA_CONCURRENCY, async (messageRef) => {
-                const messageId = messageRef.id?.trim();
-                if (!messageId) {
-                    return null;
-                }
-                const rich = await this.getRichMessageWithClient(gmail, {
-                    accountId: params.accountId,
-                    messageId,
-                });
-                return rich ? mapSubscriptionHeaders(rich) : null;
-            });
-            for (const headers of batch) {
-                if (headers) {
-                    results.push(headers);
-                }
-            }
-            const nextPageToken = response.data.nextPageToken?.trim();
-            if (!nextPageToken || nextPageToken === pageToken) {
-                break;
-            }
-            pageToken = nextPageToken;
-        }
-        return results;
-    }
-    async createGmailFilterForSender(params) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.manage"], "gmail.createFilterForSender");
-        const response = await gmail.users.settings.filters.create({
-            userId: "me",
-            requestBody: {
-                criteria: { from: params.fromAddress },
-                action: params.trash
-                    ? { removeLabelIds: ["INBOX"], addLabelIds: ["TRASH"] }
-                    : { addLabelIds: ["TRASH"], removeLabelIds: ["INBOX", "UNREAD"] },
-            },
-        });
-        return {
-            filterId: response.data.id ?? null,
-            trashed: true,
-        };
-    }
-    async trashGmailThread(params) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.manage"], "gmail.trashThread");
-        await gmail.users.threads.trash({
-            userId: "me",
-            id: params.threadId,
-        });
-    }
-    async modifyGmailMessageLabels(params) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.manage"], "gmail.modifyMessageLabels");
-        await gmail.users.messages.modify({
-            userId: "me",
-            id: params.messageId,
-            requestBody: {
-                addLabelIds: params.addLabelIds ?? [],
-                removeLabelIds: params.removeLabelIds ?? [],
-            },
-        });
-    }
-    async sendMailtoUnsubscribeEmail(params) {
-        await this.sendGmailMessage({
-            accountId: params.accountId,
-            to: [params.mailto.recipient],
-            subject: params.mailto.subject ?? "unsubscribe",
-            bodyText: params.mailto.body ?? "unsubscribe",
-        });
-    }
-    async getMessageWithClient(gmail, params) {
-        const response = await gmail.users.messages.get({
-            userId: "me",
-            id: params.messageId,
-            format: params.includeBody ? "full" : "metadata",
-            metadataHeaders: MESSAGE_METADATA_HEADERS,
-        });
-        return mapMessage(response.data, Boolean(params.includeBody));
-    }
-    async getRichMessageWithClient(gmail, params) {
-        try {
-            const response = await gmail.users.messages.get({
-                userId: "me",
-                id: params.messageId,
-                format: "metadata",
-                metadataHeaders: [...GMAIL_METADATA_HEADERS],
-            });
-            return mapRichMessage(response.data, params.selfEmail ?? null);
-        }
-        catch (error) {
-            if (googleErrorStatus(error) === 404) {
-                return null;
-            }
-            throw error;
-        }
-    }
-    async sendRawGmailMessage(params, raw, reason) {
-        const gmail = await this.clientFactory.gmail(params, ["gmail.send"], reason);
-        const response = await gmail.users.messages.send({
-            userId: "me",
-            requestBody: { raw },
-        });
-        return {
-            messageId: response.data.id ?? null,
-            threadId: response.data.threadId ?? null,
-            labelIds: response.data.labelIds ?? [],
-        };
-    }
-}
-function mapMessage(message, includeBody) {
-    const headers = message.payload?.headers ?? [];
-    const dateHeader = headerValue(headers, "Date");
-    const body = includeBody ? collectMessageBody(message.payload) : {};
-    const headerMap = Object.fromEntries(headers
-        .map((header) => [header.name?.trim() ?? "", header.value?.trim() ?? ""])
-        .filter(([name, value]) => name.length > 0 && value.length > 0));
-    return {
-        id: message.id ?? "",
-        threadId: message.threadId ?? undefined,
-        subject: headerValue(headers, "Subject"),
-        from: parseEmailAddresses(headerValue(headers, "From"))[0],
-        replyTo: parseEmailAddresses(headerValue(headers, "Reply-To"))[0],
-        to: parseEmailAddresses(headerValue(headers, "To")),
-        cc: parseEmailAddresses(headerValue(headers, "Cc")),
-        snippet: message.snippet ?? undefined,
-        receivedAt: dateHeader ? new Date(dateHeader).toISOString() : undefined,
-        labelIds: message.labelIds ?? undefined,
-        headers: headerMap,
-        ...body,
-    };
-}
-function mapRichMessage(message, selfEmail) {
-    const externalId = message.id?.trim();
-    const threadId = message.threadId?.trim();
-    if (!externalId || !threadId) {
-        return null;
-    }
-    const headers = message.payload?.headers ?? [];
-    const subject = decodeHtmlEntities(headerValue(headers, "Subject") || "") || "(no subject)";
-    const from = parseMailbox(headerValue(headers, "From") || "Unknown sender");
-    const replyTo = headerValue(headers, "Reply-To");
-    const replyToMailbox = replyTo ? parseMailbox(replyTo) : null;
-    const to = parseEmailAddresses(headerValue(headers, "To")).map(formatAddressValue);
-    const cc = parseEmailAddresses(headerValue(headers, "Cc")).map(formatAddressValue);
-    const labels = (message.labelIds ?? []).map((label) => label.trim()).filter(Boolean);
-    const receivedAt = internalDateToIso(message.internalDate);
-    const precedence = headerValue(headers, "Precedence");
-    const listId = headerValue(headers, "List-Id");
-    const autoSubmitted = headerValue(headers, "Auto-Submitted");
-    const triage = classifyReplyNeed({
-        labels,
-        fromEmail: from.email,
-        to,
-        cc,
-        selfEmail,
-        precedence,
-        listId,
-        autoSubmitted,
-    });
-    return {
-        externalId,
-        threadId,
-        subject,
-        from: from.name || from.email || "Unknown sender",
-        fromEmail: from.email ? from.email.toLowerCase() : null,
-        replyTo: replyToMailbox?.email ?? replyToMailbox?.name ?? null,
-        to,
-        cc,
-        snippet: normalizeSnippet(message.snippet),
-        receivedAt,
-        isUnread: labels.includes("UNREAD"),
-        isImportant: triage.isImportant,
-        likelyReplyNeeded: triage.likelyReplyNeeded,
-        triageScore: triage.triageScore,
-        triageReason: triage.triageReason,
-        labels,
-        htmlLink: deriveHtmlLink(threadId, selfEmail),
-        metadata: {
-            historyId: message.historyId?.trim() || null,
-            sizeEstimate: typeof message.sizeEstimate === "number" ? message.sizeEstimate : null,
-            dateHeader: headerValue(headers, "Date") || null,
-            messageIdHeader: headerValue(headers, "Message-Id") || null,
-            referencesHeader: headerValue(headers, "References") || null,
-            listUnsubscribe: headerValue(headers, "List-Unsubscribe") || null,
-            listUnsubscribePost: headerValue(headers, "List-Unsubscribe-Post") || null,
-            listId: listId || null,
-            precedence: precedence || null,
-            autoSubmitted: autoSubmitted || null,
-        },
-    };
-}
-function headerValue(headers, name) {
-    return (headers.find((header) => header.name?.toLowerCase() === name.toLowerCase())?.value ?? undefined);
-}
-function parseEmailAddresses(value) {
-    if (!value) {
-        return [];
-    }
-    return value
-        .split(",")
-        .map((part) => part.trim())
-        .filter(Boolean)
-        .map((part) => {
-        const match = part.match(/^(?:"?([^"<]*)"?\s*)?<([^>]+)>$/);
-        if (!match) {
-            return { email: part };
-        }
-        return {
-            name: match[1]?.trim() || undefined,
-            email: match[2].trim(),
-        };
-    });
-}
-function collectMessageBody(part) {
-    if (!part) {
-        return {};
-    }
-    const body = {};
-    collectMessagePart(part, body);
-    return body;
-}
-function collectMessagePart(part, body) {
-    const data = part.body?.data ? decodeBase64Url(part.body.data) : undefined;
-    if (data && part.mimeType === "text/plain" && !body.bodyText) {
-        body.bodyText = data;
-    }
-    if (data && part.mimeType === "text/html" && !body.bodyHtml) {
-        body.bodyHtml = data;
-    }
-    for (const child of part.parts ?? []) {
-        collectMessagePart(child, body);
-    }
-}
-function encodeMessage(input) {
-    const headers = [
-        `To: ${formatEmailAddresses(input.to)}`,
-        input.cc?.length ? `Cc: ${formatEmailAddresses(input.cc)}` : undefined,
-        input.bcc?.length ? `Bcc: ${formatEmailAddresses(input.bcc)}` : undefined,
-        `Subject: ${input.subject}`,
-        "MIME-Version: 1.0",
-    ].filter(Boolean);
-    const contentType = input.html ? "text/html; charset=utf-8" : "text/plain; charset=utf-8";
-    const body = input.html ?? input.text ?? "";
-    const message = [...headers, `Content-Type: ${contentType}`, "", body].join("\r\n");
-    return Buffer.from(message).toString("base64url");
-}
-function formatEmailAddresses(addresses) {
-    return addresses
-        .map((address) => (address.name ? `"${address.name}" <${address.email}>` : address.email))
-        .join(", ");
-}
-function decodeBase64Url(value) {
-    return Buffer.from(value, "base64url").toString("utf8");
-}
-function normalizedLimit(value, fallback, max) {
-    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-        return fallback;
-    }
-    return Math.min(Math.trunc(value), max);
-}
-async function mapWithConcurrency(items, concurrency, mapper) {
-    if (items.length === 0) {
-        return [];
-    }
-    const results = new Array(items.length);
-    let cursor = 0;
-    const workerCount = Math.min(Math.max(1, concurrency), items.length);
-    const workers = Array.from({ length: workerCount }, async () => {
-        while (true) {
-            const index = cursor;
-            cursor += 1;
-            if (index >= items.length) {
-                return;
-            }
-            results[index] = await mapper(items[index]);
-        }
-    });
-    await Promise.all(workers);
-    return results;
-}
-function sortGmailMessages(messages) {
-    return [...messages].sort((left, right) => {
-        if (left.isImportant !== right.isImportant) {
-            return right.isImportant ? 1 : -1;
-        }
-        if (left.likelyReplyNeeded !== right.likelyReplyNeeded) {
-            return right.likelyReplyNeeded ? 1 : -1;
-        }
-        if (left.isUnread !== right.isUnread) {
-            return right.isUnread ? 1 : -1;
-        }
-        return Date.parse(right.receivedAt) - Date.parse(left.receivedAt);
-    });
-}
-function parseMailbox(value) {
-    const trimmed = value.trim();
-    const match = trimmed.match(/^(.*?)(?:<([^>]+)>)$/);
-    if (match) {
-        const name = (match[1] ?? "").trim().replace(/^"|"$/g, "");
-        const email = (match[2] ?? "").trim();
-        return { name: name || undefined, email };
-    }
-    return { email: trimmed };
-}
-function formatAddressValue(address) {
-    return address.email || address.name || "";
-}
-function normalizeSnippet(value) {
-    return decodeHtmlEntities(value ?? "")
-        .replace(/\s+/g, " ")
-        .trim();
-}
-function decodeHtmlEntities(value) {
-    return value
-        .replace(/&nbsp;/gi, " ")
-        .replace(/&lt;/gi, "<")
-        .replace(/&gt;/gi, ">")
-        .replace(/&quot;/gi, '"')
-        .replace(/&#39;/gi, "'")
-        .replace(/&amp;/gi, "&");
-}
-function internalDateToIso(value) {
-    const ms = value ? Number(value) : Number.NaN;
-    return Number.isFinite(ms) ? new Date(ms).toISOString() : new Date().toISOString();
-}
-function deriveHtmlLink(threadId, accountEmail) {
-    const accountSegment = accountEmail && accountEmail.trim().length > 0
-        ? encodeURIComponent(accountEmail.trim().toLowerCase())
-        : "0";
-    return `https://mail.google.com/mail/u/${accountSegment}/#all/${encodeURIComponent(threadId)}`;
-}
-function classifyReplyNeed(args) {
-    const labels = new Set(args.labels.map((label) => label.trim().toUpperCase()));
-    const isUnread = labels.has("UNREAD");
-    const explicitlyImportant = labels.has("IMPORTANT");
-    const selfEmail = args.selfEmail?.trim().toLowerCase() || null;
-    const fromEmail = args.fromEmail?.trim().toLowerCase() || null;
-    const directRecipients = [...args.to, ...args.cc].map((entry) => entry.trim().toLowerCase());
-    const directlyAddressed = selfEmail ? directRecipients.includes(selfEmail) : false;
-    const fromSelf = Boolean(selfEmail && fromEmail && selfEmail === fromEmail);
-    const precedence = args.precedence?.trim().toLowerCase();
-    const autoSubmitted = args.autoSubmitted?.trim().toLowerCase();
-    const automated = Boolean(args.listId) ||
-        precedence === "bulk" ||
-        precedence === "list" ||
-        precedence === "junk" ||
-        precedence === "auto-reply" ||
-        (autoSubmitted !== undefined && autoSubmitted !== "no");
-    const likelyReplyNeeded = !automated && !fromSelf && isUnread && directlyAddressed;
-    const isImportant = explicitlyImportant || likelyReplyNeeded;
-    const triageSignals = [
-        explicitlyImportant ? "gmail-important-label" : null,
-        likelyReplyNeeded ? "direct-unread-reply-needed" : null,
-        isUnread ? "unread" : null,
-        automated ? "automated-header" : null,
-        fromSelf ? "sent-by-self" : null,
-    ].filter((signal) => Boolean(signal));
-    return {
-        likelyReplyNeeded,
-        isImportant,
-        triageScore: isImportant ? 2 : isUnread ? 1 : 0,
-        triageReason: triageSignals.join(", ") || "recent inbox message",
-    };
-}
-function isMessageFromSelf(message, selfEmail) {
-    const labels = new Set(message.labels.map((label) => label.toUpperCase()));
-    if (labels.has("SENT")) {
-        return true;
-    }
-    const fromEmail = message.fromEmail?.trim().toLowerCase() || null;
-    return Boolean(selfEmail && fromEmail && fromEmail === selfEmail);
-}
-function isAutomatedMessage(message) {
-    const precedence = typeof message.metadata.precedence === "string"
-        ? message.metadata.precedence.trim().toLowerCase()
-        : "";
-    const autoSubmitted = typeof message.metadata.autoSubmitted === "string"
-        ? message.metadata.autoSubmitted.trim().toLowerCase()
-        : "";
-    return (Boolean(message.metadata.listId) ||
-        precedence === "bulk" ||
-        precedence === "list" ||
-        precedence === "junk" ||
-        precedence === "auto-reply" ||
-        (autoSubmitted.length > 0 && autoSubmitted !== "no"));
-}
-function requireLabelIdsForOperation(operation, labelIds) {
-    const labels = (labelIds ?? []).map((labelId) => labelId.trim()).filter(Boolean);
-    if ((operation === "apply_label" || operation === "remove_label") && labels.length === 0) {
-        throw new Error(`${operation} requires at least one labelId`);
-    }
-    return labels;
-}
-function labelsForOperation(operation, labelIds) {
-    const labels = {
-        archive: { removeLabelIds: ["INBOX"] },
-        trash: {},
-        delete: {},
-        report_spam: { addLabelIds: ["SPAM"], removeLabelIds: ["INBOX"] },
-        mark_read: { removeLabelIds: ["UNREAD"] },
-        mark_unread: { addLabelIds: ["UNREAD"] },
-        apply_label: { addLabelIds: labelIds },
-        remove_label: { removeLabelIds: labelIds },
-    };
-    return labels[operation];
-}
-function normalizeReplySubject(subject) {
-    const trimmed = subject.trim();
-    if (trimmed.length === 0) {
-        return "Re: your message";
-    }
-    return /^re:/i.test(trimmed) ? trimmed : `Re: ${trimmed}`;
-}
-function encodeRawGmailMessage(lines) {
-    return Buffer.from(lines.join("\r\n"), "utf-8").toString("base64url");
-}
-function extractGoogleGmailBody(payload) {
-    const plainText = extractGoogleGmailBodyByMime(payload, "text/plain");
-    if (plainText) {
-        return plainText;
-    }
-    const htmlText = extractGoogleGmailBodyByMime(payload, "text/html");
-    if (htmlText) {
-        return htmlText;
-    }
-    const directBody = payload?.body?.data;
-    if (typeof directBody === "string") {
-        const decoded = decodeBase64Url(directBody);
-        return payload?.mimeType === "text/html" ? htmlToPlainText(decoded) : decoded.trim();
-    }
-    return "";
-}
-function extractGoogleGmailBodyByMime(payload, mimeType) {
-    if (!payload) {
-        return "";
-    }
-    const directBody = payload.body?.data;
-    if (payload.mimeType === mimeType && typeof directBody === "string") {
-        const decoded = decodeBase64Url(directBody);
-        return mimeType === "text/html" ? htmlToPlainText(decoded) : decoded.trim();
-    }
-    for (const part of payload.parts ?? []) {
-        const nested = extractGoogleGmailBodyByMime(part, mimeType);
-        if (nested) {
-            return nested;
-        }
-    }
-    return "";
-}
-function htmlToPlainText(value) {
-    return decodeHtmlEntities(value
-        .replace(/<style\b[^>]*>[\s\S]*?<\/style\b[^>]*>/gi, " ")
-        .replace(/<script\b[^>]*>[\s\S]*?<\/script\b[^>]*>/gi, " ")
-        .replace(/<br\s*\/?>/gi, "\n")
-        .replace(/<\/(?:p|div|section|article|li|tr|table|h[1-6])>/gi, "\n")
-        .replace(/<(?:li)[^>]*>/gi, "- ")
-        .replace(/<[^>]+>/g, " "))
-        .replace(/\r/g, "")
-        .replace(/[ \t]+\n/g, "\n")
-        .replace(/\n{3,}/g, "\n\n")
-        .replace(/[ \t]{2,}/g, " ")
-        .trim();
-}
-function mapSubscriptionHeaders(message) {
-    const listUnsubscribe = typeof message.metadata.listUnsubscribe === "string" ? message.metadata.listUnsubscribe : null;
-    const listUnsubscribePost = typeof message.metadata.listUnsubscribePost === "string"
-        ? message.metadata.listUnsubscribePost
-        : null;
-    const listId = typeof message.metadata.listId === "string" ? message.metadata.listId : null;
-    return {
-        messageId: message.externalId,
-        threadId: message.threadId,
-        receivedAt: message.receivedAt,
-        subject: message.subject,
-        fromDisplay: message.from,
-        fromEmail: message.fromEmail,
-        listId,
-        listUnsubscribe,
-        listUnsubscribePost,
-        snippet: message.snippet,
-        labels: message.labels,
-    };
-}
-function googleErrorStatus(error) {
-    if (typeof error !== "object" || error === null) {
-        return undefined;
-    }
-    const candidate = error;
-    if (typeof candidate.code === "number") {
-        return candidate.code;
-    }
-    if (typeof candidate.status === "number") {
-        return candidate.status;
-    }
-    if (typeof candidate.response?.status === "number") {
-        return candidate.response.status;
-    }
-    return undefined;
-}
-//# sourceMappingURL=gmail.js.map