runline 0.37.0 → 0.38.0

package/dist/credentials/http.d.ts

@@ -7,11 +7,25 @@ export interface ResourceOptions {
 }
 /** Internal send primitive. Callers validate destination policy before reaching it. */
 export declare function sendResource(url: string, method: HttpMethod, headers: Headers, body: Buffer | undefined, options: ResourceOptions): Promise<Response>;
+export interface PresignedRequestOptions {
+    /** Exact origins the URL may be on; anything else is refused. */
+    allowedOrigins: string[];
+    fetch: typeof globalThis.fetch;
+    method?: "GET" | "PUT" | "DELETE";
+    /** Request headers; credentials and cookies are never among them. */
+    headers?: Record<string, string>;
+    body?: Uint8Array;
+    maxResponseBytes?: number;
+}
 /**
- * Fetch a provider-issued preauthenticated URL without bearer tokens or cookies.
- * Hosts approve exact origins and enforce DNS/IP egress through their fetch hook.
- * The signed URL is itself secret: errors never include it. No redirects or retries.
+ * One request to a provider-issued preauthenticated URL — a signed
+ * download, an upload session — without bearer tokens or cookies.
+ * Hosts approve exact origins and enforce DNS/IP egress through their
+ * fetch hook. The signed URL is itself secret: errors never include it.
+ * No redirects or retries.
  */
+export declare function presignedRequest(value: string, options: PresignedRequestOptions): Promise<Response>;
+/** A GET of a provider-issued preauthenticated URL; see presignedRequest. */
 export declare function downloadResource(value: string, options: {
     allowedOrigins: string[];
     fetch: typeof globalThis.fetch;

package/dist/credentials/http.js

@@ -78,11 +78,19 @@ export async function sendResource(url, method, headers, body, options) {
     }
 }
 /**
- * Fetch a provider-issued preauthenticated URL without bearer tokens or cookies.
- * Hosts approve exact origins and enforce DNS/IP egress through their fetch hook.
- * The signed URL is itself secret: errors never include it. No redirects or retries.
+ * Headers a presigned request never sends: the URL is its only authority,
+ * so no credential or cookie rides along, and Destination belongs to the
+ * credential transport's COPY and MOVE.
  */
-export async function downloadResource(value, options) {
+const PRESIGNED_REFUSED_HEADERS = ["authorization", "cookie", "destination"];
+/**
+ * One request to a provider-issued preauthenticated URL — a signed
+ * download, an upload session — without bearer tokens or cookies.
+ * Hosts approve exact origins and enforce DNS/IP egress through their
+ * fetch hook. The signed URL is itself secret: errors never include it.
+ * No redirects or retries.
+ */
+export async function presignedRequest(value, options) {
     let url;
     try {
         url = new URL(value);
@@ -101,9 +109,23 @@ export async function downloadResource(value, options) {
         maxResponseBytes <= 0 ||
         maxResponseBytes > 64 * 1024 * 1024)
         throw new AuthError("invalid_definition");
-    return sendResource(url.toString(), "GET", new Headers(), undefined, {
-        fetch: options.fetch,
-        timeoutMs: 20_000,
-        maxResponseBytes,
-    });
+    const method = options.method ?? "GET";
+    const headers = new Headers();
+    try {
+        for (const [name, value] of Object.entries(options.headers ?? {})) {
+            if (PRESIGNED_REFUSED_HEADERS.includes(name.toLowerCase()))
+                throw new Error();
+            headers.set(name, value);
+        }
+        if (options.body !== undefined && method !== "PUT")
+            throw new Error();
+    }
+    catch {
+        throw new AuthError("request_not_allowed");
+    }
+    return sendResource(url.toString(), method, headers, options.body === undefined ? undefined : Buffer.from(options.body), { fetch: options.fetch, timeoutMs: 20_000, maxResponseBytes });
+}
+/** A GET of a provider-issued preauthenticated URL; see presignedRequest. */
+export function downloadResource(value, options) {
+    return presignedRequest(value, options);
 }

package/dist/index.d.ts

@@ -16,7 +16,7 @@ export { awsEndpoint, awsRegion, parseAwsXml } from "./credentials/aws.js";
 export type { AwsCredentialSpec } from "./credentials/aws-plugin.js";
 export { awsCredential, awsFailed, awsJson, awsList, awsQuery, awsTarget, } from "./credentials/aws-plugin.js";
 export { brokerFor } from "./credentials/broker.js";
-export { downloadResource } from "./credentials/http.js";
+export { downloadResource, type PresignedRequestOptions, presignedRequest, } from "./credentials/http.js";
 export type { CredentialCall, EmptyAnswer, ErrorEnvelope, StaticCredentialSpec, } from "./credentials/plugin.js";
 export { answerFailed, configChoice, configFlag, credentialJson, credentialOk, credentialRequest, credentialSocketUrl, errorIdentifier, failureMessage, grantSchema, graphqlFailed, hostLabel, httpsBase, jsonAnswer, jsonOrAcknowledged, multipartBody, pathSegment, pathSegments, pathWithin, refuseUnderHost, requestFailed, responseFailed, slashEncodedSegment, staticCredential, } from "./credentials/plugin.js";
 export { AwsAccessKeySchema, AwsSessionSchema, CredentialRegistry, OAuthGrantSchema, OAuthTokensSchema, staticSecretSchema, validateCredential, } from "./credentials/registry.js";

package/dist/index.js

@@ -10,7 +10,7 @@ export { buildAuthUrl, exchangeAuthCode, generatePKCE, OAUTH_CALLBACK_PORT, OAUT
 export { awsEndpoint, awsRegion, parseAwsXml } from "./credentials/aws.js";
 export { awsCredential, awsFailed, awsJson, awsList, awsQuery, awsTarget, } from "./credentials/aws-plugin.js";
 export { brokerFor } from "./credentials/broker.js";
-export { downloadResource } from "./credentials/http.js";
+export { downloadResource, presignedRequest, } from "./credentials/http.js";
 export { answerFailed, configChoice, configFlag, credentialJson, credentialOk, credentialRequest, credentialSocketUrl, errorIdentifier, failureMessage, grantSchema, graphqlFailed, hostLabel, httpsBase, jsonAnswer, jsonOrAcknowledged, multipartBody, pathSegment, pathSegments, pathWithin, refuseUnderHost, requestFailed, responseFailed, slashEncodedSegment, staticCredential, } from "./credentials/plugin.js";
 export { AwsAccessKeySchema, AwsSessionSchema, CredentialRegistry, OAuthGrantSchema, OAuthTokensSchema, staticSecretSchema, validateCredential, } from "./credentials/registry.js";
 export { CredentialTransport } from "./credentials/transport.js";

package/dist/plugins/_shared/attachments.js

@@ -0,0 +1,97 @@
+import { basename } from "node:path";
+import * as t from "typebox";
+import { DownloadedFile, standardBase64 } from "./base64.js";
+import { readLocalFile } from "./localFile.js";
+const STRICT = { additionalProperties: false };
+const id = t.String({ minLength: 1, pattern: "\\S" });
+/** What any attachment may say about itself, whatever its bytes are. */
+export const attachmentMetadata = {
+    name: t.Optional(t.String({ ...id, description: "File name; defaults to the path's name." })),
+    mimeType: t.Optional(t.String({ ...id, description: "MIME type, e.g. application/pdf." })),
+    inline: t.Optional(t.Boolean({
+        description: "Embed in the HTML body, referenced as cid:<contentId>, instead of attaching.",
+    })),
+    contentId: t.Optional(t.String({ ...id, description: "Content-ID for inline images." })),
+};
+/**
+ * An attachment's bytes, given one way each and named as gmail and
+ * googleDrive name them: `contentBase64` (base64, or a
+ * googleDrive.file.download result passed straight through),
+ * `contentPath` (a file on the runline host) or `content` (UTF-8 text).
+ * `sizeNote` states the plugin's own limit.
+ */
+export function attachmentSources(sizeNote) {
+    return [
+        t.Object({
+            ...attachmentMetadata,
+            contentBase64: t.Union([t.String(), DownloadedFile], {
+                description: `Base64 bytes (standard or base64url; padding and whitespace normalized), or a googleDrive.file.download result, whose name and mimeType are used when not given here. ${sizeNote}`,
+            }),
+        }, STRICT),
+        t.Object({
+            ...attachmentMetadata,
+            contentPath: t.String({
+                ...id,
+                description: `A regular file on the runline host, read at call time. ${sizeNote}`,
+            }),
+        }, STRICT),
+        t.Object({
+            ...attachmentMetadata,
+            content: t.String({
+                description: `UTF-8 text content, e.g. a generated CSV. ${sizeNote}`,
+            }),
+        }, STRICT),
+    ];
+}
+/**
+ * Bytes given as base64, or as a googleDrive.file.download result, which
+ * also supplies a name and type. `subject` names the input in errors
+ * (`gmail: attachment 0`).
+ */
+export function base64File(value, subject) {
+    const result = typeof value === "string" ? undefined : value;
+    const content = standardBase64(typeof value === "string" ? value : value.contentBase64);
+    if (content === undefined)
+        throw new Error(`${subject} contentBase64 is not valid base64`);
+    return {
+        bytes: Buffer.from(content, "base64"),
+        name: result?.name || undefined,
+        mimeType: result?.mimeType || undefined,
+    };
+}
+/**
+ * An attachment input's bytes. A download result passed as contentBase64
+ * supplies the name and type the input leaves out; a local file is named
+ * for its path; text is text/plain. Oversized bytes, invalid base64 and
+ * unreadable files are refused here, before any request.
+ */
+export async function attachmentFile(input, index, limits) {
+    const subject = `${limits.plugin}: attachment ${index}`;
+    let file;
+    if ("contentBase64" in input) {
+        file = base64File(input.contentBase64, subject);
+    }
+    else if ("contentPath" in input) {
+        file = {
+            bytes: await readLocalFile(input.contentPath, {
+                subject: `${subject} contentPath`,
+                maxBytes: limits.maxBytes,
+                oversize: limits.oversize,
+            }),
+            name: basename(input.contentPath),
+        };
+    }
+    else {
+        file = {
+            bytes: Buffer.from(input.content, "utf8"),
+            mimeType: "text/plain",
+        };
+    }
+    if (file.bytes.length > limits.maxBytes)
+        throw new Error(limits.oversize);
+    return {
+        bytes: file.bytes,
+        name: input.name ?? file.name,
+        mimeType: input.mimeType ?? file.mimeType,
+    };
+}

package/dist/plugins/_shared/microsoftAuth.js

@@ -1,4 +1,4 @@
-import { AuthError, brokerFor, downloadResource, jsonAnswer, requestFailed, } from "runline";
+import { AuthError, brokerFor, downloadResource, jsonAnswer, presignedRequest, responseFailed, } from "runline";
 import { MICROSOFT_GRANT, microsoftCredential, microsoftEndpoint, microsoftUserBase, } from "./microsoftCredentials.js";
 export { microsoftCredential, microsoftDriveBase, } from "./microsoftCredentials.js";
 export function userBase(ctx) {
@@ -7,7 +7,11 @@ export function userBase(ctx) {
 export async function microsoftProbe(ctx, plugin, scopes) {
     return brokerFor(ctx, microsoftCredential(plugin, scopes)).probe();
 }
-export async function graphResponse(ctx, plugin, scopes, method, path, body, contentType) {
+/**
+ * One Graph request under the plugin's credential. `accept` is JSON
+ * unless the caller reads raw bytes, such as an attachment's `$value`.
+ */
+export async function graphResponse(ctx, plugin, scopes, method, path, body, contentType, accept = "application/json") {
     if (!path.startsWith("/") || path.startsWith("//"))
         throw new AuthError("request_not_allowed");
     return brokerFor(ctx, microsoftCredential(plugin, scopes)).request({
@@ -15,12 +19,21 @@ export async function graphResponse(ctx, plugin, scopes, method, path, body, con
         path: path.slice(1),
         method: method,
         headers: {
-            Accept: "application/json",
+            Accept: accept,
             ...(contentType ? { "Content-Type": contentType } : {}),
         },
         body,
     });
 }
+/**
+ * A failed Graph response, by its status and Graph's `error.code`
+ * (`ErrorItemNotFound`, `ErrorAccessDenied`); Graph's message is never read.
+ */
+export function graphFailed(plugin, response) {
+    return responseFailed(plugin, response, (body) => ({
+        code: body?.error?.code,
+    }));
+}
 /**
  * A Graph JSON request that must succeed; its answer is read by
  * `jsonAnswer`. JSON and binary requests share the same destination,
@@ -29,7 +42,7 @@ export async function graphResponse(ctx, plugin, scopes, method, path, body, con
 export async function graphRequest(ctx, plugin, scopes, method, path, body) {
     const res = await graphResponse(ctx, plugin, scopes, method, path, body === undefined ? undefined : JSON.stringify(body), body === undefined ? undefined : "application/json");
     if (!res.ok)
-        throw requestFailed(plugin, res.status);
+        throw await graphFailed(plugin, res);
     return jsonAnswer(res);
 }
 /** Graph-issued signed download URLs carry their own authority, never a bearer header. */
@@ -57,6 +70,22 @@ export async function microsoftDownload(value) {
         fetch: globalThis.fetch,
     });
 }
+/** Where Graph's Outlook attachment upload sessions live, as Microsoft documents them. */
+const OUTLOOK_UPLOAD_ORIGIN = "https://outlook.office.com";
+/**
+ * One request to an Outlook attachment upload session's `uploadUrl`. The
+ * URL carries its own authority, so the request has no bearer token; a
+ * URL on any other origin is refused.
+ */
+export function outlookUpload(uploadUrl, init) {
+    if (typeof uploadUrl !== "string")
+        throw new AuthError("invalid_response");
+    return presignedRequest(uploadUrl, {
+        allowedOrigins: [OUTLOOK_UPLOAD_ORIGIN],
+        fetch: globalThis.fetch,
+        ...init,
+    });
+}
 /**
  * A Microsoft Graph plugin's OAuth declaration: the multi-tenant endpoints,
  * `offline_access` for a refresh token, the grant every Graph plugin

package/dist/plugins/_shared/schemas.js

@@ -0,0 +1,8 @@
+/**
+ * At least one of `fields` must be given: "provide a change", "name a
+ * recipient". Keyed off the field record itself, so the rule cannot drift
+ * from the fields it governs.
+ */
+export function atLeastOne(fields) {
+    return { anyOf: Object.keys(fields).map((key) => ({ required: [key] })) };
+}

package/dist/plugins/agentMail/src/drafts.js

@@ -1,5 +1,6 @@
 import * as t from "typebox";
-import { atLeastOne, attachments, clientId, contentFields, draftFields, id, idList, inboxFields, labelFields, listFields, STRICT, sendFields, strings, timestamp, } from "./schemas.js";
+import { atLeastOne } from "../../_shared/schemas.js";
+import { attachments, clientId, contentFields, draftFields, id, idList, inboxFields, labelFields, listFields, STRICT, sendFields, strings, timestamp, } from "./schemas.js";
 import { attachmentPath, draftPath, inboxPath, request, sendMessage, } from "./shared.js";
 const list = t.Object({ ...inboxFields, ...listFields }, STRICT);
 const draft = t.Object(draftFields, STRICT);

package/dist/plugins/agentMail/src/inboxes.js

@@ -1,5 +1,6 @@
 import * as t from "typebox";
-import { atLeastOne, clientId, id, inboxFields, pageFields, STRICT, } from "./schemas.js";
+import { atLeastOne } from "../../_shared/schemas.js";
+import { clientId, id, inboxFields, pageFields, STRICT } from "./schemas.js";
 import { inboxPath, request } from "./shared.js";
 const metadataValue = t.Union([
     t.String({ maxLength: 256 }),

package/dist/plugins/agentMail/src/messages.js

@@ -1,5 +1,6 @@
 import * as t from "typebox";
-import { atLeastOne, id, inboxFields, labelFields, mailListFields, messageContentFields, messageFields, recipientFields, replyContentFields, STRICT, searchFields, sendFields, strings, } from "./schemas.js";
+import { atLeastOne } from "../../_shared/schemas.js";
+import { id, inboxFields, labelFields, mailListFields, messageContentFields, messageFields, recipientFields, replyContentFields, STRICT, searchFields, sendFields, strings, } from "./schemas.js";
 import { attachmentPath, inboxPath, messagePath, request, sendMessage, } from "./shared.js";
 const list = t.Object({
     ...inboxFields,

package/dist/plugins/agentMail/src/schemas.js

@@ -1,16 +1,8 @@
 import * as t from "typebox";
-import { DownloadedFile } from "../../_shared/base64.js";
+import { attachmentMetadata, attachmentSources, } from "../../_shared/attachments.js";
 export const STRICT = { additionalProperties: false };
 export const MAX_REQUEST_BYTES = 6_000_000;
 export const id = t.String({ minLength: 1, pattern: "\\S" });
-/**
- * At least one of `fields` must be given: "provide a change", "name a
- * recipient". Keyed off the field record itself, so the rule cannot drift
- * from the fields it governs.
- */
-export function atLeastOne(fields) {
-    return { anyOf: Object.keys(fields).map((key) => ({ required: [key] })) };
-}
 export const inboxFields = {
     inboxId: t.String({
         ...id,
@@ -82,40 +74,11 @@ export const sendFields = {
     })),
 };
 /**
- * Attachment bytes come one way each, named as gmail and googleDrive name
- * them: `contentBase64`, `contentPath`, `content` (UTF-8 text), plus
- * AgentMail's own `url`. A googleDrive download result passes straight
- * through as `contentBase64`.
+ * Attachment bytes come one way each, as every mail plugin takes them,
+ * plus AgentMail's own `url`, which AgentMail fetches itself.
  */
-const attachmentMetadata = {
-    name: t.Optional(t.String({ ...id, description: "File name; defaults to the path's name." })),
-    mimeType: t.Optional(t.String({ ...id, description: "MIME type, e.g. application/pdf." })),
-    inline: t.Optional(t.Boolean({
-        description: "Embed in the HTML body, referenced as cid:<contentId>, instead of attaching.",
-    })),
-    contentId: t.Optional(t.String({ ...id, description: "Content-ID for inline images." })),
-};
-const SIZE_NOTE = "The entire serialized request is limited to 6 MB; use url for larger files.";
 export const attachment = t.Union([
-    t.Object({
-        ...attachmentMetadata,
-        contentBase64: t.Union([t.String(), DownloadedFile], {
-            description: `Base64 bytes (standard or base64url; padding and whitespace normalized), or a googleDrive.file.download result, whose name and mimeType are used when not given here. ${SIZE_NOTE}`,
-        }),
-    }, STRICT),
-    t.Object({
-        ...attachmentMetadata,
-        contentPath: t.String({
-            ...id,
-            description: `A regular file on the runline host, read at call time. ${SIZE_NOTE}`,
-        }),
-    }, STRICT),
-    t.Object({
-        ...attachmentMetadata,
-        content: t.String({
-            description: `UTF-8 text content, e.g. a generated CSV. ${SIZE_NOTE}`,
-        }),
-    }, STRICT),
+    ...attachmentSources("The entire serialized request is limited to 6 MB; use url for larger files."),
     t.Object({
         ...attachmentMetadata,
         url: t.String({

package/dist/plugins/agentMail/src/shared.js

@@ -1,9 +1,7 @@
-import { basename } from "node:path";
 import { AuthError, credentialRequest, jsonAnswer, pathSegment, responseFailed, } from "runline";
 import * as t from "typebox";
 import { Check } from "typebox/value";
-import { standardBase64 } from "../../_shared/base64.js";
-import { readLocalFile } from "../../_shared/localFile.js";
+import { attachmentFile } from "../../_shared/attachments.js";
 import { obj } from "../../_shared/provider.js";
 import { agentMailCredential } from "./credentials.js";
 import { id, MAX_REQUEST_BYTES } from "./schemas.js";
@@ -32,59 +30,39 @@ function wireFields(fields) {
 }
 /** The bytes a request body can still hold once base64 inflates them by 4/3. */
 const MAX_FILE_BYTES = Math.floor((MAX_REQUEST_BYTES * 3) / 4);
-function base64Content(value, index) {
-    const content = standardBase64(value);
-    if (content === undefined)
-        throw new Error(`agentMail: attachment ${index} contentBase64 is not valid base64`);
-    return content;
-}
-/** One attachment's base64 bytes, or its URL for AgentMail to fetch. */
-async function attachmentSource(input, index) {
-    if ("contentBase64" in input) {
-        const value = input.contentBase64;
-        return {
-            content: base64Content(typeof value === "string" ? value : value.contentBase64, index),
-        };
+/**
+ * One attachment as AgentMail's SendAttachment: its bytes as base64, or
+ * its URL for AgentMail to fetch.
+ */
+async function wireAttachment(input, index) {
+    let source;
+    let file;
+    if ("url" in input) {
+        try {
+            const url = new URL(input.url);
+            if (url.protocol !== "https:" || url.username || url.password)
+                throw new Error();
+        }
+        catch {
+            throw new Error(`agentMail: attachment ${index} url requires HTTPS without embedded credentials`);
+        }
+        source = { url: input.url };
+        file = { name: input.name, mimeType: input.mimeType };
     }
-    if ("contentPath" in input) {
-        const bytes = await readLocalFile(input.contentPath, {
-            subject: `agentMail: attachment ${index} contentPath`,
+    else {
+        const resolved = await attachmentFile(input, index, {
+            plugin: "agentMail",
             maxBytes: MAX_FILE_BYTES,
             oversize: `agentMail: attachment ${index} exceeds the 6 MB request limit once encoded; use url`,
         });
-        return { content: bytes.toString("base64") };
-    }
-    if ("content" in input)
-        return { content: Buffer.from(input.content, "utf8").toString("base64") };
-    try {
-        const url = new URL(input.url);
-        if (url.protocol !== "https:" || url.username || url.password)
-            throw new Error();
+        if (!resolved.bytes.length)
+            throw new Error(`agentMail: attachment ${index} is empty`);
+        source = { content: resolved.bytes.toString("base64") };
+        file = resolved;
     }
-    catch {
-        throw new Error(`agentMail: attachment ${index} url requires HTTPS without embedded credentials`);
-    }
-    return { url: input.url };
-}
-/**
- * One attachment as AgentMail's SendAttachment. A download result passed
- * as contentBase64 supplies the name and type the input leaves out; a
- * local file is named for its path; text defaults to text/plain.
- */
-async function wireAttachment(input, index) {
-    const source = await attachmentSource(input, index);
-    if ("content" in source && !source.content)
-        throw new Error(`agentMail: attachment ${index} is empty`);
-    const result = "contentBase64" in input && typeof input.contentBase64 !== "string"
-        ? input.contentBase64
-        : undefined;
     return Object.fromEntries(Object.entries({
-        filename: input.name ??
-            (result?.name || undefined) ??
-            ("contentPath" in input ? basename(input.contentPath) : undefined),
-        content_type: input.mimeType ??
-            (result?.mimeType || undefined) ??
-            ("content" in input ? "text/plain" : undefined),
+        filename: file.name,
+        content_type: file.mimeType,
         content_disposition: input.inline === undefined
             ? undefined
             : input.inline

package/dist/plugins/agentMail/src/threads.js

@@ -1,5 +1,6 @@
 import * as t from "typebox";
-import { atLeastOne, id, inboxFields, labelFields, mailListFields, pageFields, STRICT, searchFields, strings, threadFields, } from "./schemas.js";
+import { atLeastOne } from "../../_shared/schemas.js";
+import { id, inboxFields, labelFields, mailListFields, pageFields, STRICT, searchFields, strings, threadFields, } from "./schemas.js";
 import { attachmentPath, inboxPath, request, threadPath } from "./shared.js";
 const list = t.Object({
     ...inboxFields,

package/dist/plugins/gmail/src/index.js

@@ -19,7 +19,8 @@
  */
 import { pathSegment, } from "runline";
 import * as t from "typebox";
-import { DownloadedFile, standardBase64 } from "../../_shared/base64.js";
+import { base64File } from "../../_shared/attachments.js";
+import { DownloadedFile } from "../../_shared/base64.js";
 import { renderEmailJsx } from "../../_shared/emailJsx.js";
 import { googleCredential, googleJsonRequest, googleOAuth, } from "../../_shared/googleAuth.js";
 import { GoogleTimestamp, Id, NonEmptyString, stringEnum, } from "../../_shared/googleSchemas.js";
@@ -111,30 +112,17 @@ function normalizeAttachment(input, index) {
         throw new Error(`gmail: attachment ${index} must be an object`);
     }
     const content = input.contentBase64;
-    const contentBase64 = typeof content === "string"
-        ? content
-        : content &&
-            typeof content === "object" &&
-            typeof content.contentBase64 === "string"
-            ? content.contentBase64
-            : undefined;
-    if (typeof contentBase64 !== "string") {
+    if (typeof content !== "string" &&
+        (typeof content !== "object" ||
+            !content ||
+            typeof content.contentBase64 !== "string")) {
         throw new Error(`gmail: attachment ${index} contentBase64 must be a base64 string`);
     }
-    const normalized = standardBase64(contentBase64);
-    if (normalized === undefined) {
-        throw new Error(`gmail: attachment ${index} contentBase64 is not valid base64`);
-    }
-    // A download result passed as contentBase64 names its own file and type.
-    const result = typeof content === "object" && content ? content : {};
-    const named = (value) => typeof value === "string" && value ? value : undefined;
+    const file = base64File(content, `gmail: attachment ${index}`);
     return {
-        name: input.name ??
-            input.filename ??
-            named(result.name) ??
-            `attachment-${index + 1}`,
-        mimeType: input.mimeType ?? named(result.mimeType) ?? "application/octet-stream",
-        contentBase64: normalized,
+        name: input.name ?? input.filename ?? file.name ?? `attachment-${index + 1}`,
+        mimeType: input.mimeType ?? file.mimeType ?? "application/octet-stream",
+        contentBase64: file.bytes.toString("base64"),
     };
 }
 function attachmentPart(att) {