automate.ax 0.3.1 → 0.4.0

package/dist/components/gmail/actions/draft-email.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+/**
+ * Creates a new Gmail draft.
+ *
+ * Recipients, subject, and body are optional so incomplete drafts remain valid.
+ * Plain text is derived automatically when only HTML is supplied.
+ */
+export declare const draftEmail: import("../../..").DefinedAction<z.ZodObject<{
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodCustom<File, File>, z.ZodObject<{
+        contentId: z.ZodOptional<z.ZodString>;
+        disposition: z.ZodOptional<z.ZodEnum<{
+            attachment: "attachment";
+            inline: "inline";
+        }>>;
+        file: z.ZodCustom<File, File>;
+        filename: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    bcc: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    cc: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    from: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        normal: "normal";
+        low: "low";
+    }>>;
+    replyTo: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    subject: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    html: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    messageId: z.ZodString;
+    threadId: z.ZodString;
+    historyId: z.ZodOptional<z.ZodString>;
+    labelIds: z.ZodArray<z.ZodString>;
+    draftId: z.ZodString;
+}, z.core.$strip>, "google">;
+//# sourceMappingURL=draft-email.d.ts.map

package/dist/components/gmail/actions/draft-email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft-email.d.ts","sourceRoot":"","sources":["../../../../src/components/gmail/actions/draft-email.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAyBnB,CAAA"}

package/dist/components/gmail/actions/draft-email.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { defineAction } from "../../../automation/actions.js";
+import { buildRawMessage, getGmailApi, toDraftIdentifier } from "../lib/gmail.js";
+import { GMAIL_COMPOSE_REQUIREMENT } from "../lib/scopes.js";
+import { COMPOSE_OPTIONS_SCHEMA, DRAFT_IDENTIFIER_SCHEMA } from "../lib/schemas.js";
+/**
+ * Creates a new Gmail draft.
+ *
+ * Recipients, subject, and body are optional so incomplete drafts remain valid.
+ * Plain text is derived automatically when only HTML is supplied.
+ */
+export const draftEmail = defineAction("Draft Gmail email")
+    .describe("Creates an incomplete or ready-to-send Gmail draft.")
+    .account("google", GMAIL_COMPOSE_REQUIREMENT)
+    .input(COMPOSE_OPTIONS_SCHEMA.extend({
+    /** Optional HTML draft body. */
+    html: z.string().optional(),
+    /** Optional plain-text draft body. */
+    text: z.string().optional(),
+}))
+    .output(DRAFT_IDENTIFIER_SCHEMA)
+    .handler(async ({ account, input }) => {
+    const { data: draft } = await getGmailApi(account.secret).users.drafts.create({
+        requestBody: {
+            message: {
+                raw: await buildRawMessage(input),
+            },
+        },
+        userId: "me",
+    });
+    return toDraftIdentifier(draft, "draft");
+});

package/dist/components/gmail/actions/draft-reply.d.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+/**
+ * Creates a Gmail reply draft attached to the original conversation.
+ *
+ * Original recipients are derived from message headers, while optional To, Cc,
+ * and Bcc inputs add recipients to the draft.
+ */
+export declare const draftReply: import("../../..").DefinedAction<z.ZodObject<{
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodCustom<File, File>, z.ZodObject<{
+        contentId: z.ZodOptional<z.ZodString>;
+        disposition: z.ZodOptional<z.ZodEnum<{
+            attachment: "attachment";
+            inline: "inline";
+        }>>;
+        file: z.ZodCustom<File, File>;
+        filename: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    bcc: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    cc: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    from: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    html: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        normal: "normal";
+        low: "low";
+    }>>;
+    replyAll: z.ZodOptional<z.ZodBoolean>;
+    replyTo: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    text: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    messageId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    messageId: z.ZodString;
+    threadId: z.ZodString;
+    historyId: z.ZodOptional<z.ZodString>;
+    labelIds: z.ZodArray<z.ZodString>;
+    draftId: z.ZodString;
+}, z.core.$strip>, "google">;
+//# sourceMappingURL=draft-reply.d.ts.map

package/dist/components/gmail/actions/draft-reply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft-reply.d.ts","sourceRoot":"","sources":["../../../../src/components/gmail/actions/draft-reply.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAavB;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAoCnB,CAAA"}

package/dist/components/gmail/actions/draft-reply.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { defineAction } from "../../../automation/actions.js";
+import { buildRawMessage, getGmailApi, getMessageMetadata, getReplyMessageOptions, getReplyOptions, toDraftIdentifier, } from "../lib/gmail.js";
+import { GMAIL_COMPOSE_AND_METADATA_REQUIREMENT } from "../lib/scopes.js";
+import { DRAFT_IDENTIFIER_SCHEMA, REPLY_OPTIONS_SCHEMA } from "../lib/schemas.js";
+/**
+ * Creates a Gmail reply draft attached to the original conversation.
+ *
+ * Original recipients are derived from message headers, while optional To, Cc,
+ * and Bcc inputs add recipients to the draft.
+ */
+export const draftReply = defineAction("Draft Gmail reply")
+    .describe("Creates a reply draft for a Gmail message.")
+    .account("google", GMAIL_COMPOSE_AND_METADATA_REQUIREMENT)
+    .input(REPLY_OPTIONS_SCHEMA.extend({
+    /** Immutable Gmail message ID receiving the reply. */
+    messageId: z.string().min(1),
+}))
+    .output(DRAFT_IDENTIFIER_SCHEMA)
+    .handler(async ({ account, input }) => {
+    const gmailApi = getGmailApi(account.secret);
+    const reply = await getReplyOptions(gmailApi, await getMessageMetadata(gmailApi, input.messageId), input.replyAll ?? false);
+    const { data: draft } = await gmailApi.users.drafts.create({
+        requestBody: {
+            message: {
+                raw: await buildRawMessage({
+                    ...getReplyMessageOptions(reply, input),
+                    bcc: input.bcc,
+                    from: input.from,
+                    headers: input.headers,
+                    html: input.html,
+                    priority: input.priority,
+                    replyTo: input.replyTo,
+                    text: input.text,
+                }),
+                threadId: reply.threadId,
+            },
+        },
+        userId: "me",
+    });
+    return toDraftIdentifier(draft, "reply draft");
+});

package/dist/components/gmail/actions/forward.d.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+/**
+ * Forwards a Gmail message with optional introductory content.
+ *
+ * Original attachments are preserved by default. Text and HTML introductions
+ * receive the same automatic plain-text fallback as newly composed messages.
+ */
+export declare const forward: import("../../..").DefinedAction<z.ZodObject<{
+    attachments: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodCustom<File, File>, z.ZodObject<{
+        contentId: z.ZodOptional<z.ZodString>;
+        disposition: z.ZodOptional<z.ZodEnum<{
+            attachment: "attachment";
+            inline: "inline";
+        }>>;
+        file: z.ZodCustom<File, File>;
+        filename: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    bcc: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    cc: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    from: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        normal: "normal";
+        low: "low";
+    }>>;
+    replyTo: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>>;
+    html: z.ZodOptional<z.ZodString>;
+    includeAttachments: z.ZodOptional<z.ZodBoolean>;
+    messageId: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodString>;
+    to: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>]>;
+}, z.core.$strip>, z.ZodObject<{
+    messageId: z.ZodString;
+    threadId: z.ZodString;
+    historyId: z.ZodOptional<z.ZodString>;
+    labelIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, "google">;
+//# sourceMappingURL=forward.d.ts.map

package/dist/components/gmail/actions/forward.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forward.d.ts","sourceRoot":"","sources":["../../../../src/components/gmail/actions/forward.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB;;;;;GAKG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA0HhB,CAAA"}

package/dist/components/gmail/actions/forward.js

@@ -0,0 +1,130 @@
+import escapeHtml from "escape-html";
+import { convert } from "html-to-text";
+import { z } from "zod";
+import { defineAction } from "../../../automation/actions.js";
+import { buildRawMessage, formatAddress, getGmailApi, parseRawMessage, toMessageMetadata, } from "../lib/gmail.js";
+import { GMAIL_SEND_AND_READ_REQUIREMENT } from "../lib/scopes.js";
+import { COMPOSE_OPTIONS_SCHEMA, MESSAGE_METADATA_SCHEMA, RECIPIENTS_SCHEMA, } from "../lib/schemas.js";
+/**
+ * Forwards a Gmail message with optional introductory content.
+ *
+ * Original attachments are preserved by default. Text and HTML introductions
+ * receive the same automatic plain-text fallback as newly composed messages.
+ */
+export const forward = defineAction("Forward Gmail message")
+    .describe("Forwards a Gmail message with optional introductory content.")
+    .account("google", GMAIL_SEND_AND_READ_REQUIREMENT)
+    .input(COMPOSE_OPTIONS_SCHEMA.extend({
+    /** Optional HTML introduction inserted before the forwarded message. */
+    html: z.string().optional(),
+    /** Whether to preserve the original message's attachments. */
+    includeAttachments: z.boolean().optional(),
+    /** Immutable Gmail ID of the message to forward. */
+    messageId: z.string().min(1),
+    /**
+     * Optional subject override; defaults to the original subject prefixed
+     * with `Fwd:`.
+     */
+    subject: z.string().optional(),
+    /** Optional plain-text introduction inserted before the forwarded message. */
+    text: z.string().optional(),
+    /** One or more primary recipients. */
+    to: RECIPIENTS_SCHEMA,
+}))
+    .output(MESSAGE_METADATA_SCHEMA)
+    .handler(async ({ account, input }) => {
+    const gmailApi = getGmailApi(account.secret);
+    const { data: original } = await gmailApi.users.messages.get({
+        format: "raw",
+        id: input.messageId,
+        userId: "me",
+    });
+    if (!original.raw)
+        throw new Error("Gmail did not return the raw message.");
+    const parsed = await parseRawMessage(original.raw);
+    const originalSubject = parsed.subject ?? "";
+    const forwardedHeaders = [
+        "---------- Forwarded message ---------",
+        `From: ${formatAddresses(parsed.from)}`,
+        `Date: ${parsed.date ?? ""}`,
+        `Subject: ${originalSubject}`,
+        `To: ${formatAddresses(parsed.to)}`,
+    ];
+    const originalText = parsed.text ??
+        (parsed.html === undefined
+            ? undefined
+            : convert(parsed.html, { wordwrap: false }));
+    const introHtml = input.html ??
+        (input.text === undefined ? undefined : textToHtml(input.text));
+    const originalHtml = parsed.html ??
+        (parsed.text === undefined ? undefined : textToHtml(parsed.text));
+    // Keep the generated MIME alternatives named so their fallback behavior is readable.
+    const html = introHtml || originalHtml
+        ? [
+            introHtml,
+            `<div>${forwardedHeaders.map(escapeHtml).join("<br>")}</div>`,
+            originalHtml,
+        ]
+            .filter(Boolean)
+            .join("<br><br>")
+        : undefined;
+    // See `html` above; this is the matching plain-text MIME alternative.
+    const text = input.text !== undefined || originalText !== undefined
+        ? [input.text, forwardedHeaders.join("\r\n"), originalText]
+            .filter((part) => part !== undefined)
+            .join("\r\n\r\n")
+        : undefined;
+    const forwardedAttachments = input.includeAttachments === false
+        ? []
+        : parsed.attachments.map((attachment) => ({
+            contentId: attachment.contentId,
+            disposition: attachment.disposition ?? undefined,
+            file: new File([
+                attachment.content instanceof ArrayBuffer
+                    ? new Uint8Array(attachment.content)
+                    : attachment.content,
+            ], attachment.filename || "attachment", { type: attachment.mimeType }),
+        }));
+    return toMessageMetadata((await gmailApi.users.messages.send({
+        requestBody: {
+            raw: await buildRawMessage({
+                attachments: [
+                    ...(input.attachments ?? []),
+                    ...forwardedAttachments,
+                ],
+                bcc: input.bcc,
+                cc: input.cc,
+                from: input.from,
+                headers: input.headers,
+                html,
+                priority: input.priority,
+                replyTo: input.replyTo,
+                subject: input.subject ??
+                    (originalSubject.startsWith("Fwd:")
+                        ? originalSubject
+                        : `Fwd: ${originalSubject}`),
+                text,
+                to: input.to,
+            }),
+        },
+        userId: "me",
+    })).data, "forward");
+});
+/**
+ * Converts plain text to safe HTML for a multipart forwarded message.
+ *
+ * @param text - Plain-text content.
+ */
+function textToHtml(text) {
+    return escapeHtml(text).replaceAll(/\r?\n/g, "<br>");
+}
+/**
+ * Formats PostalMime addresses for a forwarded-message preamble.
+ *
+ * @param addresses - One address or an address list.
+ */
+function formatAddresses(addresses) {
+    return (Array.isArray(addresses) ? addresses : addresses ? [addresses] : [])
+        .map(formatAddress)
+        .join(", ");
+}

package/dist/components/gmail/actions/get-draft.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+/** Retrieves and fully parses a Gmail draft and its message. */
+export declare const getDraft: import("../../..").DefinedAction<z.ZodObject<{
+    draftId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    draftId: z.ZodString;
+    message: z.ZodObject<{
+        messageId: z.ZodString;
+        threadId: z.ZodString;
+        historyId: z.ZodOptional<z.ZodString>;
+        labelIds: z.ZodArray<z.ZodString>;
+        attachments: z.ZodArray<z.ZodObject<{
+            contentId: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            disposition: z.ZodOptional<z.ZodEnum<{
+                attachment: "attachment";
+                inline: "inline";
+            }>>;
+            file: z.ZodCustom<File, File>;
+            filename: z.ZodString;
+            mimeType: z.ZodString;
+            related: z.ZodBoolean;
+        }, z.core.$strip>>;
+        bcc: z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        cc: z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        deliveredTo: z.ZodOptional<z.ZodString>;
+        from: z.ZodOptional<z.ZodObject<{
+            address: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        headers: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        html: z.ZodOptional<z.ZodString>;
+        inReplyTo: z.ZodOptional<z.ZodString>;
+        rfc822MessageId: z.ZodOptional<z.ZodString>;
+        receivedAt: z.ZodNullable<z.ZodDate>;
+        references: z.ZodArray<z.ZodString>;
+        replyTo: z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        returnPath: z.ZodOptional<z.ZodString>;
+        sender: z.ZodOptional<z.ZodObject<{
+            address: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        sentAt: z.ZodOptional<z.ZodDate>;
+        sizeEstimate: z.ZodOptional<z.ZodNumber>;
+        snippet: z.ZodOptional<z.ZodString>;
+        subject: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
+        to: z.ZodArray<z.ZodObject<{
+            address: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, "google">;
+//# sourceMappingURL=get-draft.d.ts.map

package/dist/components/gmail/actions/get-draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-draft.d.ts","sourceRoot":"","sources":["../../../../src/components/gmail/actions/get-draft.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,gEAAgE;AAChE,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAuBjB,CAAA"}

package/dist/components/gmail/actions/get-draft.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { defineAction } from "../../../automation/actions.js";
+import { getGmailApi, getGmailMessage } from "../lib/gmail.js";
+import { GMAIL_READ_REQUIREMENT } from "../lib/scopes.js";
+import { DRAFT_SCHEMA } from "../lib/schemas.js";
+/** Retrieves and fully parses a Gmail draft and its message. */
+export const getDraft = defineAction("Get Gmail draft")
+    .describe("Gets a Gmail draft with its parsed message and attachments.")
+    .account("google", GMAIL_READ_REQUIREMENT)
+    .input(z.object({
+    /** Immutable Gmail draft ID. */
+    draftId: z.string().min(1),
+}))
+    .output(DRAFT_SCHEMA)
+    .handler(async ({ account, input }) => {
+    const { data: draft } = await getGmailApi(account.secret).users.drafts.get({
+        format: "raw",
+        id: input.draftId,
+        userId: "me",
+    });
+    if (!draft.id || !draft.message) {
+        throw new Error("Gmail returned an incomplete draft.");
+    }
+    return {
+        draftId: draft.id,
+        message: await getGmailMessage(draft.message),
+    };
+});

package/dist/components/gmail/actions/get-message.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+/**
+ * Retrieves and fully parses one Gmail message.
+ *
+ * Attachments are always returned as Files because Gmail's raw-message response
+ * already includes their contents.
+ */
+export declare const getMessage: import("../../..").DefinedAction<z.ZodObject<{
+    messageId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    messageId: z.ZodString;
+    threadId: z.ZodString;
+    historyId: z.ZodOptional<z.ZodString>;
+    labelIds: z.ZodArray<z.ZodString>;
+    attachments: z.ZodArray<z.ZodObject<{
+        contentId: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        disposition: z.ZodOptional<z.ZodEnum<{
+            attachment: "attachment";
+            inline: "inline";
+        }>>;
+        file: z.ZodCustom<File, File>;
+        filename: z.ZodString;
+        mimeType: z.ZodString;
+        related: z.ZodBoolean;
+    }, z.core.$strip>>;
+    bcc: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    cc: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    deliveredTo: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    headers: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    html: z.ZodOptional<z.ZodString>;
+    inReplyTo: z.ZodOptional<z.ZodString>;
+    rfc822MessageId: z.ZodOptional<z.ZodString>;
+    receivedAt: z.ZodNullable<z.ZodDate>;
+    references: z.ZodArray<z.ZodString>;
+    replyTo: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    returnPath: z.ZodOptional<z.ZodString>;
+    sender: z.ZodOptional<z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    sentAt: z.ZodOptional<z.ZodDate>;
+    sizeEstimate: z.ZodOptional<z.ZodNumber>;
+    snippet: z.ZodOptional<z.ZodString>;
+    subject: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
+    to: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, "google">;
+//# sourceMappingURL=get-message.d.ts.map

package/dist/components/gmail/actions/get-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-message.d.ts","sourceRoot":"","sources":["../../../../src/components/gmail/actions/get-message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB;;;;;GAKG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAoBpB,CAAA"}

package/dist/components/gmail/actions/get-message.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { defineAction } from "../../../automation/actions.js";
+import { getGmailApi, getGmailMessage } from "../lib/gmail.js";
+import { GMAIL_READ_REQUIREMENT } from "../lib/scopes.js";
+import { MESSAGE_SCHEMA } from "../lib/schemas.js";
+/**
+ * Retrieves and fully parses one Gmail message.
+ *
+ * Attachments are always returned as Files because Gmail's raw-message response
+ * already includes their contents.
+ */
+export const getMessage = defineAction("Get Gmail message")
+    .describe("Gets a parsed Gmail message with headers and attachments.")
+    .account("google", GMAIL_READ_REQUIREMENT)
+    .input(z.object({
+    /** Immutable Gmail message ID. */
+    messageId: z.string().min(1),
+}))
+    .output(MESSAGE_SCHEMA)
+    .handler(async ({ account, input }) => getGmailMessage((await getGmailApi(account.secret).users.messages.get({
+    format: "raw",
+    id: input.messageId,
+    userId: "me",
+})).data));