runline 0.1.0

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

@@ -0,0 +1,321 @@
+async function apiRequest(apiKey, method, endpoint, body, qs) {
+    const dc = apiKey.split("-").pop();
+    const url = new URL(`https://${dc}.api.mailchimp.com/3.0${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: { Authorization: `Basic ${btoa(`anystring:${apiKey}`)}`, Accept: "application/json" },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE") {
+        opts.headers["Content-Type"] = "application/json";
+        opts.body = JSON.stringify(body);
+    }
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`Mailchimp API error ${res.status}: ${await res.text()}`);
+    if (res.status === 204)
+        return { success: true };
+    return res.json();
+}
+export default function mailchimp(rl) {
+    rl.setName("mailchimp");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Mailchimp API key (includes datacenter suffix, e.g. xxx-us21)", env: "MAILCHIMP_API_KEY" },
+    });
+    const key = (ctx) => ctx.connection.config.apiKey;
+    // ── Member ──────────────────────────────────────────
+    rl.registerAction("member.create", {
+        description: "Add a member to a list/audience",
+        inputSchema: {
+            listId: { type: "string", required: true, description: "List/audience ID" },
+            email: { type: "string", required: true },
+            status: { type: "string", required: true, description: "subscribed, unsubscribed, cleaned, pending, transactional" },
+            mergeFields: { type: "object", required: false, description: "Merge fields as {TAG: value}" },
+            tags: { type: "array", required: false, description: "Array of tag name strings" },
+            emailType: { type: "string", required: false, description: "html or text" },
+            language: { type: "string", required: false },
+            vip: { type: "boolean", required: false },
+            location: { type: "object", required: false, description: "{latitude: number, longitude: number}" },
+            interests: { type: "object", required: false, description: "Interest group IDs as {id: boolean}" },
+            ipSignup: { type: "string", required: false },
+            ipOpt: { type: "string", required: false },
+            timestampSignup: { type: "string", required: false, description: "ISO datetime" },
+            timestampOpt: { type: "string", required: false, description: "ISO datetime" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = {
+                email_address: p.email,
+                status: p.status,
+            };
+            if (p.mergeFields)
+                body.merge_fields = p.mergeFields;
+            if (p.tags)
+                body.tags = p.tags;
+            if (p.emailType)
+                body.email_type = p.emailType;
+            if (p.language)
+                body.language = p.language;
+            if (p.vip !== undefined)
+                body.vip = p.vip;
+            if (p.location)
+                body.location = p.location;
+            if (p.interests)
+                body.interests = p.interests;
+            if (p.ipSignup)
+                body.ip_signup = p.ipSignup;
+            if (p.ipOpt)
+                body.ip_opt = p.ipOpt;
+            if (p.timestampSignup)
+                body.timestamp_signup = p.timestampSignup;
+            if (p.timestampOpt)
+                body.timestamp_opt = p.timestampOpt;
+            return apiRequest(key(ctx), "POST", `/lists/${p.listId}/members`, body);
+        },
+    });
+    rl.registerAction("member.get", {
+        description: "Get a list member by email (used directly as subscriber hash)",
+        inputSchema: {
+            listId: { type: "string", required: true },
+            email: { type: "string", required: true, description: "Email address (Mailchimp accepts email or MD5 hash)" },
+            fields: { type: "string", required: false, description: "Comma-separated fields to return" },
+            excludeFields: { type: "string", required: false, description: "Comma-separated fields to exclude" },
+        },
+        async execute(input, ctx) {
+            const { listId, email, fields, excludeFields } = input;
+            const qs = {};
+            if (fields)
+                qs.fields = fields;
+            if (excludeFields)
+                qs.exclude_fields = excludeFields;
+            return apiRequest(key(ctx), "GET", `/lists/${listId}/members/${email}`, undefined, qs);
+        },
+    });
+    rl.registerAction("member.list", {
+        description: "List members in a list/audience",
+        inputSchema: {
+            listId: { type: "string", required: true },
+            count: { type: "number", required: false, description: "Max results (default 500)" },
+            offset: { type: "number", required: false },
+            status: { type: "string", required: false, description: "subscribed, unsubscribed, cleaned, pending, transactional" },
+            emailType: { type: "string", required: false, description: "html or text" },
+            sinceLastChanged: { type: "string", required: false, description: "ISO datetime" },
+            beforeLastChanged: { type: "string", required: false, description: "ISO datetime" },
+            beforeTimestampOpt: { type: "string", required: false, description: "ISO datetime" },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const qs = {};
+            if (p.count)
+                qs.count = p.count;
+            if (p.offset)
+                qs.offset = p.offset;
+            if (p.status)
+                qs.status = p.status;
+            if (p.emailType)
+                qs.email_type = p.emailType;
+            if (p.sinceLastChanged)
+                qs.since_last_changed = p.sinceLastChanged;
+            if (p.beforeLastChanged)
+                qs.before_last_changed = p.beforeLastChanged;
+            if (p.beforeTimestampOpt)
+                qs.before_timestamp_opt = p.beforeTimestampOpt;
+            const data = (await apiRequest(key(ctx), "GET", `/lists/${p.listId}/members`, undefined, qs));
+            return data.members;
+        },
+    });
+    rl.registerAction("member.update", {
+        description: "Update a list member (PUT — full replace)",
+        inputSchema: {
+            listId: { type: "string", required: true },
+            email: { type: "string", required: true, description: "Email address (used as subscriber hash)" },
+            status: { type: "string", required: false },
+            mergeFields: { type: "object", required: false },
+            interests: { type: "object", required: false },
+            emailType: { type: "string", required: false },
+            language: { type: "string", required: false },
+            vip: { type: "boolean", required: false },
+            location: { type: "object", required: false },
+            ipSignup: { type: "string", required: false },
+            ipOpt: { type: "string", required: false },
+            timestampSignup: { type: "string", required: false },
+            timestampOpt: { type: "string", required: false },
+            skipMergeValidation: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const body = { email_address: p.email };
+            const qs = {};
+            if (p.status)
+                body.status = p.status;
+            if (p.mergeFields)
+                body.merge_fields = p.mergeFields;
+            if (p.interests)
+                body.interests = p.interests;
+            if (p.emailType)
+                body.email_type = p.emailType;
+            if (p.language)
+                body.language = p.language;
+            if (p.vip !== undefined)
+                body.vip = p.vip;
+            if (p.location)
+                body.location = p.location;
+            if (p.ipSignup)
+                body.ip_signup = p.ipSignup;
+            if (p.ipOpt)
+                body.ip_opt = p.ipOpt;
+            if (p.timestampSignup)
+                body.timestamp_signup = p.timestampSignup;
+            if (p.timestampOpt)
+                body.timestamp_opt = p.timestampOpt;
+            if (p.skipMergeValidation)
+                qs.skip_merge_validation = p.skipMergeValidation;
+            return apiRequest(key(ctx), "PUT", `/lists/${p.listId}/members/${p.email}`, body, Object.keys(qs).length > 0 ? qs : undefined);
+        },
+    });
+    rl.registerAction("member.delete", {
+        description: "Permanently delete a list member",
+        inputSchema: {
+            listId: { type: "string", required: true },
+            email: { type: "string", required: true, description: "Email address" },
+        },
+        async execute(input, ctx) {
+            const { listId, email } = input;
+            await apiRequest(key(ctx), "POST", `/lists/${listId}/members/${email}/actions/delete-permanent`);
+            return { success: true };
+        },
+    });
+    // ── Member Tag ──────────────────────────────────────
+    rl.registerAction("memberTag.add", {
+        description: "Add tags to a member",
+        inputSchema: {
+            listId: { type: "string", required: true },
+            email: { type: "string", required: true },
+            tags: { type: "array", required: true, description: "Array of tag names" },
+            isSyncing: { type: "boolean", required: false, description: "If true, automations based on tags won't fire" },
+        },
+        async execute(input, ctx) {
+            const { listId, email, tags, isSyncing } = input;
+            const body = { tags: tags.map((t) => ({ name: t, status: "active" })) };
+            if (isSyncing)
+                body.is_syncing = isSyncing;
+            await apiRequest(key(ctx), "POST", `/lists/${listId}/members/${email}/tags`, body);
+            return { success: true };
+        },
+    });
+    rl.registerAction("memberTag.remove", {
+        description: "Remove tags from a member",
+        inputSchema: {
+            listId: { type: "string", required: true },
+            email: { type: "string", required: true },
+            tags: { type: "array", required: true, description: "Array of tag names" },
+            isSyncing: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const { listId, email, tags, isSyncing } = input;
+            const body = { tags: tags.map((t) => ({ name: t, status: "inactive" })) };
+            if (isSyncing)
+                body.is_syncing = isSyncing;
+            await apiRequest(key(ctx), "POST", `/lists/${listId}/members/${email}/tags`, body);
+            return { success: true };
+        },
+    });
+    // ── List Group ──────────────────────────────────────
+    rl.registerAction("listGroup.list", {
+        description: "List interests in a specific interest category for a list",
+        inputSchema: {
+            listId: { type: "string", required: true },
+            categoryId: { type: "string", required: true, description: "Interest category ID" },
+            count: { type: "number", required: false, description: "Max results" },
+        },
+        async execute(input, ctx) {
+            const { listId, categoryId, count } = input;
+            const qs = {};
+            if (count)
+                qs.count = count;
+            const data = (await apiRequest(key(ctx), "GET", `/lists/${listId}/interest-categories/${categoryId}/interests`, undefined, qs));
+            return data.interests;
+        },
+    });
+    // ── Campaign ────────────────────────────────────────
+    rl.registerAction("campaign.get", {
+        description: "Get a campaign",
+        inputSchema: { campaignId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "GET", `/campaigns/${input.campaignId}`); },
+    });
+    rl.registerAction("campaign.list", {
+        description: "List campaigns",
+        inputSchema: {
+            count: { type: "number", required: false, description: "Max results" },
+            status: { type: "string", required: false, description: "save, sending, sent, schedule" },
+            listId: { type: "string", required: false, description: "Filter by list ID" },
+            fields: { type: "array", required: false, description: "Array of field names to return" },
+            sinceCreateTime: { type: "string", required: false, description: "ISO datetime" },
+            beforeCreateTime: { type: "string", required: false, description: "ISO datetime" },
+            sinceSendTime: { type: "string", required: false, description: "ISO datetime" },
+            beforeSendTime: { type: "string", required: false, description: "ISO datetime" },
+            sortField: { type: "string", required: false, description: "create_time or send_time" },
+            sortDirection: { type: "string", required: false, description: "ASC or DESC" },
+        },
+        async execute(input, ctx) {
+            const p = (input ?? {});
+            const qs = {};
+            if (p.count)
+                qs.count = p.count;
+            if (p.status)
+                qs.status = p.status;
+            if (p.listId)
+                qs.list_id = p.listId;
+            if (p.fields && Array.isArray(p.fields))
+                qs.fields = p.fields.join(",");
+            else
+                qs.fields = "campaigns.id,campaigns.status,campaigns.tracking,campaigns.settings.from_name,campaigns.settings.title,campaigns.settings.reply_to";
+            if (p.sinceCreateTime)
+                qs.since_create_time = p.sinceCreateTime;
+            if (p.beforeCreateTime)
+                qs.before_create_time = p.beforeCreateTime;
+            if (p.sinceSendTime)
+                qs.since_send_time = p.sinceSendTime;
+            if (p.beforeSendTime)
+                qs.before_send_time = p.beforeSendTime;
+            if (p.sortField)
+                qs.sort_field = p.sortField;
+            if (p.sortDirection)
+                qs.sort_dir = p.sortDirection;
+            const data = (await apiRequest(key(ctx), "GET", "/campaigns", undefined, qs));
+            return data.campaigns;
+        },
+    });
+    rl.registerAction("campaign.send", {
+        description: "Send a campaign",
+        inputSchema: { campaignId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            await apiRequest(key(ctx), "POST", `/campaigns/${input.campaignId}/actions/send`);
+            return { success: true };
+        },
+    });
+    rl.registerAction("campaign.replicate", {
+        description: "Replicate a campaign",
+        inputSchema: { campaignId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "POST", `/campaigns/${input.campaignId}/actions/replicate`); },
+    });
+    rl.registerAction("campaign.resend", {
+        description: "Create a resend to non-openers",
+        inputSchema: { campaignId: { type: "string", required: true } },
+        async execute(input, ctx) { return apiRequest(key(ctx), "POST", `/campaigns/${input.campaignId}/actions/create-resend`); },
+    });
+    rl.registerAction("campaign.delete", {
+        description: "Delete a campaign",
+        inputSchema: { campaignId: { type: "string", required: true } },
+        async execute(input, ctx) {
+            await apiRequest(key(ctx), "DELETE", `/campaigns/${input.campaignId}`);
+            return { success: true };
+        },
+    });
+}

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

@@ -0,0 +1,123 @@
+const BASE_URL = "https://connect.mailerlite.com/api";
+async function apiRequest(token, method, endpoint, body, qs) {
+    const url = new URL(`${BASE_URL}${endpoint}`);
+    if (qs) {
+        for (const [k, v] of Object.entries(qs)) {
+            if (v !== undefined && v !== null)
+                url.searchParams.set(k, String(v));
+        }
+    }
+    const opts = {
+        method,
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    };
+    if (body && Object.keys(body).length > 0 && method !== "GET" && method !== "DELETE")
+        opts.body = JSON.stringify(body);
+    const res = await fetch(url.toString(), opts);
+    if (!res.ok)
+        throw new Error(`MailerLite API error ${res.status}: ${await res.text()}`);
+    return res.json();
+}
+async function paginateAll(token, method, endpoint, qs = {}) {
+    const all = [];
+    qs.limit = 1000;
+    let cursor = null;
+    do {
+        if (cursor)
+            qs.cursor = cursor;
+        const resp = (await apiRequest(token, method, endpoint, undefined, qs));
+        const data = resp.data;
+        if (data)
+            all.push(...data);
+        const meta = resp.meta;
+        const links = resp.links;
+        cursor = meta?.next_cursor ?? null;
+        if (!links?.next)
+            cursor = null;
+    } while (cursor);
+    return all;
+}
+export default function mailerlite(rl) {
+    rl.setName("mailerlite");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "MailerLite API token", env: "MAILERLITE_API_KEY" },
+    });
+    const tok = (ctx) => ctx.connection.config.apiKey;
+    rl.registerAction("subscriber.create", {
+        description: "Create a subscriber",
+        inputSchema: {
+            email: { type: "string", required: true },
+            fields: { type: "object", required: false, description: "Custom fields as {field_key: value}" },
+            groups: { type: "array", required: false, description: "Array of group IDs" },
+            status: { type: "string", required: false, description: "active, unsubscribed, unconfirmed, bounced, junk" },
+            subscribed_at: { type: "string", required: false, description: "ISO datetime" },
+            ip_address: { type: "string", required: false },
+            opted_in_at: { type: "string", required: false },
+            optin_ip: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const { email, fields, ...rest } = input;
+            const body = { email };
+            if (fields)
+                body.fields = fields;
+            for (const [k, v] of Object.entries(rest)) {
+                if (v !== undefined && v !== null)
+                    body[k] = v;
+            }
+            const resp = (await apiRequest(tok(ctx), "POST", "/subscribers", body));
+            return resp.data;
+        },
+    });
+    rl.registerAction("subscriber.get", {
+        description: "Get a subscriber by ID or email",
+        inputSchema: { subscriberId: { type: "string", required: true, description: "Subscriber ID or email" } },
+        async execute(input, ctx) {
+            const resp = (await apiRequest(tok(ctx), "GET", `/subscribers/${encodeURIComponent(input.subscriberId)}`));
+            return resp.data;
+        },
+    });
+    rl.registerAction("subscriber.list", {
+        description: "List subscribers",
+        inputSchema: {
+            limit: { type: "number", required: false },
+            status: { type: "string", required: false, description: "Filter by status: active, unsubscribed, unconfirmed, bounced, junk" },
+        },
+        async execute(input, ctx) {
+            const { limit, status } = (input ?? {});
+            const qs = {};
+            if (status)
+                qs["filter[status]"] = status;
+            if (limit) {
+                qs.limit = limit;
+                const resp = (await apiRequest(tok(ctx), "GET", "/subscribers", undefined, qs));
+                return resp.data;
+            }
+            return paginateAll(tok(ctx), "GET", "/subscribers", qs);
+        },
+    });
+    rl.registerAction("subscriber.update", {
+        description: "Update a subscriber",
+        inputSchema: {
+            subscriberId: { type: "string", required: true, description: "Subscriber ID or email" },
+            fields: { type: "object", required: false, description: "Custom fields as {field_key: value}" },
+            groups: { type: "array", required: false, description: "Array of group IDs" },
+            status: { type: "string", required: false },
+            subscribed_at: { type: "string", required: false },
+            ip_address: { type: "string", required: false },
+            opted_in_at: { type: "string", required: false },
+            optin_ip: { type: "string", required: false },
+        },
+        async execute(input, ctx) {
+            const { subscriberId, fields, ...rest } = input;
+            const body = {};
+            if (fields)
+                body.fields = fields;
+            for (const [k, v] of Object.entries(rest)) {
+                if (v !== undefined && v !== null && k !== "subscriberId")
+                    body[k] = v;
+            }
+            return apiRequest(tok(ctx), "PUT", `/subscribers/${encodeURIComponent(subscriberId)}`, body);
+        },
+    });
+}

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

@@ -0,0 +1,48 @@
+export default function mailgun(rl) {
+    rl.setName("mailgun");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKey: { type: "string", required: true, description: "Mailgun API key", env: "MAILGUN_API_KEY" },
+        apiDomain: { type: "string", required: false, description: "API domain: 'api.mailgun.net' (US, default) or 'api.eu.mailgun.net' (EU)", default: "api.mailgun.net", env: "MAILGUN_API_DOMAIN" },
+        emailDomain: { type: "string", required: true, description: "Sending domain (e.g. mg.example.com)", env: "MAILGUN_EMAIL_DOMAIN" },
+    });
+    rl.registerAction("email.send", {
+        description: "Send an email via Mailgun",
+        inputSchema: {
+            to: { type: "string", required: true, description: "Recipient email(s), comma-separated" },
+            from: { type: "string", required: true, description: "Sender (e.g. 'Name <user@domain.com>')" },
+            subject: { type: "string", required: true },
+            text: { type: "string", required: false, description: "Plain text body" },
+            html: { type: "string", required: false, description: "HTML body" },
+            cc: { type: "string", required: false, description: "CC recipients, comma-separated" },
+            bcc: { type: "string", required: false, description: "BCC recipients, comma-separated" },
+        },
+        async execute(input, ctx) {
+            const { to, from, subject, text, html, cc, bcc } = input;
+            const cfg = ctx.connection.config;
+            const apiKey = cfg.apiKey;
+            const apiDomain = cfg.apiDomain ?? "api.mailgun.net";
+            const emailDomain = cfg.emailDomain;
+            const form = new URLSearchParams();
+            form.set("to", to);
+            form.set("from", from);
+            form.set("subject", subject);
+            if (text)
+                form.set("text", text);
+            if (html)
+                form.set("html", html);
+            if (cc)
+                form.set("cc", cc);
+            if (bcc)
+                form.set("bcc", bcc);
+            const res = await fetch(`https://${apiDomain}/v3/${emailDomain}/messages`, {
+                method: "POST",
+                headers: { Authorization: `Basic ${btoa(`api:${apiKey}`)}` },
+                body: form,
+            });
+            if (!res.ok)
+                throw new Error(`Mailgun error ${res.status}: ${await res.text()}`);
+            return res.json();
+        },
+    });
+}

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

@@ -0,0 +1,155 @@
+const BASE_URL = "https://api.mailjet.com";
+export default function mailjet(rl) {
+    rl.setName("mailjet");
+    rl.setVersion("0.1.0");
+    rl.setConnectionSchema({
+        apiKeyPublic: { type: "string", required: true, description: "Mailjet API key (public)", env: "MAILJET_API_KEY" },
+        apiKeyPrivate: { type: "string", required: true, description: "Mailjet secret key (private)", env: "MAILJET_SECRET_KEY" },
+        sandboxMode: { type: "boolean", required: false, description: "Enable sandbox mode (emails not actually sent)", default: false },
+        smsToken: { type: "string", required: false, description: "Mailjet SMS API token (if using SMS)", env: "MAILJET_SMS_TOKEN" },
+    });
+    const emailAuth = (ctx) => `Basic ${btoa(`${ctx.connection.config.apiKeyPublic}:${ctx.connection.config.apiKeyPrivate}`)}`;
+    const sandbox = (ctx) => ctx.connection.config.sandboxMode ?? false;
+    rl.registerAction("email.send", {
+        description: "Send an email via Mailjet Send API v3.1",
+        inputSchema: {
+            fromEmail: { type: "string", required: true },
+            fromName: { type: "string", required: false },
+            toEmail: { type: "string", required: true, description: "Comma-separated recipient emails" },
+            subject: { type: "string", required: true },
+            htmlPart: { type: "string", required: false, description: "HTML body" },
+            textPart: { type: "string", required: false, description: "Plain text body" },
+            cc: { type: "string", required: false, description: "Comma-separated CC emails" },
+            bcc: { type: "string", required: false, description: "Comma-separated BCC emails" },
+            replyTo: { type: "string", required: false, description: "Reply-to email" },
+            variables: { type: "object", required: false, description: "Template variables as key-value pairs" },
+            trackOpens: { type: "string", required: false, description: "account_default, disabled, enabled" },
+            trackClicks: { type: "string", required: false, description: "account_default, disabled, enabled" },
+            templateLanguage: { type: "boolean", required: false, description: "Enable template language in body" },
+            priority: { type: "number", required: false, description: "1-4, lower is higher priority" },
+            customCampaign: { type: "string", required: false },
+            deduplicateCampaign: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const message = {
+                From: { Email: p.fromEmail, ...(p.fromName ? { Name: p.fromName } : {}) },
+                Subject: p.subject,
+                To: p.toEmail.split(",").map((e) => ({ Email: e.trim() })),
+            };
+            if (p.htmlPart)
+                message.HTMLPart = p.htmlPart;
+            if (p.textPart)
+                message.TextPart = p.textPart;
+            if (p.cc)
+                message.Cc = p.cc.split(",").map((e) => ({ Email: e.trim() }));
+            if (p.bcc)
+                message.Bcc = p.bcc.split(",").map((e) => ({ Email: e.trim() }));
+            if (p.replyTo)
+                message.ReplyTo = { Email: p.replyTo };
+            if (p.variables)
+                message.Variables = p.variables;
+            if (p.trackOpens)
+                message.TrackOpens = p.trackOpens;
+            if (p.trackClicks)
+                message.TrackClicks = p.trackClicks;
+            if (p.templateLanguage !== undefined)
+                message.TemplateLanguage = p.templateLanguage;
+            if (p.priority)
+                message.Priority = p.priority;
+            if (p.customCampaign)
+                message.CustomCampaign = p.customCampaign;
+            if (p.deduplicateCampaign !== undefined)
+                message.DeduplicateCampaign = p.deduplicateCampaign;
+            const res = await fetch(`${BASE_URL}/v3.1/send`, {
+                method: "POST",
+                headers: { Authorization: emailAuth(ctx), "Content-Type": "application/json", Accept: "application/json" },
+                body: JSON.stringify({ Messages: [message], SandboxMode: sandbox(ctx) }),
+            });
+            if (!res.ok)
+                throw new Error(`Mailjet API error ${res.status}: ${await res.text()}`);
+            const data = (await res.json());
+            return data.Messages;
+        },
+    });
+    rl.registerAction("email.sendTemplate", {
+        description: "Send an email using a Mailjet template",
+        inputSchema: {
+            fromEmail: { type: "string", required: true },
+            fromName: { type: "string", required: false },
+            toEmail: { type: "string", required: true, description: "Comma-separated recipient emails" },
+            subject: { type: "string", required: true },
+            templateId: { type: "number", required: true, description: "Mailjet template ID" },
+            variables: { type: "object", required: false, description: "Template variables" },
+            cc: { type: "string", required: false },
+            bcc: { type: "string", required: false },
+            replyTo: { type: "string", required: false },
+            trackOpens: { type: "string", required: false },
+            trackClicks: { type: "string", required: false },
+            templateLanguage: { type: "boolean", required: false },
+            priority: { type: "number", required: false },
+            customCampaign: { type: "string", required: false },
+            deduplicateCampaign: { type: "boolean", required: false },
+        },
+        async execute(input, ctx) {
+            const p = input;
+            const message = {
+                From: { Email: p.fromEmail, ...(p.fromName ? { Name: p.fromName } : {}) },
+                Subject: p.subject,
+                To: p.toEmail.split(",").map((e) => ({ Email: e.trim() })),
+                TemplateID: p.templateId,
+            };
+            if (p.variables)
+                message.Variables = p.variables;
+            if (p.cc)
+                message.Cc = p.cc.split(",").map((e) => ({ Email: e.trim() }));
+            if (p.bcc)
+                message.Bcc = p.bcc.split(",").map((e) => ({ Email: e.trim() }));
+            if (p.replyTo)
+                message.ReplyTo = { Email: p.replyTo };
+            if (p.trackOpens)
+                message.TrackOpens = p.trackOpens;
+            if (p.trackClicks)
+                message.TrackClicks = p.trackClicks;
+            if (p.templateLanguage !== undefined)
+                message.TemplateLanguage = p.templateLanguage;
+            if (p.priority)
+                message.Priority = p.priority;
+            if (p.customCampaign)
+                message.CustomCampaign = p.customCampaign;
+            if (p.deduplicateCampaign !== undefined)
+                message.DeduplicateCampaign = p.deduplicateCampaign;
+            const res = await fetch(`${BASE_URL}/v3.1/send`, {
+                method: "POST",
+                headers: { Authorization: emailAuth(ctx), "Content-Type": "application/json", Accept: "application/json" },
+                body: JSON.stringify({ Messages: [message], SandboxMode: sandbox(ctx) }),
+            });
+            if (!res.ok)
+                throw new Error(`Mailjet API error ${res.status}: ${await res.text()}`);
+            const data = (await res.json());
+            return data.Messages;
+        },
+    });
+    rl.registerAction("sms.send", {
+        description: "Send an SMS via Mailjet SMS API",
+        inputSchema: {
+            from: { type: "string", required: true, description: "Sender name or number" },
+            to: { type: "string", required: true, description: "Recipient phone number (international format)" },
+            text: { type: "string", required: true, description: "SMS message text" },
+        },
+        async execute(input, ctx) {
+            const { from, to, text } = input;
+            const smsToken = ctx.connection.config.smsToken;
+            if (!smsToken)
+                throw new Error("SMS token not configured — set smsToken in connection config");
+            const res = await fetch(`${BASE_URL}/v4/sms-send`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${smsToken}`, "Content-Type": "application/json" },
+                body: JSON.stringify({ From: from, To: to, Text: text }),
+            });
+            if (!res.ok)
+                throw new Error(`Mailjet SMS error ${res.status}: ${await res.text()}`);
+            return res.json();
+        },
+    });
+}