@oomol-lab/open-connector 1.8.0 → 1.9.0

package/src/providers/getyoutubetranscript/executors.js

@@ -0,0 +1,14 @@
+import { defineApiKeyProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { getyoutubetranscriptActionHandlers, getyoutubetranscriptApiBaseUrl, validateGetyoutubetranscriptCredential, } from "./runtime.js";
+const service = "getyoutubetranscript";
+export const executors = defineApiKeyProviderExecutors(service, getyoutubetranscriptActionHandlers);
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        return validateGetyoutubetranscriptCredential(input.apiKey, fetcher, signal);
+    },
+};
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: getyoutubetranscriptApiBaseUrl,
+    auth: { type: "bearer" },
+});

package/src/providers/getyoutubetranscript/runtime.d.ts

@@ -0,0 +1,8 @@
+import type { CredentialValidationResult } from "../../core/types.ts";
+import type { ApiKeyProviderContext, ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+export declare const getyoutubetranscriptApiBaseUrl = "https://getyoutubetranscript.com/api/v1";
+type ActionContext = Pick<ApiKeyProviderContext, "apiKey" | "fetcher" | "signal">;
+type ActionHandler = (input: Record<string, unknown>, context: ActionContext) => Promise<unknown>;
+export declare const getyoutubetranscriptActionHandlers: ProviderActionHandlers<"getyoutubetranscript", ActionHandler>;
+export declare function validateGetyoutubetranscriptCredential(apiKey: string, fetcher: ProviderFetch, signal?: AbortSignal): Promise<CredentialValidationResult>;
+export {};

package/src/providers/getyoutubetranscript/runtime.js

@@ -0,0 +1,101 @@
+import { compactObject, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
+import { readProviderErrorTextBody, readProviderTextBody, runProviderRequest, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+export const getyoutubetranscriptApiBaseUrl = "https://getyoutubetranscript.com/api/v1";
+export const getyoutubetranscriptActionHandlers = {
+    get_credits(_input, context) {
+        return apiGet("/credits", {}, context, "execute");
+    },
+    get_youtube_transcript(input, context) {
+        return apiGet("/transcript", { v: input.video, language: input.language, timestamps: input.timestamps === true ? "true" : undefined }, context, "execute");
+    },
+    search_youtube(input, context) {
+        return apiGet("/search", input.pageToken === undefined
+            ? { q: input.query, type: input.type }
+            : { page_token: input.pageToken, type: input.type }, context, "execute");
+    },
+    list_youtube_channel_videos(input, context) {
+        return apiGet("/channel/videos", input.continuation === undefined ? { channel: input.channel } : { continuation: input.continuation }, context, "execute");
+    },
+    get_youtube_playlist(input, context) {
+        return apiGet("/playlist", input.continuation === undefined ? { list: input.list } : { continuation: input.continuation }, context, "execute");
+    },
+};
+export async function validateGetyoutubetranscriptCredential(apiKey, fetcher, signal) {
+    // /credits costs no credits, so validating a key is free.
+    const credits = optionalRecord(await apiGet("/credits", {}, { apiKey, fetcher, signal }, "validate"));
+    if (!credits) {
+        throw new ProviderRequestError(502, "GetYouTubeTranscript credits response was not an object");
+    }
+    const plan = optionalString(credits.plan);
+    return {
+        profile: {
+            displayName: plan ? `GetYouTubeTranscript (${plan} plan)` : "GetYouTubeTranscript API Key",
+        },
+        grantedScopes: [],
+        metadata: compactObject({
+            validationEndpoint: "/credits",
+            apiBaseUrl: getyoutubetranscriptApiBaseUrl,
+            plan,
+            planCreditsLeft: optionalNumber(credits.plan_credits_left),
+            topupCreditsLeft: optionalNumber(credits.topup_credits_left),
+        }),
+    };
+}
+/** GET a path and return the `data` object from the `{ success, data }` envelope. */
+async function apiGet(path, query, context, phase) {
+    const url = new URL(`${getyoutubetranscriptApiBaseUrl}${path}`);
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined && value !== null && value !== "") {
+            url.searchParams.set(key, String(value));
+        }
+    }
+    const { response, payload } = await runProviderRequest({ signal: context.signal, label: "GetYouTubeTranscript" }, async (signal) => {
+        const response = await context.fetcher(url, {
+            method: "GET",
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${context.apiKey}`,
+                "user-agent": providerUserAgent,
+            },
+            signal,
+        });
+        return { response, payload: await readPayload(response) };
+    });
+    const envelope = optionalRecord(payload);
+    if (!response.ok || envelope?.success === false) {
+        throw createError(response, payload, phase);
+    }
+    if (!envelope || !("data" in envelope)) {
+        throw new ProviderRequestError(502, "GetYouTubeTranscript response did not include data", payload);
+    }
+    return envelope.data;
+}
+async function readPayload(response) {
+    const text = response.ok
+        ? await readProviderTextBody(response, "GetYouTubeTranscript response")
+        : await readProviderErrorTextBody(response, "GetYouTubeTranscript error");
+    if (!text) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+function createError(response, payload, phase) {
+    const record = optionalRecord(payload);
+    const message = optionalString(record?.message) ?? optionalString(record?.code) ?? response.statusText;
+    const status = response.ok ? 502 : response.status;
+    if (status === 429) {
+        return new ProviderRequestError(429, message || "GetYouTubeTranscript rate limit exceeded", payload);
+    }
+    if (optionalString(record?.code) === "INVALID_API_KEY") {
+        return new ProviderRequestError(phase === "validate" ? 400 : 401, message || "GetYouTubeTranscript API key is invalid", undefined, phase === "validate" ? "invalid_input" : "authorization_failed");
+    }
+    if (status === 400 || status === 402 || status === 404) {
+        return new ProviderRequestError(status, message || "GetYouTubeTranscript request failed", payload);
+    }
+    return new ProviderRequestError(status || 502, message || "GetYouTubeTranscript request failed", payload, "provider_error");
+}

package/src/providers/github/runtime-pull-request.js

@@ -1,5 +1,5 @@
 import { optionalBoolean, optionalInteger, optionalRawString, optionalRecord, optionalString, } from "../../core/cast.js";
-import { readBoundedResponseBytes } from "../../core/request.js";
+import { storeResponseInTransit } from "../../core/request.js";
 import { ProviderRequestError } from "../provider-runtime.js";
 import { buildGitHubUrl, compactObject, githubHeaders, githubRequestJson, githubRequestNoContent, githubRequestTextTail, mapReviewComment, normalizeGitHubError, normalizeRequestedReviewersResponse, readJsonResponse, } from "./runtime-shared.js";
 export const pullRequestActionHandlers = {
@@ -627,11 +627,12 @@ async function downloadWorkflowArtifact(input, context) {
         throw normalizeGitHubError(response, await readJsonResponse(response), "github artifact download failed");
     const name = optionalString(input.fileName) ?? `github-artifact-${artifactId}.zip`;
     const mimeType = response.headers.get("content-type") ?? "application/zip";
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: context.transitFiles.maxBytes,
+    const file = await storeResponseInTransit(response, context.transitFiles, {
+        name,
+        mimeType,
         fieldName: "GitHub workflow artifact",
         createError: (message) => new ProviderRequestError(413, message),
+        signal: context.signal,
     });
-    const file = await context.transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
     return { file };
 }

package/src/providers/gmail/executors.js

@@ -1,9 +1,13 @@
-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";
@@ -73,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);
@@ -96,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);
@@ -320,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",
@@ -329,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({
@@ -351,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) {
@@ -423,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,
@@ -437,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) {
@@ -489,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) {
@@ -665,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) {

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 {