@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/gmail/executors.js

@@ -1,10 +1,15 @@
-import { looseArray, optionalRecord, optionalString } from "../../core/cast.js";
+import { format as schemaFormat } from "@cfworker/json-schema";
+import { looseArray, optionalBoolean, optionalNumberLike, optionalRawString, optionalRecord, optionalString, } from "../../core/cast.js";
 import { encodePathSegment } from "../../core/request.js";
 import { googleBearerProxyAuth, googleServiceAccountValidator, resolveGoogleAccessToken, } from "../googledrive/runtime-auth.js";
-import { defineProviderExecutors, defineProviderProxy, ProviderRequestError, readProviderErrorTextBody, readProviderJsonBody, requiredInputString, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { defineProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerResponseError, readProviderErrorTextBody, readProviderJsonBody, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
 import { decodeGmailAttachment } from "./attachment-stream.js";
-import { buildRecipients, encodeMimeMessage, extractBodyContent, firstAddress, normalizeGmailMessage, normalizeMessageId, normalizeThreadId, parseAddressList, readHeader, resolveReplyHeaders, summarizeGmailMessage, } from "./message.js";
+import { gmailMaxMimeBytes } from "./limits.js";
+import { assertMatchingReplySubject, buildRecipients, normalizeGmailMessage, normalizeMessageId, normalizeThreadId, readHeader, resolveReplyHeaders, summarizeGmailMessage, } from "./message.js";
+import { readGmailAttachments } from "./mime-attachments.js";
+import { decodeMimeSubject, encodeMimeMessage, readMimeReplyHeaders, updateMimeMessage } from "./mime.js";
 import { gmailOAuthScopes } from "./scopes.js";
+import { gmailMessageReceived } from "./trigger-on-message-received.js";
 const service = "gmail";
 const gmailApiBaseUrl = "https://gmail.googleapis.com/gmail/v1";
 const detailHydrationBatchSize = 10;
@@ -72,22 +77,20 @@ export const gmailActionHandlers = {
     get_profile(_input, { userId, accessToken, fetcher }) {
         return getProfile(userId, accessToken, fetcher);
     },
-    send_email(input, { userId, accessToken, fetcher }) {
-        return sendEmail(input, userId, accessToken, fetcher);
+    send_email(input, context) {
+        return sendEmail(input, context);
     },
-    async reply_email(input, { userId, accessToken, fetcher }) {
-        const output = await replyToMessage(input, userId, accessToken, fetcher);
-        return { messageId: output.messageId };
+    reply_email(input, context) {
+        return replyToMessage(input, context);
     },
-    reply_to_thread(input, { userId, accessToken, fetcher }) {
-        return replyToThread(input, userId, accessToken, fetcher);
+    reply_to_thread(input, context) {
+        return replyToThread(input, context);
     },
-    async create_draft(input, { userId, accessToken, fetcher }) {
-        const output = await createEmailDraft(input, userId, accessToken, fetcher);
-        return { draftId: output.draftId };
+    create_draft(input, context) {
+        return createEmailDraft(input, context);
     },
-    create_email_draft(input, { userId, accessToken, fetcher }) {
-        return createEmailDraft(input, userId, accessToken, fetcher);
+    create_email_draft(input, context) {
+        return createEmailDraft(input, context);
     },
     list_drafts(input, { userId, accessToken, fetcher }) {
         return listDrafts(input, userId, accessToken, fetcher);
@@ -95,8 +98,8 @@ export const gmailActionHandlers = {
     get_draft(input, { userId, accessToken, fetcher }) {
         return getDraft(input, userId, accessToken, fetcher);
     },
-    update_draft(input, { userId, accessToken, fetcher }) {
-        return updateDraft(input, userId, accessToken, fetcher);
+    update_draft(input, context) {
+        return updateDraft(input, context);
     },
     send_draft(input, { userId, accessToken, fetcher }) {
         return sendDraft(input, userId, accessToken, fetcher);
@@ -319,7 +322,9 @@ async function listThreads(input, userId, accessToken, fetcher) {
         resultSizeEstimate: payload.resultSizeEstimate ?? threads.length,
     };
 }
-async function sendEmail(input, userId, accessToken, fetcher) {
+async function sendEmail(input, context) {
+    const { userId, accessToken, fetcher } = context;
+    const attachments = await readGmailAttachments(input.attachments, context);
     const recipients = buildRecipients(input);
     const response = await fetchJson(gmailUserUrl(userId, "messages", "send"), accessToken, fetcher, {
         method: "POST",
@@ -328,21 +333,21 @@ async function sendEmail(input, userId, accessToken, fetcher) {
                 to: recipients.to,
                 cc: recipients.cc,
                 bcc: recipients.bcc,
-                subject: trimmedString(input.subject),
-                body: trimmedString(input.body) || trimmedString(input.messageBody),
+                subject: optionalRawString(input.subject),
+                body: optionalRawString(input.body) ?? optionalRawString(input.messageBody),
                 isHtml: input.isHtml === true,
-                from: trimmedString(input.fromEmail),
+                from: optionalRawString(input.fromEmail),
+                attachments,
             }),
         }),
     });
-    return { messageId: response.id };
+    return { messageId: response.id, threadId: optionalString(response.threadId) };
 }
-async function replyToThread(input, userId, accessToken, fetcher) {
+async function replyToThread(input, context) {
+    const { userId, accessToken, fetcher } = context;
+    const attachments = await readGmailAttachments(input.attachments, context);
     const thread = await getThreadResource(userId, normalizeThreadId(input.threadId), accessToken, fetcher, "full");
-    const target = thread.messages?.at(-1);
-    if (!target) {
-        throw new ProviderRequestError(400, "thread has no messages");
-    }
+    const target = latestReplyMessage(thread);
     const recipients = buildRecipients(input);
     const replyHeaders = resolveReplyHeaders(target);
     const response = await sendThreadMessage(userId, accessToken, fetcher, thread.id, encodeMimeMessage({
@@ -350,54 +355,116 @@ async function replyToThread(input, userId, accessToken, fetcher) {
         cc: recipients.cc,
         bcc: recipients.bcc,
         subject: replyHeaders.subject,
-        body: trimmedString(input.messageBody) || trimmedString(input.body),
+        body: optionalRawString(input.messageBody) ?? optionalRawString(input.body),
         isHtml: input.isHtml === true,
         inReplyTo: replyHeaders.inReplyTo,
         references: replyHeaders.references,
+        attachments,
     }));
-    return { messageId: response.id, threadId: response.threadId ?? thread.id };
+    return { messageId: response.id, threadId: optionalString(response.threadId) };
 }
-async function replyToMessage(input, userId, accessToken, fetcher) {
+async function replyToMessage(input, context) {
+    const { userId, accessToken, fetcher } = context;
+    const to = Object.hasOwn(input, "to") ? requiredInputString(input.to, "to") : undefined;
+    if (to !== undefined && !schemaFormat.email(to)) {
+        throw providerInputError("to must be a valid email address");
+    }
+    const recipients = buildRecipients({ to });
+    const attachments = await readGmailAttachments(input.attachments, context);
     const message = await getMessageResource(userId, normalizeMessageId(input.messageId), accessToken, fetcher, "full");
+    const threadId = optionalString(message.threadId);
+    if (!threadId)
+        throw providerResponseError("Gmail reply target is missing its threadId");
+    const requestedThreadId = optionalString(input.threadId);
+    if (requestedThreadId && normalizeThreadId(requestedThreadId) !== threadId) {
+        throw providerInputError("threadId must match the reply target message's threadId");
+    }
     const replyHeaders = resolveReplyHeaders(message);
-    const threadId = normalizeThreadId(message.threadId || input.threadId);
     const response = await sendThreadMessage(userId, accessToken, fetcher, threadId, encodeMimeMessage({
-        to: [replyHeaders.to],
+        to: to !== undefined ? recipients.to : [replyHeaders.to],
         subject: replyHeaders.subject,
-        body: trimmedString(input.body),
+        body: optionalRawString(input.body),
+        isHtml: input.isHtml === true,
         inReplyTo: replyHeaders.inReplyTo,
         references: replyHeaders.references,
+        attachments,
     }));
     return {
         messageId: response.id,
-        threadId: response.threadId ?? normalizeThreadId(input.threadId),
+        threadId: optionalString(response.threadId),
     };
 }
-async function createEmailDraft(input, userId, accessToken, fetcher) {
+async function createEmailDraft(input, context) {
+    const { userId, accessToken, fetcher } = context;
+    const attachments = await readGmailAttachments(input.attachments, context);
     const recipients = buildRecipients(input);
+    const replyTarget = await resolveDraftReplyTarget({
+        threadId: optionalString(input.threadId),
+        replyToMessageId: optionalString(input.replyToMessageId),
+    }, context);
+    const subject = optionalRawString(input.subject) ?? replyTarget?.headers.subject;
+    if (replyTarget && subject !== undefined) {
+        assertMatchingReplySubject(subject, replyTarget.headers.subject);
+    }
+    const hasRecipients = ["to", "recipientEmail", "extraRecipients"].some((name) => Object.hasOwn(input, name));
     const payload = await fetchJson(gmailUserUrl(userId, "drafts"), accessToken, fetcher, {
         method: "POST",
         body: JSON.stringify({
             message: {
                 raw: encodeMimeMessage({
-                    to: recipients.to,
+                    to: hasRecipients ? recipients.to : replyTarget ? [replyTarget.headers.to] : [],
                     cc: recipients.cc,
                     bcc: recipients.bcc,
-                    subject: trimmedString(input.subject),
-                    body: trimmedString(input.body) || trimmedString(input.messageBody),
+                    subject,
+                    body: optionalRawString(input.body) ?? optionalRawString(input.messageBody),
                     isHtml: input.isHtml === true,
-                    from: trimmedString(input.fromEmail),
+                    from: optionalRawString(input.fromEmail),
+                    inReplyTo: replyTarget?.headers.inReplyTo,
+                    references: replyTarget?.headers.references,
+                    attachments,
                 }),
-                threadId: trimmedString(input.threadId) ? normalizeThreadId(input.threadId) : undefined,
+                threadId: replyTarget?.threadId,
             },
         }),
     });
     return {
         draftId: payload.id,
-        messageId: payload.message?.id ?? "",
-        threadId: payload.message?.threadId ?? "",
+        messageId: optionalString(payload.message?.id),
+        threadId: optionalString(payload.message?.threadId),
     };
 }
+async function resolveDraftReplyTarget(input, context) {
+    const threadId = input.threadId ? normalizeThreadId(input.threadId) : undefined;
+    if (!threadId && !input.replyToMessageId)
+        return undefined;
+    const { userId, accessToken, fetcher } = context;
+    const message = input.replyToMessageId
+        ? await getMessageResource(userId, input.replyToMessageId, accessToken, fetcher, "full")
+        : latestReplyMessage(await getThreadResource(userId, threadId, accessToken, fetcher, "full"));
+    const resolvedThreadId = optionalString(message.threadId);
+    if (!resolvedThreadId)
+        throw providerResponseError("Gmail reply target is missing its threadId");
+    if (threadId && threadId !== resolvedThreadId) {
+        throw providerInputError("threadId must match the reply target message's threadId");
+    }
+    return { threadId: resolvedThreadId, headers: resolveReplyHeaders(message) };
+}
+function latestReplyMessage(thread) {
+    let latest;
+    let latestTimestamp;
+    for (const message of thread.messages ?? []) {
+        if (message.labelIds?.includes("DRAFT"))
+            continue;
+        const timestamp = optionalNumberLike(message.internalDate);
+        if (latestTimestamp !== undefined && (timestamp === undefined || timestamp < latestTimestamp))
+            continue;
+        latest = message;
+        latestTimestamp = timestamp;
+    }
+    if (!latest)
+        throw providerInputError("thread has no non-draft messages to reply to");
+    return latest;
+}
 async function listDrafts(input, userId, accessToken, fetcher) {
     const url = new URL(gmailUserUrl(userId, "drafts"));
     if (input.pageToken != null) {
@@ -422,8 +489,8 @@ async function listDrafts(input, userId, accessToken, fetcher) {
         drafts: drafts.map((draft) => ({
             id: draft.id,
             message: {
-                messageId: draft.message?.id ?? "",
-                threadId: draft.message?.threadId ?? "",
+                messageId: optionalString(draft.message?.id),
+                threadId: optionalString(draft.message?.threadId),
             },
         })),
         nextPageToken: payload.nextPageToken ?? null,
@@ -436,47 +503,65 @@ async function getDraft(input, userId, accessToken, fetcher) {
         message: normalizeGmailMessage(draft.message),
     };
 }
-async function updateDraft(input, userId, accessToken, fetcher) {
+async function updateDraft(input, context) {
+    const { userId, accessToken, fetcher } = context;
+    const attachments = await readGmailAttachments(input.attachments, context);
     const draftId = normalizeMessageId(input.draftId);
-    const existing = await getDraftResource(userId, draftId, accessToken, fetcher, "full");
-    const headers = existing.message.payload?.headers ?? [];
-    const nextRecipients = buildRecipients(input);
-    const recipients = buildRecipients({
-        to: nextRecipients.to.length > 0 ? nextRecipients.to : parseAddressList(readHeader(headers, "To")),
-        cc: nextRecipients.cc.length > 0 ? nextRecipients.cc : parseAddressList(readHeader(headers, "Cc")),
-        bcc: nextRecipients.bcc.length > 0 ? nextRecipients.bcc : parseAddressList(readHeader(headers, "Bcc")),
+    const existing = requiredResponseRecord(await getDraftResource(userId, draftId, accessToken, fetcher, "raw"), "Gmail draft");
+    const existingMessage = requiredResponseRecord(existing.message, "Gmail draft message");
+    const originalRaw = optionalRawString(existingMessage.raw);
+    if (!originalRaw)
+        throw providerResponseError("Gmail draft response is missing its raw MIME message");
+    const recipients = buildRecipients(input);
+    const existingThreadId = optionalString(existingMessage.threadId);
+    const requestedThreadId = optionalString(input.threadId);
+    const normalizedThreadId = requestedThreadId ? normalizeThreadId(requestedThreadId) : undefined;
+    const replyToMessageId = optionalString(input.replyToMessageId);
+    const rebuildReply = Boolean(replyToMessageId || (normalizedThreadId && normalizedThreadId !== existingThreadId));
+    const replyTarget = rebuildReply
+        ? await resolveDraftReplyTarget({ threadId: normalizedThreadId, replyToMessageId }, context)
+        : undefined;
+    const subject = optionalRawString(input.subject) ?? replyTarget?.headers.subject;
+    if (subject !== undefined) {
+        if (replyTarget) {
+            assertMatchingReplySubject(subject, replyTarget.headers.subject);
+        }
+        else {
+            const currentHeaders = readMimeReplyHeaders(originalRaw);
+            if (currentHeaders.inReplyTo || currentHeaders.references) {
+                assertMatchingReplySubject(subject, decodeMimeSubject(currentHeaders.encodedSubject));
+            }
+        }
+    }
+    const threadId = replyTarget?.threadId ?? existingThreadId;
+    const raw = updateMimeMessage(originalRaw, {
+        to: ["to", "recipientEmail", "extraRecipients"].some((name) => Object.hasOwn(input, name))
+            ? recipients.to
+            : undefined,
+        cc: Object.hasOwn(input, "cc") ? recipients.cc : undefined,
+        bcc: Object.hasOwn(input, "bcc") ? recipients.bcc : undefined,
+        subject,
+        body: optionalRawString(input.body) ?? optionalRawString(input.messageBody),
+        isHtml: optionalBoolean(input.isHtml),
+        from: optionalRawString(input.fromEmail),
+        inReplyTo: replyTarget?.headers.inReplyTo,
+        references: replyTarget?.headers.references,
+        attachments,
     });
-    const existingBody = extractBodyContent(existing.message.payload ?? null);
-    const subject = trimmedString(input.subject) || readHeader(headers, "Subject");
-    const body = Object.hasOwn(input, "body")
-        ? trimmedString(input.body)
-        : Object.hasOwn(input, "messageBody")
-            ? trimmedString(input.messageBody)
-            : existingBody.body;
-    const isHtml = typeof input.isHtml === "boolean" ? input.isHtml : existingBody.isHtml;
-    const threadId = trimmedString(input.threadId) || existing.message.threadId;
     const payload = await fetchJson(gmailUserUrl(userId, "drafts", draftId), accessToken, fetcher, {
         method: "PUT",
         body: JSON.stringify({
             id: draftId,
             message: {
-                raw: encodeMimeMessage({
-                    to: recipients.to,
-                    cc: recipients.cc,
-                    bcc: recipients.bcc,
-                    subject,
-                    body,
-                    isHtml,
-                    from: trimmedString(input.fromEmail) || firstAddress(readHeader(headers, "From")),
-                }),
+                raw,
                 threadId: threadId ? normalizeThreadId(threadId) : undefined,
             },
         }),
     });
     return {
         draftId: payload.id,
-        messageId: payload.message?.id ?? "",
-        threadId: payload.message?.threadId ?? "",
+        messageId: optionalString(payload.message?.id),
+        threadId: optionalString(payload.message?.threadId),
     };
 }
 async function sendDraft(input, userId, accessToken, fetcher) {
@@ -488,7 +573,7 @@ async function sendDraft(input, userId, accessToken, fetcher) {
     });
     return {
         messageId: payload.id,
-        threadId: payload.threadId ?? null,
+        threadId: optionalString(payload.threadId) ?? null,
     };
 }
 async function deleteDraft(input, userId, accessToken, fetcher) {
@@ -664,6 +749,15 @@ async function getThreadResource(userId, threadId, accessToken, fetcher, format)
 async function getDraftResource(userId, draftId, accessToken, fetcher, format) {
     const url = new URL(gmailUserUrl(userId, "drafts", draftId));
     url.searchParams.set("format", format);
+    if (format === "raw") {
+        // Raw MIME includes all files. Bound the encoded envelope without the small JSON default.
+        const response = await sendGmailRequest(url.toString(), accessToken, fetcher);
+        return (await readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "Gmail raw draft response must be valid JSON",
+            maxBytes: Math.ceil((gmailMaxMimeBytes * 4) / 3) + 64 * 1024,
+        }));
+    }
     return fetchJson(url.toString(), accessToken, fetcher);
 }
 async function sendThreadMessage(userId, accessToken, fetcher, threadId, raw) {
@@ -789,3 +883,4 @@ async function readGmailError(response) {
         looseArray(error?.errors).some((entry) => gmailQuotaReasons.has(optionalString(optionalRecord(entry)?.reason) ?? ""));
     return new ProviderRequestError(response.status, optionalString(error?.message) ?? `gmail request failed with ${response.status}`, withRetryAfterSeconds(response), rateLimited ? "rate_limited" : undefined);
 }
+export const triggers = [gmailMessageReceived];

package/src/providers/gmail/limits.d.ts

@@ -0,0 +1,3 @@
+export declare const gmailMaxMimeBytes = 35000000;
+export declare const gmailMaxAttachmentBytes = 25000000;
+export declare const gmailMaxAttachmentCount = 100;

package/src/providers/gmail/limits.js

@@ -0,0 +1,5 @@
+// Gmail's upload ceiling applies to the complete MIME message, including encoding overhead.
+export const gmailMaxMimeBytes = 35_000_000;
+export const gmailMaxAttachmentBytes = 25_000_000;
+// Bound per-message work independently of the byte budget.
+export const gmailMaxAttachmentCount = 100;

package/src/providers/gmail/message.d.ts

@@ -3,6 +3,7 @@ export interface GmailMessageHeader {
     value: string;
 }
 export interface GmailMessagePart {
+    partId?: string;
     mimeType?: string;
     filename?: string;
     headers?: GmailMessageHeader[];
@@ -39,6 +40,9 @@ export interface GmailAttachmentSummary {
     filename: string;
     mimeType: string;
     size: number;
+    partId: string | null;
+    contentId: string | null;
+    disposition: "inline" | "attachment" | null;
 }
 export interface NormalizedGmailMessage extends GmailMessageSummary {
     preview: {
@@ -63,33 +67,24 @@ export interface GmailMessageSummary {
     sizeEstimate?: number;
     snippet?: string;
 }
-export interface MimeMessageInput {
-    to: string[];
-    cc?: string[];
-    bcc?: string[];
-    subject?: string;
-    body?: string;
-    isHtml?: boolean;
-    from?: string;
-    inReplyTo?: string;
-    references?: string;
-}
 export declare function summarizeGmailMessage(resource: GmailMessageResource): GmailMessageSummary;
 export declare function normalizeGmailMessage(resource: GmailMessageResource): NormalizedGmailMessage;
 export declare function readHeader(headers: GmailMessageHeader[], name: string): string;
-export declare function resolveReplyHeaders(resource: GmailMessageResource): {
+export interface GmailReplyHeaders {
     subject: string;
     to: string;
     references: string;
     inReplyTo: string;
-};
-export declare function encodeMimeMessage(input: MimeMessageInput): string;
-export declare function parseAddressList(value: string): string[];
-export declare function firstAddress(value: string): string;
-export declare function extractBodyContent(payload: GmailMessagePart | null): {
+}
+/** Build reply headers from RFC message identities, never Gmail resource IDs. */
+export declare function resolveReplyHeaders(resource: GmailMessageResource): GmailReplyHeaders;
+/** Gmail requires a reply's subject to match its target after ordinary Re: prefixes. */
+export declare function assertMatchingReplySubject(subject: string, targetSubject: string): void;
+interface GmailBodyContent {
     body: string;
     isHtml: boolean;
-};
+}
+export declare function extractBodyContent(payload: GmailMessagePart | null): GmailBodyContent;
 export declare function normalizeThreadId(value: unknown): string;
 export declare function normalizeMessageId(value: unknown): string;
 interface RecipientsInput {