@dbx-tools/email 0.3.44 → 0.4.0

package/lib/src/sender.js

@@ -0,0 +1,152 @@
+/**
+ * Sender-address policy: turn the on-behalf-of user's email into an
+ * outbound `From`, and (optionally) restrict which addresses may send.
+ *
+ * The default `From` re-homes the local part (everything before `@`) of
+ * the OBO email on the configured sending domain, so `alice@databricks.com`
+ * through a domain of `mail.example.com` goes out as
+ * `alice@mail.example.com`. An explicit `from` short-circuits that; the
+ * file/outbox fallback (no domain) keeps the user's address verbatim so
+ * test artifacts land under a recognizable folder.
+ *
+ * The resolved `From` is then constrained to the effective allow-list: a
+ * pattern is either an exact address (`user@domain.com`), a domain wildcard
+ * (`*@domain.com` or the bare `domain.com`, matching any local part on that
+ * domain), or `*` (any). This module only matches patterns; which patterns
+ * apply is decided by the configured sender policy in `./config`, which
+ * under the default `"allowlist"` mode fills an empty list in from the
+ * sender source. {@link listSenderOptions} expands the effective list into
+ * the concrete addresses a UI dropdown can offer for the current user.
+ *
+ * @module
+ */
+import { ConfigurationError, ValidationError } from "@databricks/appkit";
+import { log, net } from "@dbx-tools/shared-core";
+const logger = log.logger("email/sender");
+/**
+ * Re-home the OBO user's local part on `domain`. Throws when no usable
+ * local part is available (e.g. a service-context call with no user).
+ */
+export function deriveSenderAddress(userEmail, domain) {
+    const local = userEmail?.split("@")[0]?.trim();
+    if (!local) {
+        throw ConfigurationError.resourceNotFound("On-behalf-of user email", "Set `from` / EMAIL_FROM to send from a fixed address instead of deriving one.");
+    }
+    return `${local}@${domain}`;
+}
+/**
+ * Normalize a sender allow-list from config (a `string[]`) or an env var
+ * (a CSV / whitespace-separated string). Delegates to the shared
+ * {@link net.parseEmails} so allow-list patterns are read exactly
+ * like recipient lists elsewhere: entries are trimmed, lower-cased (so
+ * matching in {@link isSenderAllowed} is case-insensitive), and
+ * de-duplicated; empties are dropped. An empty result means "no
+ * restriction".
+ */
+export function parseAllowedSenders(raw) {
+    return net.parseEmails(raw, { lowercase: true });
+}
+/** The `@domain` suffix a wildcard / bare-domain pattern matches, else null. */
+function patternDomainSuffix(pattern) {
+    if (pattern.startsWith("*@"))
+        return `@${pattern.slice(2)}`;
+    if (!pattern.includes("@"))
+        return `@${pattern}`;
+    return null;
+}
+/** Whether `address` (already lower-cased) satisfies a single pattern. */
+function matchesPattern(address, pattern) {
+    if (pattern === "*")
+        return true;
+    const suffix = patternDomainSuffix(pattern);
+    if (suffix)
+        return address.length > suffix.length && address.endsWith(suffix);
+    return address === pattern;
+}
+/**
+ * Whether `from` is permitted by the allow-list. An empty (or absent)
+ * allow-list permits everything: {@link resolveEmailConfig} is what turns
+ * the configured {@link SenderPolicy} into concrete patterns, so an empty
+ * list here means the policy had nothing to narrow to.
+ */
+export function isSenderAllowed(from, patterns) {
+    if (patterns.length === 0)
+        return true;
+    const address = from.trim().toLowerCase();
+    return patterns.some((pattern) => matchesPattern(address, pattern));
+}
+/**
+ * Throw when `from` is not permitted by the allow-list. No-op when the
+ * allow-list is empty. The single enforcement point for the restriction
+ * (called from {@link sendEmail}), so every send path is covered whether
+ * the address was derived server-side or chosen in a UI.
+ */
+export function assertSenderAllowed(from, patterns) {
+    if (isSenderAllowed(from, patterns))
+        return;
+    // The thrown message names the field only; the patterns are policy detail
+    // that belongs in the operator's logs, not in a client or model response.
+    logger.warn("sender:denied", { from, allowedSenders: patterns });
+    throw ValidationError.invalidValue("from", from, "an address permitted by the configured sender allow-list");
+}
+/**
+ * Resolve the `From` address for a send from the resolved config and the
+ * current OBO user: explicit `from` wins, then `<local>@<domain>`, then
+ * (file/outbox mode only) the user's email verbatim. Throws when none of
+ * those yield an address.
+ */
+export function resolveSenderAddress(config, userEmail) {
+    if (config.from)
+        return config.from;
+    if (config.domain)
+        return deriveSenderAddress(userEmail, config.domain);
+    const email = userEmail?.trim();
+    if (!email) {
+        throw ConfigurationError.resourceNotFound("Email sender address", "Set `from` / EMAIL_FROM, set `domain` / EMAIL_DOMAIN, or run on behalf of a user.");
+    }
+    return email;
+}
+/**
+ * Expand the resolved config's allow-list into the concrete `From`
+ * addresses offered to the current user - the data a UI sender dropdown
+ * renders. Exact-address patterns pass through; domain wildcards
+ * (`*@domain.com` / bare `domain.com`) are concretized as
+ * `<user-local>@<domain>` and dropped when no OBO user local part is
+ * available. When no allow-list is configured, the single default sender
+ * ({@link resolveSenderAddress}) is returned when it can be resolved,
+ * else an empty list. The default resolved sender, when permitted, is
+ * ordered first.
+ */
+export function listSenderOptions(config, userEmail) {
+    const patterns = config.allowedSenders ?? [];
+    const local = userEmail?.split("@")[0]?.trim().toLowerCase();
+    const options = [];
+    const add = (address) => {
+        if (address && !options.includes(address))
+            options.push(address);
+    };
+    // Surface the address a send would use by default first, when it can
+    // be resolved and the allow-list (if any) permits it.
+    try {
+        const fallback = resolveSenderAddress(config, userEmail);
+        if (isSenderAllowed(fallback, patterns))
+            add(fallback.toLowerCase());
+    }
+    catch {
+        // No default resolvable (e.g. file mode with no user / domain / from).
+    }
+    for (const pattern of patterns) {
+        if (pattern === "*")
+            continue; // "any" can't be enumerated as a choice
+        if (pattern.startsWith("*@") || !pattern.includes("@")) {
+            const domain = pattern.startsWith("*@") ? pattern.slice(2) : pattern;
+            if (local)
+                add(`${local}@${domain}`);
+        }
+        else {
+            add(pattern); // exact address
+        }
+    }
+    return options;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sender.js","sourceRoot":"","sources":["../../src/sender.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Sender-address policy: turn the on-behalf-of user's email into an\n * outbound `From`, and (optionally) restrict which addresses may send.\n *\n * The default `From` re-homes the local part (everything before `@`) of\n * the OBO email on the configured sending domain, so `alice@databricks.com`\n * through a domain of `mail.example.com` goes out as\n * `alice@mail.example.com`. An explicit `from` short-circuits that; the\n * file/outbox fallback (no domain) keeps the user's address verbatim so\n * test artifacts land under a recognizable folder.\n *\n * The resolved `From` is then constrained to the effective allow-list: a\n * pattern is either an exact address (`user@domain.com`), a domain wildcard\n * (`*@domain.com` or the bare `domain.com`, matching any local part on that\n * domain), or `*` (any). This module only matches patterns; which patterns\n * apply is decided by the configured sender policy in `./config`, which\n * under the default `\"allowlist\"` mode fills an empty list in from the\n * sender source. {@link listSenderOptions} expands the effective list into\n * the concrete addresses a UI dropdown can offer for the current user.\n *\n * @module\n */\n\nimport { ConfigurationError, ValidationError } from \"@databricks/appkit\";\nimport { log, net } from \"@dbx-tools/shared-core\";\n\nimport type { ResolvedEmailConfig } from \"./config\";\n\nconst logger = log.logger(\"email/sender\");\n\n/**\n * Re-home the OBO user's local part on `domain`. Throws when no usable\n * local part is available (e.g. a service-context call with no user).\n */\nexport function deriveSenderAddress(userEmail: string | undefined, domain: string): string {\n  const local = userEmail?.split(\"@\")[0]?.trim();\n  if (!local) {\n    throw ConfigurationError.resourceNotFound(\n      \"On-behalf-of user email\",\n      \"Set `from` / EMAIL_FROM to send from a fixed address instead of deriving one.\",\n    );\n  }\n  return `${local}@${domain}`;\n}\n\n/**\n * Normalize a sender allow-list from config (a `string[]`) or an env var\n * (a CSV / whitespace-separated string). Delegates to the shared\n * {@link net.parseEmails} so allow-list patterns are read exactly\n * like recipient lists elsewhere: entries are trimmed, lower-cased (so\n * matching in {@link isSenderAllowed} is case-insensitive), and\n * de-duplicated; empties are dropped. An empty result means \"no\n * restriction\".\n */\nexport function parseAllowedSenders(raw: string | string[] | undefined): string[] {\n  return net.parseEmails(raw, { lowercase: true });\n}\n\n/** The `@domain` suffix a wildcard / bare-domain pattern matches, else null. */\nfunction patternDomainSuffix(pattern: string): string | null {\n  if (pattern.startsWith(\"*@\")) return `@${pattern.slice(2)}`;\n  if (!pattern.includes(\"@\")) return `@${pattern}`;\n  return null;\n}\n\n/** Whether `address` (already lower-cased) satisfies a single pattern. */\nfunction matchesPattern(address: string, pattern: string): boolean {\n  if (pattern === \"*\") return true;\n  const suffix = patternDomainSuffix(pattern);\n  if (suffix) return address.length > suffix.length && address.endsWith(suffix);\n  return address === pattern;\n}\n\n/**\n * Whether `from` is permitted by the allow-list. An empty (or absent)\n * allow-list permits everything: {@link resolveEmailConfig} is what turns\n * the configured {@link SenderPolicy} into concrete patterns, so an empty\n * list here means the policy had nothing to narrow to.\n */\nexport function isSenderAllowed(from: string, patterns: string[]): boolean {\n  if (patterns.length === 0) return true;\n  const address = from.trim().toLowerCase();\n  return patterns.some((pattern) => matchesPattern(address, pattern));\n}\n\n/**\n * Throw when `from` is not permitted by the allow-list. No-op when the\n * allow-list is empty. The single enforcement point for the restriction\n * (called from {@link sendEmail}), so every send path is covered whether\n * the address was derived server-side or chosen in a UI.\n */\nexport function assertSenderAllowed(from: string, patterns: string[]): void {\n  if (isSenderAllowed(from, patterns)) return;\n  // The thrown message names the field only; the patterns are policy detail\n  // that belongs in the operator's logs, not in a client or model response.\n  logger.warn(\"sender:denied\", { from, allowedSenders: patterns });\n  throw ValidationError.invalidValue(\n    \"from\",\n    from,\n    \"an address permitted by the configured sender allow-list\",\n  );\n}\n\n/**\n * Resolve the `From` address for a send from the resolved config and the\n * current OBO user: explicit `from` wins, then `<local>@<domain>`, then\n * (file/outbox mode only) the user's email verbatim. Throws when none of\n * those yield an address.\n */\nexport function resolveSenderAddress(\n  config: ResolvedEmailConfig,\n  userEmail: string | undefined,\n): string {\n  if (config.from) return config.from;\n  if (config.domain) return deriveSenderAddress(userEmail, config.domain);\n  const email = userEmail?.trim();\n  if (!email) {\n    throw ConfigurationError.resourceNotFound(\n      \"Email sender address\",\n      \"Set `from` / EMAIL_FROM, set `domain` / EMAIL_DOMAIN, or run on behalf of a user.\",\n    );\n  }\n  return email;\n}\n\n/**\n * Expand the resolved config's allow-list into the concrete `From`\n * addresses offered to the current user - the data a UI sender dropdown\n * renders. Exact-address patterns pass through; domain wildcards\n * (`*@domain.com` / bare `domain.com`) are concretized as\n * `<user-local>@<domain>` and dropped when no OBO user local part is\n * available. When no allow-list is configured, the single default sender\n * ({@link resolveSenderAddress}) is returned when it can be resolved,\n * else an empty list. The default resolved sender, when permitted, is\n * ordered first.\n */\nexport function listSenderOptions(\n  config: ResolvedEmailConfig,\n  userEmail: string | undefined,\n): string[] {\n  const patterns = config.allowedSenders ?? [];\n  const local = userEmail?.split(\"@\")[0]?.trim().toLowerCase();\n  const options: string[] = [];\n  const add = (address: string | undefined): void => {\n    if (address && !options.includes(address)) options.push(address);\n  };\n\n  // Surface the address a send would use by default first, when it can\n  // be resolved and the allow-list (if any) permits it.\n  try {\n    const fallback = resolveSenderAddress(config, userEmail);\n    if (isSenderAllowed(fallback, patterns)) add(fallback.toLowerCase());\n  } catch {\n    // No default resolvable (e.g. file mode with no user / domain / from).\n  }\n\n  for (const pattern of patterns) {\n    if (pattern === \"*\") continue; // \"any\" can't be enumerated as a choice\n    if (pattern.startsWith(\"*@\") || !pattern.includes(\"@\")) {\n      const domain = pattern.startsWith(\"*@\") ? pattern.slice(2) : pattern;\n      if (local) add(`${local}@${domain}`);\n    } else {\n      add(pattern); // exact address\n    }\n  }\n  return options;\n}\n"]}

package/lib/src/tool.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The `send_email` Mastra tool: approval-gated so a model can draft a
+ * message freely but nothing leaves the building until a human clicks
+ * Approve in the chat UI. On approval the sender is resolved (explicit
+ * `from` config, else derived from the on-behalf-of user's email) and
+ * the message is dispatched through the shared SMTP transport.
+ *
+ * The sender derivation runs inside the AppKit user scope, so
+ * `getExecutionContext()` returns the OBO user whose local-part seeds
+ * the address (see {@link deriveSenderAddress}).
+ *
+ * The dispatch itself goes through the executor the plugin installs on the
+ * shared runtime, so a send from this tool picks up the same retry / timeout /
+ * telemetry chain as one from the AppKit tool. In a Mastra app with no AppKit
+ * plugin registered the send still runs, just without interceptors.
+ *
+ * @module
+ */
+/**
+ * The model-facing description of the send capability, shared by the Mastra
+ * {@link emailTool} and the AppKit `email.send` tool so both agents get the
+ * same guidance about approval, scope, and body formatting.
+ */
+export declare const SEND_EMAIL_DESCRIPTION: string;
+/** Options accepted by {@link emailTool}. */
+export interface EmailToolOptions {
+    /**
+     * Override the tool id. Defaults to `"send_email"`; the chat UI's
+     * approval gate keys off this id, so keep it unless you also teach
+     * the client about the new name.
+     */
+    id?: string;
+}
+/**
+ * Build the approval-gated `send_email` tool. Spread it into the agents
+ * that should be able to draft mail; it is intentionally not installed
+ * everywhere.
+ *
+ * @example
+ * ```ts
+ * import { emailTool } from "@dbx-tools/email";
+ * import { createAgent } from "@dbx-tools/appkit-mastra";
+ *
+ * const support = createAgent({
+ *   instructions: "...",
+ *   tools: () => ({ send_email: emailTool() }),
+ * });
+ * ```
+ */
+export declare function emailTool(opts?: EmailToolOptions): import("@mastra/core/tools").Tool<{
+    to: string[];
+    subject: string;
+    body: string;
+    cc?: string[] | undefined;
+    bcc?: string[] | undefined;
+    attachments?: {
+        filename: string;
+        content?: string | undefined;
+        encoding?: string | undefined;
+        path?: string | undefined;
+        contentType?: string | undefined;
+    }[] | undefined;
+}, {
+    sent: boolean;
+    recipient: string;
+    from: string;
+    messageId?: string | undefined;
+}, unknown, unknown, import("@mastra/core/tools").ToolExecutionContext<unknown, unknown, unknown>, string, unknown>;

package/lib/src/tool.js

@@ -0,0 +1,82 @@
+/**
+ * The `send_email` Mastra tool: approval-gated so a model can draft a
+ * message freely but nothing leaves the building until a human clicks
+ * Approve in the chat UI. On approval the sender is resolved (explicit
+ * `from` config, else derived from the on-behalf-of user's email) and
+ * the message is dispatched through the shared SMTP transport.
+ *
+ * The sender derivation runs inside the AppKit user scope, so
+ * `getExecutionContext()` returns the OBO user whose local-part seeds
+ * the address (see {@link deriveSenderAddress}).
+ *
+ * The dispatch itself goes through the executor the plugin installs on the
+ * shared runtime, so a send from this tool picks up the same retry / timeout /
+ * telemetry chain as one from the AppKit tool. In a Mastra app with no AppKit
+ * plugin registered the send still runs, just without interceptors.
+ *
+ * @module
+ */
+import { getExecutionContext } from "@databricks/appkit";
+import { log, string } from "@dbx-tools/shared-core";
+import { email } from "@dbx-tools/shared-email";
+import { createTool } from "@mastra/core/tools";
+import { resolveSenderAddress } from "./sender.js";
+import { getEmailRuntime, sendEmail } from "./transport.js";
+const logger = log.logger("email/tool/send-email");
+/**
+ * The model-facing description of the send capability, shared by the Mastra
+ * {@link emailTool} and the AppKit `email.send` tool so both agents get the
+ * same guidance about approval, scope, and body formatting.
+ */
+export const SEND_EMAIL_DESCRIPTION = string.toDescription(`
+  Send an email on the user's behalf. Pass one or more recipient
+  addresses (with optional cc / bcc and file attachments), a subject,
+  and a body; the user is prompted to approve the send before it goes
+  out (this tool is approval-gated). Use it only when the user
+  explicitly asks to send / forward / share something via email -
+  never autonomously. Keep subjects short and bodies self-contained:
+  the recipient has none of the chat context. Write the body in
+  GitHub-Flavored Markdown - headings, lists, and real Markdown
+  tables - not ASCII art (no "=====" dividers or space/pipe-drawn
+  tables); it is rendered to HTML before sending.
+`);
+/**
+ * Build the approval-gated `send_email` tool. Spread it into the agents
+ * that should be able to draft mail; it is intentionally not installed
+ * everywhere.
+ *
+ * @example
+ * ```ts
+ * import { emailTool } from "@dbx-tools/email";
+ * import { createAgent } from "@dbx-tools/appkit-mastra";
+ *
+ * const support = createAgent({
+ *   instructions: "...",
+ *   tools: () => ({ send_email: emailTool() }),
+ * });
+ * ```
+ */
+export function emailTool(opts = {}) {
+    return createTool({
+        id: opts.id ?? "send_email",
+        description: SEND_EMAIL_DESCRIPTION,
+        inputSchema: email.emailMessageSchema,
+        outputSchema: email.emailResultSchema,
+        requireApproval: true,
+        execute: async (input, context) => {
+            const message = email.emailMessageSchema.parse(input);
+            const { config } = getEmailRuntime();
+            const ctx = getExecutionContext();
+            const userEmail = "isUserContext" in ctx ? ctx.userEmail : undefined;
+            const from = resolveSenderAddress(config, userEmail);
+            const result = await sendEmail(message, from, context?.abortSignal);
+            logger.info("sent", {
+                to: result.recipient,
+                from: result.from,
+                ...(result.messageId ? { messageId: result.messageId } : {}),
+            });
+            return result;
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/transport.d.ts

@@ -0,0 +1,103 @@
+/**
+ * The email runtime: a lazily-built, process-wide dispatcher plus its
+ * resolved config, and {@link sendEmail} which sends one
+ * {@link EmailMessage} through it. In SMTP mode the runtime holds a
+ * memoized nodemailer transport (shared by the plugin's setup and the
+ * agent tool, so they reuse one connection pool); in file/outbox mode it
+ * holds no transport and {@link sendEmail} writes HTML to disk instead.
+ * The first caller (normally the plugin at setup) primes it with the
+ * plugin's config; later callers reuse it.
+ *
+ * The runtime also carries the {@link EmailExecutor} every outbound send runs
+ * through. The plugin installs its own `execute()` there at setup, which is
+ * how the Mastra tool - a plain function with no plugin instance in scope -
+ * still gets AppKit's retry / timeout / telemetry chain. Without a registered
+ * plugin (a direct call from a script or a test) the send still runs, just
+ * without interceptors.
+ *
+ * Every entry point takes an optional {@link AbortSignal} so the plugin's
+ * `execute()` timeout and a client disconnect both stop the caller waiting
+ * on SMTP.
+ *
+ * @module
+ */
+import { type ExecutionResult } from "@databricks/appkit";
+import type { EmailMessage, EmailResult } from "@dbx-tools/shared-email";
+import { type Transporter } from "nodemailer";
+import { type EmailPluginConfig, type ResolvedEmailConfig } from "./config.js";
+import { type EmailExecutionSettings } from "./defaults.js";
+/**
+ * Runs one outbound send through AppKit's interceptor chain. Matches
+ * `Plugin.execute()`, which never throws: a failure comes back as
+ * `{ ok: false }`.
+ */
+export type EmailExecutor = <T>(fn: (signal?: AbortSignal) => Promise<T>, settings: EmailExecutionSettings) => Promise<ExecutionResult<T>>;
+/** The shared dispatcher, its resolved config, and the send executor. */
+export interface EmailRuntime {
+    /** Present only in SMTP mode. */
+    transporter?: Transporter;
+    config: ResolvedEmailConfig;
+    execute: EmailExecutor;
+}
+/**
+ * Return the shared runtime, building it on first use by resolving
+ * `overrides` over the environment (`SMTP_HOST`, `SMTP_PORT`,
+ * `SMTP_SECURE`, `SMTP_USER`, `SMTP_PASSWORD`, `EMAIL_DOMAIN`,
+ * `EMAIL_FROM`, `EMAIL_ALLOWED_SENDERS`, `EMAIL_SENDER_POLICY`,
+ * `EMAIL_OUTBOX_MODE`, `EMAIL_OUTBOX_DIR`) through
+ * {@link resolveEmailConfig}. With SMTP credentials present it holds a
+ * nodemailer transport and its connection pool; otherwise it is in
+ * file/outbox mode and holds none.
+ *
+ * `overrides` is read only on the call that builds the runtime, so prime it
+ * from the plugin's config at setup; later callers (the tool's `execute`,
+ * the sender-options route) pass nothing and get the same instance. Throws
+ * whatever {@link resolveEmailConfig} throws for an unusable configuration.
+ */
+export declare function getEmailRuntime(overrides?: EmailPluginConfig): EmailRuntime;
+/**
+ * Install the executor outbound sends run through. The plugin calls this at
+ * setup with its own `execute()`; a second call replaces the previous one, so
+ * a re-registered plugin does not leave the tools bound to a dead instance.
+ */
+export declare function setEmailExecutor(execute: EmailExecutor): void;
+/**
+ * Drop the memoized runtime, closing the SMTP connection pool, so the next
+ * {@link getEmailRuntime} rebuilds it from fresh config and stops calling
+ * through a torn-down plugin's `execute()`. Idempotent, and the plugin's
+ * `shutdown()` hook.
+ */
+export declare function resetEmailRuntime(): void;
+/**
+ * Run one non-idempotent write through the shared executor and unwrap it.
+ *
+ * `execute()` never throws, so a failed send arrives as `{ ok: false }` with a
+ * status the interceptors already sanitized; it is logged here and re-raised
+ * as a stable {@link ExecutionError} so an upstream message never becomes the
+ * caller's error text. `signal` is the caller's own cancellation (an agent
+ * run, a request teardown); it is merged with the signal the timeout
+ * interceptor supplies so either one unwinds the I/O.
+ */
+export declare function executeWrite<T>(operation: string, settings: EmailExecutionSettings, fn: (signal?: AbortSignal) => Promise<T>, signal?: AbortSignal): Promise<T>;
+/**
+ * Open and tear down one SMTP connection to prove the host, port, and
+ * credentials work. Called at plugin setup so a bad relay shows up in the
+ * boot logs rather than on the first approved send.
+ */
+export declare function verifyEmailTransport(transporter: Transporter | undefined, signal?: AbortSignal): Promise<void>;
+/**
+ * Send (SMTP mode) or persist (file/outbox mode) one message from the
+ * resolved `from` address. `to` (and optional `cc` / `bcc`) each accept
+ * one or more addresses, and `attachments` are forwarded as files. The
+ * body is markdown: SMTP sends it as both a plain-text part (the raw
+ * source) and an HTML part (rendered), and the outbox embeds the
+ * rendered HTML in a document. In file mode the returned `messageId` is
+ * the path written. Throws when `to` carries no recipient, when the body
+ * or attachments exceed the plugin's caps, or when `from` is not permitted
+ * by the effective sender allow-list.
+ *
+ * The recipient, cap, and sender checks run before the interceptor chain so
+ * their specific status and actionable message reach the caller instead of
+ * the chain's stable failure text. `signal` cancels the send.
+ */
+export declare function sendEmail(message: EmailMessage, from: string, signal?: AbortSignal): Promise<EmailResult>;