@dbx-tools/email 0.6.53 → 0.6.55

package/lib/src/transport.js

@@ -22,7 +22,7 @@
  * @module
  */
 import { ConfigurationError, ExecutionError, ValidationError, } from "@databricks/appkit";
-import { execution, log, object } from "@dbx-tools/shared-core";
+import { execution, log } from "@dbx-tools/shared-core";
 import nodemailer from "nodemailer";
 import { resolveEmailConfig } from "./config.js";
 import { EMAIL_SEND_SETTINGS, MAX_ATTACHMENT_BYTES, MAX_ATTACHMENT_COUNT, MAX_ATTACHMENTS_TOTAL_BYTES, MAX_BODY_CHARS, } from "./defaults.js";
@@ -242,7 +242,7 @@ async function dispatch(message, from, signal, options) {
     const recipient = recipientEcho(message.to);
     signal?.throwIfAborted();
     if (config.mode === "file") {
-        const path = await writeOutboxEmail(message, from, config.outDir, config.brand, options);
+        const path = await writeOutboxEmail(message, from, config.outDir, config.brand);
         return { sent: true, recipient, from, messageId: path };
     }
     if (!transporter) {
@@ -253,13 +253,16 @@ async function dispatch(message, from, signal, options) {
         subject: message.subject,
         body: message.body,
         brand: config.brand,
-        ...object.optional("trailer", options?.trailer),
     });
     const info = await abortable(transporter.sendMail({
         from,
         to: message.to,
         subject: message.subject,
-        text: rendered.text,
+        // A caller-supplied plain-text part WINS over the generated one. Both parts
+        // still come from the same content; this only lets a caller control the
+        // text alternative's exact line layout, which some clients parse (see
+        // `SendEmailOptions.text`).
+        text: options?.text ?? rendered.text,
         html: rendered.html,
         ...(message.cc && message.cc.length > 0 ? { cc: message.cc } : {}),
         ...(message.bcc && message.bcc.length > 0 ? { bcc: message.bcc } : {}),
@@ -295,4 +298,4 @@ export async function sendEmail(message, from, signal, options) {
     assertSenderAllowed(from, getEmailRuntime().config.allowedSenders);
     return executeWrite("send", EMAIL_SEND_SETTINGS, (executeSignal) => dispatch(message, from, executeSignal, options), signal);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The email runtime: a lazily-built, process-wide dispatcher plus its\n * resolved config, and {@link sendEmail} which sends one\n * {@link EmailMessage} through it. In SMTP mode the runtime holds a\n * memoized nodemailer transport (shared by the plugin's setup and the\n * agent tool, so they reuse one connection pool); in file/outbox mode it\n * holds no transport and {@link sendEmail} writes HTML to disk instead.\n * The first caller (normally the plugin at setup) primes it with the\n * plugin's config; later callers reuse it.\n *\n * The runtime also carries the {@link EmailExecutor} every outbound send runs\n * through. The plugin installs its own `execute()` there at setup, which is\n * how the Mastra tool - a plain function with no plugin instance in scope -\n * still gets AppKit's retry / timeout / telemetry chain. Without a registered\n * plugin (a direct call from a script or a test) the send still runs, just\n * without interceptors.\n *\n * Every entry point takes an optional {@link AbortSignal} so the plugin's\n * `execute()` timeout and a client disconnect both stop the caller waiting\n * on SMTP.\n *\n * @module\n */\n\nimport {\n  ConfigurationError,\n  ExecutionError,\n  ValidationError,\n  type ExecutionResult,\n} from \"@databricks/appkit\";\nimport { execution, log, object } from \"@dbx-tools/shared-core\";\nimport type { EmailAttachment, EmailMessage, EmailResult } from \"@dbx-tools/shared-email\";\nimport nodemailer, { type SendMailOptions, type Transporter } from \"nodemailer\";\nimport { resolveEmailConfig, type EmailPluginConfig, type ResolvedEmailConfig } from \"./config.ts\";\nimport {\n  EMAIL_SEND_SETTINGS,\n  MAX_ATTACHMENT_BYTES,\n  MAX_ATTACHMENT_COUNT,\n  MAX_ATTACHMENTS_TOTAL_BYTES,\n  MAX_BODY_CHARS,\n  type EmailExecutionSettings,\n} from \"./defaults.ts\";\nimport { renderEmail } from \"./email-html.ts\";\nimport { writeOutboxEmail } from \"./outbox.ts\";\nimport { assertSenderAllowed } from \"./sender.ts\";\n\nconst logger = log.logger(\"email/transport\");\n\n/**\n * Runs one outbound send through AppKit's interceptor chain. Matches\n * `Plugin.execute()`, which never throws: a failure comes back as\n * `{ ok: false }`.\n */\nexport type EmailExecutor = <T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  settings: EmailExecutionSettings,\n) => Promise<ExecutionResult<T>>;\n\n/** The shared dispatcher, its resolved config, and the send executor. */\nexport interface EmailRuntime {\n  /** Present only in SMTP mode. */\n  transporter?: Transporter;\n  config: ResolvedEmailConfig;\n  execute: EmailExecutor;\n}\n\n/**\n * Executor used until (or unless) the plugin installs its own: run the send\n * directly, mapping a throw onto the same {@link ExecutionResult} shape so\n * call sites branch on `ok` either way.\n */\nconst directExecute = execution.directExecutor<EmailExecutionSettings>();\n\nlet runtime: EmailRuntime | undefined;\n\n/**\n * Return the shared runtime, building it on first use by resolving\n * `overrides` over the environment (`SMTP_HOST`, `SMTP_PORT`,\n * `SMTP_SECURE`, `SMTP_USER`, `SMTP_PASSWORD`, `EMAIL_DOMAIN`,\n * `EMAIL_FROM`, `EMAIL_ALLOWED_SENDERS`, `EMAIL_SENDER_POLICY`,\n * `EMAIL_OUTBOX_MODE`, `EMAIL_OUTBOX_DIR`) through\n * {@link resolveEmailConfig}. With SMTP credentials present it holds a\n * nodemailer transport and its connection pool; otherwise it is in\n * file/outbox mode and holds none.\n *\n * `overrides` is read only on the call that builds the runtime, so prime it\n * from the plugin's config at setup; later callers (the tool's `execute`,\n * the sender-options route) pass nothing and get the same instance. Throws\n * whatever {@link resolveEmailConfig} throws for an unusable configuration.\n */\nexport function getEmailRuntime(overrides?: EmailPluginConfig): EmailRuntime {\n  if (!runtime) {\n    const config = resolveEmailConfig(overrides);\n    runtime = {\n      config,\n      execute: directExecute,\n      ...(config.mode === \"smtp\"\n        ? {\n            transporter: nodemailer.createTransport({\n              host: config.host,\n              port: config.port,\n              secure: config.secure,\n              auth: config.auth,\n            }),\n          }\n        : {}),\n    };\n  }\n  return runtime;\n}\n\n/**\n * Install the executor outbound sends run through. The plugin calls this at\n * setup with its own `execute()`; a second call replaces the previous one, so\n * a re-registered plugin does not leave the tools bound to a dead instance.\n */\nexport function setEmailExecutor(execute: EmailExecutor): void {\n  getEmailRuntime().execute = execute;\n}\n\n/**\n * Drop the memoized runtime, closing the SMTP connection pool, so the next\n * {@link getEmailRuntime} rebuilds it from fresh config and stops calling\n * through a torn-down plugin's `execute()`. Idempotent, and the plugin's\n * `shutdown()` hook.\n */\nexport function resetEmailRuntime(): void {\n  runtime?.transporter?.close();\n  runtime = undefined;\n}\n\n/**\n * Run one non-idempotent write through the shared executor and unwrap it.\n *\n * `execute()` never throws, so a failed send arrives as `{ ok: false }` with a\n * status the interceptors already sanitized; it is logged here and re-raised\n * as a stable {@link ExecutionError} so an upstream message never becomes the\n * caller's error text. `signal` is the caller's own cancellation (an agent\n * run, a request teardown); it is merged with the signal the timeout\n * interceptor supplies so either one unwinds the I/O.\n */\nexport async function executeWrite<T>(\n  operation: string,\n  settings: EmailExecutionSettings,\n  fn: (signal?: AbortSignal) => Promise<T>,\n  signal?: AbortSignal,\n): Promise<T> {\n  const { execute } = getEmailRuntime();\n  return execution.run({\n    operation,\n    settings,\n    execute,\n    fn,\n    signal,\n    canceled: ExecutionError.canceled,\n    failed: (failure) => {\n      logger.warn(\"execution-failed\", {\n        operation: failure.operation,\n        status: failure.status,\n        error: failure.message,\n      });\n      return new ExecutionError(`email: ${failure.operation} failed`, {\n        context: { operation: failure.operation, status: failure.status },\n      });\n    },\n  });\n}\n\n/**\n * Open and tear down one SMTP connection to prove the host, port, and\n * credentials work. Called at plugin setup so a bad relay shows up in the\n * boot logs rather than on the first approved send.\n */\nexport async function verifyEmailTransport(\n  transporter: Transporter | undefined,\n  signal?: AbortSignal,\n): Promise<void> {\n  if (!transporter) {\n    throw ConfigurationError.invalidConnection(\n      \"SMTP\",\n      \"The runtime resolved to outbox mode, so there is no transport to verify.\",\n    );\n  }\n  await abortable(transporter.verify(), signal);\n}\n\n/**\n * Stop awaiting `promise` as soon as `signal` aborts. nodemailer exposes no\n * cancellation hook, so the SMTP conversation itself finishes on its own\n * connection; what unwinds is the caller and everything downstream of it.\n */\nfunction abortable<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T> {\n  if (!signal) return promise;\n  signal.throwIfAborted();\n  // The listener is detached once the race settles so a long-lived run signal\n  // does not accumulate one per send.\n  const listener = new AbortController();\n  const aborted = new Promise<never>((_, reject) => {\n    signal.addEventListener(\"abort\", () => reject(signal.reason), {\n      once: true,\n      signal: listener.signal,\n    });\n  });\n  return Promise.race([promise, aborted]).finally(() => listener.abort());\n}\n\n/** The comma-joined recipient string echoed back in {@link EmailResult}. */\nfunction recipientEcho(to: string[]): string {\n  return to.join(\", \");\n}\n\n/**\n * Node buffer encodings a wire attachment may name for its inline `content`.\n * Anything else is measured as UTF-8, which over-counts rather than letting\n * an unrecognized encoding slip past the size cap.\n */\nconst CONTENT_ENCODINGS: ReadonlySet<string> = new Set([\n  \"ascii\",\n  \"base64\",\n  \"base64url\",\n  \"binary\",\n  \"hex\",\n  \"latin1\",\n  \"ucs2\",\n  \"ucs-2\",\n  \"utf8\",\n  \"utf-8\",\n  \"utf16le\",\n  \"utf-16le\",\n]);\n\n/**\n * Decoded byte size of one attachment's inline content. A `path` attachment\n * contributes nothing: nodemailer streams it, so its bytes never sit in this\n * process and cannot be measured here.\n */\nfunction attachmentBytes(attachment: EmailAttachment): number {\n  const { content, encoding } = attachment;\n  if (content === undefined) return 0;\n  const declared = encoding?.toLowerCase();\n  const resolved =\n    declared && CONTENT_ENCODINGS.has(declared) ? (declared as BufferEncoding) : \"utf8\";\n  return Buffer.byteLength(content, resolved);\n}\n\n/**\n * Reject a message whose body or attachments exceed the plugin's caps. The\n * body and attachment list arrive from a model, so they are unbounded until\n * something bounds them; most SMTP relays also reject an oversized message\n * only after the whole payload has been uploaded.\n */\nfunction assertMessageWithinCaps(message: EmailMessage): void {\n  if (message.body.length > MAX_BODY_CHARS) {\n    throw ValidationError.invalidValue(\n      \"body\",\n      message.body.length,\n      `at most ${MAX_BODY_CHARS} characters`,\n    );\n  }\n  const attachments = message.attachments ?? [];\n  if (attachments.length > MAX_ATTACHMENT_COUNT) {\n    throw ValidationError.invalidValue(\n      \"attachments\",\n      attachments.length,\n      `at most ${MAX_ATTACHMENT_COUNT} files`,\n    );\n  }\n  let total = 0;\n  for (const attachment of attachments) {\n    const bytes = attachmentBytes(attachment);\n    if (bytes > MAX_ATTACHMENT_BYTES) {\n      throw ValidationError.invalidValue(\n        \"attachments[].content\",\n        bytes,\n        `at most ${MAX_ATTACHMENT_BYTES} bytes per file`,\n      );\n    }\n    total += bytes;\n  }\n  if (total > MAX_ATTACHMENTS_TOTAL_BYTES) {\n    throw ValidationError.invalidValue(\n      \"attachments\",\n      total,\n      `at most ${MAX_ATTACHMENTS_TOTAL_BYTES} bytes across all files`,\n    );\n  }\n}\n\n/**\n * Map the wire-format {@link EmailAttachment}s onto nodemailer's\n * attachment shape, dropping unset optional keys so nodemailer applies\n * its own defaults (utf-8 encoding, filename-inferred content type). The\n * wire fields are a deliberate subset of nodemailer's, so this is a\n * straight structural pass-through.\n */\nfunction toMailAttachments(\n  attachments: EmailAttachment[] | undefined,\n): SendMailOptions[\"attachments\"] {\n  if (!attachments || attachments.length === 0) return undefined;\n  return attachments.map((att) => ({\n    filename: att.filename,\n    ...(att.content !== undefined ? { content: att.content } : {}),\n    ...(att.encoding !== undefined ? { encoding: att.encoding } : {}),\n    ...(att.path !== undefined ? { path: att.path } : {}),\n    ...(att.contentType !== undefined ? { contentType: att.contentType } : {}),\n  }));\n}\n\n/**\n * Hand one already-validated message to SMTP, or write it to the outbox when\n * no credentials are configured. The half of a send that performs I/O, so it\n * is what runs inside the interceptor chain.\n */\nasync function dispatch(\n  message: EmailMessage,\n  from: string,\n  signal?: AbortSignal,\n  options?: SendEmailOptions,\n): Promise<EmailResult> {\n  const { config, transporter } = getEmailRuntime();\n  const recipient = recipientEcho(message.to);\n  signal?.throwIfAborted();\n\n  if (config.mode === \"file\") {\n    const path = await writeOutboxEmail(message, from, config.outDir, config.brand, options);\n    return { sent: true, recipient, from, messageId: path };\n  }\n\n  if (!transporter) {\n    throw ConfigurationError.invalidConnection(\n      \"SMTP\",\n      \"No transport was built for the resolved configuration.\",\n    );\n  }\n  const attachments = toMailAttachments(message.attachments);\n  const rendered = await renderEmail({\n    subject: message.subject,\n    body: message.body,\n    brand: config.brand,\n    ...object.optional(\"trailer\", options?.trailer),\n  });\n  const info = await abortable(\n    transporter.sendMail({\n      from,\n      to: message.to,\n      subject: message.subject,\n      text: rendered.text,\n      html: rendered.html,\n      ...(message.cc && message.cc.length > 0 ? { cc: message.cc } : {}),\n      ...(message.bcc && message.bcc.length > 0 ? { bcc: message.bcc } : {}),\n      ...(attachments ? { attachments } : {}),\n    }),\n    signal,\n  );\n  return {\n    sent: true,\n    recipient,\n    from,\n    ...(info.messageId ? { messageId: info.messageId } : {}),\n  };\n}\n\n/**\n * Delivery-time options that are NOT part of the message a model composes.\n *\n * Deliberately separate from {@link EmailMessage}: that schema is the agent\n * tool's input, so anything added to it becomes a field a model can set. A\n * trailer is a property of how the message is DELIVERED (it must be the final\n * line, and its content is derived from the deployment's own domain), so it is\n * the caller's to supply, never the model's.\n */\nexport interface SendEmailOptions {\n  /**\n   * A machine-read final line, after the branded footer - Apple's domain-bound\n   * one-time-code AutoFill trailer. Build it with\n   * `sharedEmailTemplate.autofillTrailer(domain, code)`.\n   */\n  trailer?: string;\n}\n\n/**\n * Send (SMTP mode) or persist (file/outbox mode) one message from the\n * resolved `from` address. `to` (and optional `cc` / `bcc`) each accept\n * one or more addresses, and `attachments` are forwarded as files. The\n * body is rendered by React Email into matching plain-text and HTML MIME\n * alternatives, and the outbox embeds the\n * rendered HTML in a document. In file mode the returned `messageId` is\n * the path written. Throws when `to` carries no recipient, when the body\n * or attachments exceed the plugin's caps, or when `from` is not permitted\n * by the effective sender allow-list.\n *\n * The recipient, cap, and sender checks run before the interceptor chain so\n * their specific status and actionable message reach the caller instead of\n * the chain's stable failure text. `signal` cancels the send.\n */\nexport async function sendEmail(\n  message: EmailMessage,\n  from: string,\n  signal?: AbortSignal,\n  options?: SendEmailOptions,\n): Promise<EmailResult> {\n  if (message.to.length === 0) {\n    throw ValidationError.missingField(\"to\");\n  }\n  assertMessageWithinCaps(message);\n  assertSenderAllowed(from, getEmailRuntime().config.allowedSenders);\n  return executeWrite(\n    \"send\",\n    EMAIL_SEND_SETTINGS,\n    (executeSignal) => dispatch(message, from, executeSignal, options),\n    signal,\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The email runtime: a lazily-built, process-wide dispatcher plus its\n * resolved config, and {@link sendEmail} which sends one\n * {@link EmailMessage} through it. In SMTP mode the runtime holds a\n * memoized nodemailer transport (shared by the plugin's setup and the\n * agent tool, so they reuse one connection pool); in file/outbox mode it\n * holds no transport and {@link sendEmail} writes HTML to disk instead.\n * The first caller (normally the plugin at setup) primes it with the\n * plugin's config; later callers reuse it.\n *\n * The runtime also carries the {@link EmailExecutor} every outbound send runs\n * through. The plugin installs its own `execute()` there at setup, which is\n * how the Mastra tool - a plain function with no plugin instance in scope -\n * still gets AppKit's retry / timeout / telemetry chain. Without a registered\n * plugin (a direct call from a script or a test) the send still runs, just\n * without interceptors.\n *\n * Every entry point takes an optional {@link AbortSignal} so the plugin's\n * `execute()` timeout and a client disconnect both stop the caller waiting\n * on SMTP.\n *\n * @module\n */\n\nimport {\n  ConfigurationError,\n  ExecutionError,\n  ValidationError,\n  type ExecutionResult,\n} from \"@databricks/appkit\";\nimport { execution, log } from \"@dbx-tools/shared-core\";\nimport type { EmailAttachment, EmailMessage, EmailResult } from \"@dbx-tools/shared-email\";\nimport nodemailer, { type SendMailOptions, type Transporter } from \"nodemailer\";\nimport { resolveEmailConfig, type EmailPluginConfig, type ResolvedEmailConfig } from \"./config.ts\";\nimport {\n  EMAIL_SEND_SETTINGS,\n  MAX_ATTACHMENT_BYTES,\n  MAX_ATTACHMENT_COUNT,\n  MAX_ATTACHMENTS_TOTAL_BYTES,\n  MAX_BODY_CHARS,\n  type EmailExecutionSettings,\n} from \"./defaults.ts\";\nimport { renderEmail } from \"./email-html.ts\";\nimport { writeOutboxEmail } from \"./outbox.ts\";\nimport { assertSenderAllowed } from \"./sender.ts\";\n\nconst logger = log.logger(\"email/transport\");\n\n/**\n * Runs one outbound send through AppKit's interceptor chain. Matches\n * `Plugin.execute()`, which never throws: a failure comes back as\n * `{ ok: false }`.\n */\nexport type EmailExecutor = <T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  settings: EmailExecutionSettings,\n) => Promise<ExecutionResult<T>>;\n\n/** The shared dispatcher, its resolved config, and the send executor. */\nexport interface EmailRuntime {\n  /** Present only in SMTP mode. */\n  transporter?: Transporter;\n  config: ResolvedEmailConfig;\n  execute: EmailExecutor;\n}\n\n/**\n * Executor used until (or unless) the plugin installs its own: run the send\n * directly, mapping a throw onto the same {@link ExecutionResult} shape so\n * call sites branch on `ok` either way.\n */\nconst directExecute = execution.directExecutor<EmailExecutionSettings>();\n\nlet runtime: EmailRuntime | undefined;\n\n/**\n * Return the shared runtime, building it on first use by resolving\n * `overrides` over the environment (`SMTP_HOST`, `SMTP_PORT`,\n * `SMTP_SECURE`, `SMTP_USER`, `SMTP_PASSWORD`, `EMAIL_DOMAIN`,\n * `EMAIL_FROM`, `EMAIL_ALLOWED_SENDERS`, `EMAIL_SENDER_POLICY`,\n * `EMAIL_OUTBOX_MODE`, `EMAIL_OUTBOX_DIR`) through\n * {@link resolveEmailConfig}. With SMTP credentials present it holds a\n * nodemailer transport and its connection pool; otherwise it is in\n * file/outbox mode and holds none.\n *\n * `overrides` is read only on the call that builds the runtime, so prime it\n * from the plugin's config at setup; later callers (the tool's `execute`,\n * the sender-options route) pass nothing and get the same instance. Throws\n * whatever {@link resolveEmailConfig} throws for an unusable configuration.\n */\nexport function getEmailRuntime(overrides?: EmailPluginConfig): EmailRuntime {\n  if (!runtime) {\n    const config = resolveEmailConfig(overrides);\n    runtime = {\n      config,\n      execute: directExecute,\n      ...(config.mode === \"smtp\"\n        ? {\n            transporter: nodemailer.createTransport({\n              host: config.host,\n              port: config.port,\n              secure: config.secure,\n              auth: config.auth,\n            }),\n          }\n        : {}),\n    };\n  }\n  return runtime;\n}\n\n/**\n * Install the executor outbound sends run through. The plugin calls this at\n * setup with its own `execute()`; a second call replaces the previous one, so\n * a re-registered plugin does not leave the tools bound to a dead instance.\n */\nexport function setEmailExecutor(execute: EmailExecutor): void {\n  getEmailRuntime().execute = execute;\n}\n\n/**\n * Drop the memoized runtime, closing the SMTP connection pool, so the next\n * {@link getEmailRuntime} rebuilds it from fresh config and stops calling\n * through a torn-down plugin's `execute()`. Idempotent, and the plugin's\n * `shutdown()` hook.\n */\nexport function resetEmailRuntime(): void {\n  runtime?.transporter?.close();\n  runtime = undefined;\n}\n\n/**\n * Run one non-idempotent write through the shared executor and unwrap it.\n *\n * `execute()` never throws, so a failed send arrives as `{ ok: false }` with a\n * status the interceptors already sanitized; it is logged here and re-raised\n * as a stable {@link ExecutionError} so an upstream message never becomes the\n * caller's error text. `signal` is the caller's own cancellation (an agent\n * run, a request teardown); it is merged with the signal the timeout\n * interceptor supplies so either one unwinds the I/O.\n */\nexport async function executeWrite<T>(\n  operation: string,\n  settings: EmailExecutionSettings,\n  fn: (signal?: AbortSignal) => Promise<T>,\n  signal?: AbortSignal,\n): Promise<T> {\n  const { execute } = getEmailRuntime();\n  return execution.run({\n    operation,\n    settings,\n    execute,\n    fn,\n    signal,\n    canceled: ExecutionError.canceled,\n    failed: (failure) => {\n      logger.warn(\"execution-failed\", {\n        operation: failure.operation,\n        status: failure.status,\n        error: failure.message,\n      });\n      return new ExecutionError(`email: ${failure.operation} failed`, {\n        context: { operation: failure.operation, status: failure.status },\n      });\n    },\n  });\n}\n\n/**\n * Open and tear down one SMTP connection to prove the host, port, and\n * credentials work. Called at plugin setup so a bad relay shows up in the\n * boot logs rather than on the first approved send.\n */\nexport async function verifyEmailTransport(\n  transporter: Transporter | undefined,\n  signal?: AbortSignal,\n): Promise<void> {\n  if (!transporter) {\n    throw ConfigurationError.invalidConnection(\n      \"SMTP\",\n      \"The runtime resolved to outbox mode, so there is no transport to verify.\",\n    );\n  }\n  await abortable(transporter.verify(), signal);\n}\n\n/**\n * Stop awaiting `promise` as soon as `signal` aborts. nodemailer exposes no\n * cancellation hook, so the SMTP conversation itself finishes on its own\n * connection; what unwinds is the caller and everything downstream of it.\n */\nfunction abortable<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T> {\n  if (!signal) return promise;\n  signal.throwIfAborted();\n  // The listener is detached once the race settles so a long-lived run signal\n  // does not accumulate one per send.\n  const listener = new AbortController();\n  const aborted = new Promise<never>((_, reject) => {\n    signal.addEventListener(\"abort\", () => reject(signal.reason), {\n      once: true,\n      signal: listener.signal,\n    });\n  });\n  return Promise.race([promise, aborted]).finally(() => listener.abort());\n}\n\n/** The comma-joined recipient string echoed back in {@link EmailResult}. */\nfunction recipientEcho(to: string[]): string {\n  return to.join(\", \");\n}\n\n/**\n * Node buffer encodings a wire attachment may name for its inline `content`.\n * Anything else is measured as UTF-8, which over-counts rather than letting\n * an unrecognized encoding slip past the size cap.\n */\nconst CONTENT_ENCODINGS: ReadonlySet<string> = new Set([\n  \"ascii\",\n  \"base64\",\n  \"base64url\",\n  \"binary\",\n  \"hex\",\n  \"latin1\",\n  \"ucs2\",\n  \"ucs-2\",\n  \"utf8\",\n  \"utf-8\",\n  \"utf16le\",\n  \"utf-16le\",\n]);\n\n/**\n * Decoded byte size of one attachment's inline content. A `path` attachment\n * contributes nothing: nodemailer streams it, so its bytes never sit in this\n * process and cannot be measured here.\n */\nfunction attachmentBytes(attachment: EmailAttachment): number {\n  const { content, encoding } = attachment;\n  if (content === undefined) return 0;\n  const declared = encoding?.toLowerCase();\n  const resolved =\n    declared && CONTENT_ENCODINGS.has(declared) ? (declared as BufferEncoding) : \"utf8\";\n  return Buffer.byteLength(content, resolved);\n}\n\n/**\n * Reject a message whose body or attachments exceed the plugin's caps. The\n * body and attachment list arrive from a model, so they are unbounded until\n * something bounds them; most SMTP relays also reject an oversized message\n * only after the whole payload has been uploaded.\n */\nfunction assertMessageWithinCaps(message: EmailMessage): void {\n  if (message.body.length > MAX_BODY_CHARS) {\n    throw ValidationError.invalidValue(\n      \"body\",\n      message.body.length,\n      `at most ${MAX_BODY_CHARS} characters`,\n    );\n  }\n  const attachments = message.attachments ?? [];\n  if (attachments.length > MAX_ATTACHMENT_COUNT) {\n    throw ValidationError.invalidValue(\n      \"attachments\",\n      attachments.length,\n      `at most ${MAX_ATTACHMENT_COUNT} files`,\n    );\n  }\n  let total = 0;\n  for (const attachment of attachments) {\n    const bytes = attachmentBytes(attachment);\n    if (bytes > MAX_ATTACHMENT_BYTES) {\n      throw ValidationError.invalidValue(\n        \"attachments[].content\",\n        bytes,\n        `at most ${MAX_ATTACHMENT_BYTES} bytes per file`,\n      );\n    }\n    total += bytes;\n  }\n  if (total > MAX_ATTACHMENTS_TOTAL_BYTES) {\n    throw ValidationError.invalidValue(\n      \"attachments\",\n      total,\n      `at most ${MAX_ATTACHMENTS_TOTAL_BYTES} bytes across all files`,\n    );\n  }\n}\n\n/**\n * Map the wire-format {@link EmailAttachment}s onto nodemailer's\n * attachment shape, dropping unset optional keys so nodemailer applies\n * its own defaults (utf-8 encoding, filename-inferred content type). The\n * wire fields are a deliberate subset of nodemailer's, so this is a\n * straight structural pass-through.\n */\nfunction toMailAttachments(\n  attachments: EmailAttachment[] | undefined,\n): SendMailOptions[\"attachments\"] {\n  if (!attachments || attachments.length === 0) return undefined;\n  return attachments.map((att) => ({\n    filename: att.filename,\n    ...(att.content !== undefined ? { content: att.content } : {}),\n    ...(att.encoding !== undefined ? { encoding: att.encoding } : {}),\n    ...(att.path !== undefined ? { path: att.path } : {}),\n    ...(att.contentType !== undefined ? { contentType: att.contentType } : {}),\n  }));\n}\n\n/**\n * Hand one already-validated message to SMTP, or write it to the outbox when\n * no credentials are configured. The half of a send that performs I/O, so it\n * is what runs inside the interceptor chain.\n */\nasync function dispatch(\n  message: EmailMessage,\n  from: string,\n  signal?: AbortSignal,\n  options?: SendEmailOptions,\n): Promise<EmailResult> {\n  const { config, transporter } = getEmailRuntime();\n  const recipient = recipientEcho(message.to);\n  signal?.throwIfAborted();\n\n  if (config.mode === \"file\") {\n    const path = await writeOutboxEmail(message, from, config.outDir, config.brand);\n    return { sent: true, recipient, from, messageId: path };\n  }\n\n  if (!transporter) {\n    throw ConfigurationError.invalidConnection(\n      \"SMTP\",\n      \"No transport was built for the resolved configuration.\",\n    );\n  }\n  const attachments = toMailAttachments(message.attachments);\n  const rendered = await renderEmail({\n    subject: message.subject,\n    body: message.body,\n    brand: config.brand,\n  });\n  const info = await abortable(\n    transporter.sendMail({\n      from,\n      to: message.to,\n      subject: message.subject,\n      // A caller-supplied plain-text part WINS over the generated one. Both parts\n      // still come from the same content; this only lets a caller control the\n      // text alternative's exact line layout, which some clients parse (see\n      // `SendEmailOptions.text`).\n      text: options?.text ?? rendered.text,\n      html: rendered.html,\n      ...(message.cc && message.cc.length > 0 ? { cc: message.cc } : {}),\n      ...(message.bcc && message.bcc.length > 0 ? { bcc: message.bcc } : {}),\n      ...(attachments ? { attachments } : {}),\n    }),\n    signal,\n  );\n  return {\n    sent: true,\n    recipient,\n    from,\n    ...(info.messageId ? { messageId: info.messageId } : {}),\n  };\n}\n\n/**\n * Delivery-time options that are NOT part of the message a model composes.\n *\n * Deliberately separate from {@link EmailMessage}: that schema is the agent\n * tool's input, so anything added to it becomes a field a model can set. These\n * describe how a message is DELIVERED, so they are the caller's to supply.\n */\nexport interface SendEmailOptions {\n  /**\n   * An explicit `text/plain` alternative, replacing the one generated from the\n   * React Email tree. The HTML part is untouched, so the recipient still gets the\n   * full branded template.\n   *\n   * This exists because the generated text part is a RENDERING of the HTML: it\n   * carries the brand header and footer, and it turns CSS margin into blank\n   * lines. That is fine for prose and wrong for content a machine parses. A\n   * one-time-code email is the case in point - clients look for the code on the\n   * line immediately after the prompt, and a styled `<h2>` code lands two blank\n   * lines below it, so autofill stops being offered even though the HTML looks\n   * perfect. Supplying the text part directly keeps the nice template AND the\n   * layout those clients expect.\n   *\n   * Keep the same information in both parts; a text alternative that disagrees\n   * with the HTML reads as phishing to spam filters.\n   */\n  text?: string;\n}\n\n/**\n * Send (SMTP mode) or persist (file/outbox mode) one message from the\n * resolved `from` address. `to` (and optional `cc` / `bcc`) each accept\n * one or more addresses, and `attachments` are forwarded as files. The\n * body is rendered by React Email into matching plain-text and HTML MIME\n * alternatives, and the outbox embeds the\n * rendered HTML in a document. In file mode the returned `messageId` is\n * the path written. Throws when `to` carries no recipient, when the body\n * or attachments exceed the plugin's caps, or when `from` is not permitted\n * by the effective sender allow-list.\n *\n * The recipient, cap, and sender checks run before the interceptor chain so\n * their specific status and actionable message reach the caller instead of\n * the chain's stable failure text. `signal` cancels the send.\n */\nexport async function sendEmail(\n  message: EmailMessage,\n  from: string,\n  signal?: AbortSignal,\n  options?: SendEmailOptions,\n): Promise<EmailResult> {\n  if (message.to.length === 0) {\n    throw ValidationError.missingField(\"to\");\n  }\n  assertMessageWithinCaps(message);\n  assertSenderAllowed(from, getEmailRuntime().config.allowedSenders);\n  return executeWrite(\n    \"send\",\n    EMAIL_SEND_SETTINGS,\n    (executeSignal) => dispatch(message, from, executeSignal, options),\n    signal,\n  );\n}\n"]}

package/package.json

@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/shared-core": "0.6.53",
-    "@dbx-tools/shared-email": "0.6.53",
-    "@dbx-tools/shared-email-template": "0.6.53",
+    "@dbx-tools/shared-core": "0.6.55",
+    "@dbx-tools/shared-email": "0.6.55",
+    "@dbx-tools/shared-email-template": "0.6.55",
     "@mastra/core": "^1.47.0",
     "@react-email/render": "^2.1.0",
     "nodemailer": "^7.0.13",
@@ -50,7 +50,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.53",
+  "version": "0.6.55",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/config.ts

@@ -18,6 +18,7 @@
  * to a single SMTP server (e.g. SMTP2GO): `SMTP_HOST`, `SMTP_PORT`,
  * `SMTP_SECURE`, `SMTP_USER`, `SMTP_PASSWORD`, plus `EMAIL_DOMAIN` for
  * the derived sender's domain, `EMAIL_FROM` for an explicit override,
+ * `EMAIL_SYSTEM_FROM` for the do-not-reply address system mail sends from,
  * `EMAIL_SENDER_POLICY` for the sender restriction mode, and
  * `EMAIL_OUTBOX_DIR` for the outbox directory.
  *
@@ -28,7 +29,7 @@ import { ConfigurationError, ValidationError, type BasePluginConfig } from "@dat
 import { env, object } from "@dbx-tools/shared-core";
 import type { JSONSchema7 } from "json-schema";
 import { defaultEmailBrand, type EmailBrand } from "./brand.ts";
-import { parseAllowedSenders } from "./sender.ts";
+import { isSenderAllowed, parseAllowedSenders, systemSenderAddress } from "./sender.ts";
 
 /** SMTP submission port used when none is configured. */
 export const DEFAULT_SMTP_PORT = 587;
@@ -80,10 +81,24 @@ export interface EmailPluginConfig extends BasePluginConfig {
    */
   domain?: string;
   /**
-   * Explicit `From` address. When set, the sender is used verbatim and
-   * the per-user derivation is skipped. Falls back to `EMAIL_FROM`.
+   * Explicit `From` address, OPTIONAL. When set, the sender is used verbatim
+   * and the per-user derivation is skipped. Falls back to `EMAIL_FROM`.
+   *
+   * Leave it unset in most deployments: {@link domain} alone is enough, and
+   * mail then comes from the address of the person who caused it, which is what
+   * a recipient expects to be able to reply to.
    */
   from?: string;
+  /**
+   * `From` for SYSTEM mail - a send with no on-behalf-of user, such as a
+   * sign-in code or a password reset. Falls back to `EMAIL_SYSTEM_FROM`, then
+   * to `no-reply@<domain>`, then to {@link from}.
+   *
+   * Machine mail gets a do-not-reply address by default because a reply to it
+   * reaches nobody. Set this to route those replies somewhere real (a monitored
+   * `support@`) or to spell the local part differently (`donotreply@`).
+   */
+  systemFrom?: string;
   /**
    * Directory for the file/outbox fallback. Falls back to
    * `EMAIL_OUTBOX_DIR`, then `<cwd>/tmp`. Only used when SMTP
@@ -116,11 +131,16 @@ export interface EmailPluginConfig extends BasePluginConfig {
 }
 
 /** Config shared by both resolved modes. */
-interface ResolvedSender {
+export interface ResolvedSender {
   /** Sender domain; present whenever {@link from} is absent. */
   domain?: string;
   /** Explicit sender override; present skips per-user derivation. */
   from?: string;
+  /**
+   * Explicit do-not-reply sender for system mail. Absent means it is derived -
+   * see {@link systemSenderAddress}.
+   */
+  systemFrom?: string;
   /**
    * Effective sender allow-list: the configured patterns when any were
    * given, else the patterns implied by the sender source under an
@@ -184,7 +204,13 @@ export const EMAIL_CONFIG_SCHEMA: JSONSchema7 = {
     },
     from: {
       type: "string",
-      description: "Explicit From address; skips per-user derivation. Falls back to EMAIL_FROM.",
+      description:
+        "Optional explicit From address; skips per-user derivation. Falls back to EMAIL_FROM.",
+    },
+    systemFrom: {
+      type: "string",
+      description:
+        "From for system mail (no on-behalf-of user, e.g. a sign-in code). Falls back to EMAIL_SYSTEM_FROM, then no-reply@<domain>, then from.",
     },
     outDir: {
       type: "string",
@@ -262,10 +288,21 @@ function resolveSenderPolicy(policy: SenderPolicy | undefined): SenderPolicy {
  * which only happens in outbox mode (where the sender falls back to the
  * on-behalf-of user's own address and cannot be enumerated up front).
  */
-function impliedSenderPatterns(domain: string | undefined, from: string | undefined): string[] {
+function impliedSenderPatterns(sender: {
+  domain?: string;
+  from?: string;
+  systemFrom?: string;
+}): string[] {
   const patterns: string[] = [];
-  if (from) patterns.push(from.trim().toLowerCase());
-  if (domain) patterns.push(`*@${domain.trim().toLowerCase()}`);
+  if (sender.from) patterns.push(sender.from.trim().toLowerCase());
+  if (sender.domain) patterns.push(`*@${sender.domain.trim().toLowerCase()}`);
+  // The system sender too, when the patterns above do not already cover it: it
+  // is an address this app SENDS from, so a list derived from the sender source
+  // has to permit it, or the very policy meant to describe the app's own senders
+  // denies its sign-in mail. Usually redundant (`*@domain` already matches
+  // `no-reply@domain`) - it matters for a `systemFrom` on another domain.
+  const system = systemSenderAddress(sender)?.toLowerCase();
+  if (system && !isSenderAllowed(system, patterns)) patterns.push(system);
   return patterns;
 }
 
@@ -290,8 +327,9 @@ function missingSmtpFields(
  * Resolve plugin config over environment defaults.
  *
  * When SMTP host + user + password are all present, returns `mode:
- * "smtp"` for real delivery (and throws if no sender source - domain or
- * from - is configured, since SMTP can't derive one from nothing).
+ * "smtp"` for real delivery (and throws if no sender source - domain,
+ * from, or systemFrom - is configured, since SMTP can't derive one from
+ * nothing; `domain` alone is the intended minimum).
  * When all three are absent and `EMAIL_OUTBOX_MODE` is enabled, returns
  * `mode: "file"` so the runtime writes messages to the outbox directory
  * for local testing; in that mode a sender source is optional (the
@@ -311,6 +349,7 @@ export function resolveEmailConfig(config: EmailPluginConfig = {}): ResolvedEmai
   const pass = env.string(smtp.password, "SMTP_PASSWORD") ?? undefined;
   const domain = env.string(config.domain, "EMAIL_DOMAIN") ?? undefined;
   const from = env.string(config.from, "EMAIL_FROM") ?? undefined;
+  const systemFrom = env.string(config.systemFrom, "EMAIL_SYSTEM_FROM") ?? undefined;
   const senderPolicy = resolveSenderPolicy(config.senderPolicy);
   const configuredSenders = parseAllowedSenders(
     config.allowedSenders ?? env.text("EMAIL_ALLOWED_SENDERS") ?? undefined,
@@ -318,10 +357,11 @@ export function resolveEmailConfig(config: EmailPluginConfig = {}): ResolvedEmai
   const allowedSenders =
     configuredSenders.length > 0 || senderPolicy === "unrestricted"
       ? configuredSenders
-      : impliedSenderPatterns(domain, from);
+      : impliedSenderPatterns({ domain, from, systemFrom });
   const sender: ResolvedSender = {
     ...object.optional("domain", domain),
     ...object.optional("from", from),
+    ...object.optional("systemFrom", systemFrom),
     allowedSenders,
     senderPolicy,
     brand: config.brand ?? defaultEmailBrand,
@@ -335,10 +375,10 @@ export function resolveEmailConfig(config: EmailPluginConfig = {}): ResolvedEmai
   }
 
   if (hasAllSmtp) {
-    if (!domain && !from) {
+    if (!domain && !from && !systemFrom) {
       throw ConfigurationError.resourceNotFound(
         "Email sender source",
-        "Set EMAIL_DOMAIN to derive <user-local-part>@<domain>, or EMAIL_FROM for a fixed address.",
+        "Set EMAIL_DOMAIN to derive <user-local-part>@<domain> (and no-reply@<domain> for system mail), or EMAIL_FROM for a fixed address.",
       );
     }
     const port = env.positiveInt(smtp.port, "SMTP_PORT", DEFAULT_SMTP_PORT);

package/src/outbox.ts

@@ -55,7 +55,6 @@ export async function writeOutboxEmail(
   from: string,
   dir: string,
   brand?: EmailBrand,
-  options?: { trailer?: string },
 ): Promise<string> {
   const folder = resolve(dir, from);
   await mkdir(folder, { recursive: true });
@@ -66,9 +65,6 @@ export async function writeOutboxEmail(
     body: message.body,
     footer: "Local outbox preview - written to disk, not sent (no SMTP credentials configured).",
     ...(brand ? { brand } : {}),
-    // Preserved so the preview shows the trailer in the same place a real send
-    // puts it - the whole point being that it is the LAST line.
-    ...(options?.trailer ? { trailer: options.trailer } : {}),
   });
   await writeFile(path, html, "utf8");
   return path;

package/src/plugin.ts

@@ -243,11 +243,6 @@ export class EmailPlugin extends Plugin<EmailPluginConfig> implements ToolProvid
        * Send a message immediately from `from` through the shared
        * transport, bypassing the approval flow. For agent-driven sends
        * use {@link emailTool} instead.
-       *
-       * `options` carries delivery-time concerns that are deliberately NOT part of
-       * the message schema an agent fills in - see {@link SendEmailOptions}. The
-       * agent tool path never supplies them, which is the point: a trailer is
-       * derived from the deployment's own domain, not from model output.
        */
       sendEmail: (
         message: EmailMessage,
@@ -282,10 +277,6 @@ export class EmailPlugin extends Plugin<EmailPluginConfig> implements ToolProvid
    * `from` is not pinned. The interceptor chain is applied inside
    * {@link sendEmail} through the executor installed at setup, so this must
    * not wrap it again.
-   *
-   * `options` is forwarded untouched so every caller of this plugin reaches the
-   * same shared template features the module-level {@link sendEmail} does; the
-   * agent tool path simply omits it.
    */
   private async send(
     message: EmailMessage,

package/src/sender.ts

@@ -5,9 +5,15 @@
  * 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.
+ * `alice@mail.example.com`. Nothing has to be configured for that beyond the
+ * domain: a fixed `from` is an OVERRIDE, not a requirement. The file/outbox
+ * fallback (no domain) keeps the user's address verbatim so test artifacts land
+ * under a recognizable folder.
+ *
+ * A send with NO user in scope is SYSTEM mail - a sign-in code, a password
+ * reset, an alert - and goes from the do-not-reply address instead
+ * ({@link resolveSystemSenderAddress}), because a recipient cannot usefully
+ * reply to a machine and a human's address on machine mail invites them to try.
  *
  * The resolved `From` is then constrained to the effective allow-list: a
  * pattern is either an exact address (`user@domain.com`), a domain wildcard
@@ -22,15 +28,16 @@
  */
 
 import { ConfigurationError, ValidationError } from "@databricks/appkit";
-import { log, net } from "@dbx-tools/shared-core";
+import { log, net, string } from "@dbx-tools/shared-core";
 
-import type { ResolvedEmailConfig } from "./config.ts";
+import type { ResolvedEmailConfig, ResolvedSender } from "./config.ts";
 
 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).
+ * Re-home a user's local part on `domain`. Throws when no usable local part is
+ * available; callers with no user in scope want
+ * {@link resolveSystemSenderAddress} instead of a fixed `from`.
  */
 export function deriveSenderAddress(userEmail: string | undefined, domain: string): string {
   const local = userEmail?.split("@")[0]?.trim();
@@ -101,25 +108,68 @@ export function assertSenderAllowed(from: string, patterns: string[]): void {
   );
 }
 
+/**
+ * Local part of the default do-not-reply sender, used for mail that no user
+ * asked for and nobody can reply to.
+ */
+export const SYSTEM_SENDER_LOCAL_PART = "no-reply";
+
+/** The sender fields {@link systemSenderAddress} reads, resolved or raw. */
+type SenderSource = Pick<ResolvedSender, "systemFrom" | "domain" | "from">;
+
+/**
+ * The address SYSTEM mail sends from, or undefined when nothing configured
+ * yields one: an explicit {@link ResolvedSender.systemFrom} wins, else
+ * `no-reply@<domain>`, else the fixed `from`.
+ *
+ * `no-reply@<domain>` outranks a configured `from` on purpose. A fixed `from` is
+ * typically a person or a team address chosen for mail a HUMAN sent, and a
+ * verification code arriving from it invites a reply nobody reads. Set
+ * `systemFrom` / EMAIL_SYSTEM_FROM to name the address explicitly (a monitored
+ * `support@`, a differently-spelled `donotreply@`).
+ *
+ * Returns undefined rather than throwing so config resolution can fold the
+ * result into the sender allow-list before any send happens.
+ */
+export function systemSenderAddress(source: SenderSource): string | undefined {
+  const explicit = string.trimToNull(source.systemFrom);
+  if (explicit) return explicit;
+  const domain = string.trimToNull(source.domain);
+  if (domain) return `${SYSTEM_SENDER_LOCAL_PART}@${domain}`;
+  return string.trimToNull(source.from) ?? undefined;
+}
+
+/**
+ * The `From` for a send with no user in scope. Throws when no sender source is
+ * configured at all, which in SMTP mode {@link resolveEmailConfig} has already
+ * ruled out - so this only fires for an outbox with nothing configured.
+ */
+export function resolveSystemSenderAddress(config: ResolvedEmailConfig): string {
+  const address = systemSenderAddress(config);
+  if (address) return address;
+  throw ConfigurationError.resourceNotFound(
+    "Email sender address",
+    "Set `domain` / EMAIL_DOMAIN to send system mail as no-reply@<domain>, or `systemFrom` / EMAIL_SYSTEM_FROM to name the address.",
+  );
+}
+
 /**
  * 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.
+ * current OBO user.
+ *
+ * With a user in scope: an explicit `from` wins, then `<local>@<domain>`, then
+ * (file/outbox mode only) the user's email verbatim. With NO user the send is
+ * system mail, so it goes from {@link resolveSystemSenderAddress}. Throws when
+ * none of those yield an address.
  */
 export function resolveSenderAddress(
   config: ResolvedEmailConfig,
   userEmail: string | undefined,
 ): string {
+  const email = string.trimToNull(userEmail);
+  if (!email) return resolveSystemSenderAddress(config);
   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.",
-    );
-  }
+  if (config.domain) return deriveSenderAddress(email, config.domain);
   return email;
 }
 

package/src/transport.ts

@@ -28,7 +28,7 @@ import {
   ValidationError,
   type ExecutionResult,
 } from "@databricks/appkit";
-import { execution, log, object } from "@dbx-tools/shared-core";
+import { execution, log } from "@dbx-tools/shared-core";
 import type { EmailAttachment, EmailMessage, EmailResult } from "@dbx-tools/shared-email";
 import nodemailer, { type SendMailOptions, type Transporter } from "nodemailer";
 import { resolveEmailConfig, type EmailPluginConfig, type ResolvedEmailConfig } from "./config.ts";
@@ -322,7 +322,7 @@ async function dispatch(
   signal?.throwIfAborted();
 
   if (config.mode === "file") {
-    const path = await writeOutboxEmail(message, from, config.outDir, config.brand, options);
+    const path = await writeOutboxEmail(message, from, config.outDir, config.brand);
     return { sent: true, recipient, from, messageId: path };
   }
 
@@ -337,14 +337,17 @@ async function dispatch(
     subject: message.subject,
     body: message.body,
     brand: config.brand,
-    ...object.optional("trailer", options?.trailer),
   });
   const info = await abortable(
     transporter.sendMail({
       from,
       to: message.to,
       subject: message.subject,
-      text: rendered.text,
+      // A caller-supplied plain-text part WINS over the generated one. Both parts
+      // still come from the same content; this only lets a caller control the
+      // text alternative's exact line layout, which some clients parse (see
+      // `SendEmailOptions.text`).
+      text: options?.text ?? rendered.text,
       html: rendered.html,
       ...(message.cc && message.cc.length > 0 ? { cc: message.cc } : {}),
       ...(message.bcc && message.bcc.length > 0 ? { bcc: message.bcc } : {}),
@@ -364,18 +367,28 @@ async function dispatch(
  * Delivery-time options that are NOT part of the message a model composes.
  *
  * Deliberately separate from {@link EmailMessage}: that schema is the agent
- * tool's input, so anything added to it becomes a field a model can set. A
- * trailer is a property of how the message is DELIVERED (it must be the final
- * line, and its content is derived from the deployment's own domain), so it is
- * the caller's to supply, never the model's.
+ * tool's input, so anything added to it becomes a field a model can set. These
+ * describe how a message is DELIVERED, so they are the caller's to supply.
  */
 export interface SendEmailOptions {
   /**
-   * A machine-read final line, after the branded footer - Apple's domain-bound
-   * one-time-code AutoFill trailer. Build it with
-   * `sharedEmailTemplate.autofillTrailer(domain, code)`.
+   * An explicit `text/plain` alternative, replacing the one generated from the
+   * React Email tree. The HTML part is untouched, so the recipient still gets the
+   * full branded template.
+   *
+   * This exists because the generated text part is a RENDERING of the HTML: it
+   * carries the brand header and footer, and it turns CSS margin into blank
+   * lines. That is fine for prose and wrong for content a machine parses. A
+   * one-time-code email is the case in point - clients look for the code on the
+   * line immediately after the prompt, and a styled `<h2>` code lands two blank
+   * lines below it, so autofill stops being offered even though the HTML looks
+   * perfect. Supplying the text part directly keeps the nice template AND the
+   * layout those clients expect.
+   *
+   * Keep the same information in both parts; a text alternative that disagrees
+   * with the HTML reads as phishing to spam filters.
    */
-  trailer?: string;
+  text?: string;
 }
 
 /**