@jini-ai/agent-plugins 0.6.17 → 0.6.19

package/render/deploy-ops/render.mjs

@@ -0,0 +1,152 @@
+/** Render REST adapter. The host owns credentials, HTTP policy, cancellation and polling. */
+const API = "https://api.render.com/v1";
+const SERVER_TYPES = ["web_service", "private_service", "background_worker"];
+
+/** Validate before encoding: a target or deployment is one bounded opaque path segment. */
+function segment({ ctx, value, prefix }, _options = {}) {
+  if (typeof value !== "string" || !value.startsWith(prefix) || !/^[A-Za-z0-9_-]+$/.test(value)) ctx.fail("Use a valid Render service or deployment ID.");
+  if (value.length <= prefix.length || value.length > 128) ctx.fail("Use a valid Render service or deployment ID.");
+  return encodeURIComponent(value);
+}
+function serviceUrl({ ctx, target }, _options = {}) {
+  return `${API}/services/${segment({ ctx, value: target, prefix: "srv-" })}`;
+}
+/** Reject unsuitable services rather than dispatching a static site or provisioning resources. */
+async function service({ ctx, target }, _options = {}) {
+  const response = await ctx.get(serviceUrl({ ctx, target }));
+  const found = response.json;
+  if (response.truncated || found?.id !== target) ctx.fail("Render did not return the requested service.");
+  if (!SERVER_TYPES.includes(found.type)) ctx.fail("Choose an existing Render server service; static sites and cron jobs are not supported.");
+  return found;
+}
+/** Read at most five 100-row pages. A full last page means the result may be incomplete.
+ * Values are projected away on each page, before they can enter an operation result. */
+async function pages({ ctx, url, field, project }, _options = {}) {
+  const items = []; let cursor;
+  for (let page = 0; page < 5; page++) {
+    const query = new URLSearchParams({ limit: "100" });
+    if (cursor) query.set("cursor", cursor);
+    const response = await ctx.get(`${url}${url.includes("?") ? "&" : "?"}${query}`);
+    const rows = listPage({ ctx, response });
+    items.push(...rows.map(row => project({ ctx, value: row?.[field] })));
+    if (rows.length < 100) return { items, truncated: false };
+    cursor = nextCursor({ ctx, rows, cursor });
+  }
+  return { items, truncated: true };
+}
+function listPage({ ctx, response }, _options = {}) {
+  const rows = response.json;
+  if (response.truncated || !Array.isArray(rows) || rows.length > 100) ctx.fail("Render returned an incomplete or invalid list.");
+  return rows;
+}
+function nextCursor({ ctx, rows, cursor }, _options = {}) {
+  const next = rows.at(-1)?.cursor;
+  if (typeof next !== "string" || !next || next.length > 2000 || next === cursor) ctx.fail("Render did not return a usable pagination cursor.");
+  return next;
+}
+function targetInfo({ ctx, value }, _options = {}) {
+  segment({ ctx, value: value?.id, prefix: "srv-" });
+  if (typeof value.name !== "string" || typeof value.type !== "string") ctx.fail("Render returned an invalid service entry.");
+  return { id: value.id, name: value.name.slice(0, 2000), type: value.type };
+}
+/** Discovery is bounded; never present a capped inventory as a complete choice list. */
+async function listTargets(ctx, { org } = {}) {
+  const query = org === undefined ? "" : `?ownerId=${encodeURIComponent(org)}`;
+  const result = await pages({ ctx, url: `${API}/services${query}`, field: "service", project: targetInfo });
+  if (result.truncated) ctx.fail("Render service discovery reached 500 services. Narrow it with the workspace ID in org.");
+  return { platform: "render", targets: result.items.filter(item => SERVER_TYPES.includes(item.type)).map(({ id, name }) => ({ id, name })) };
+}
+/** Unknown provider states remain unknown so waiting cannot invent completion. */
+function overall({ state }, _options = {}) {
+  if (state === "live") return "healthy";
+  if (["build_failed", "update_failed", "pre_deploy_failed"].includes(state)) return "failing";
+  if (["canceled", "deactivated"].includes(state)) return "stopped";
+  if (["created", "queued", "build_in_progress", "pre_deploy_in_progress", "update_in_progress"].includes(state)) return "deploying";
+  return "unknown";
+}
+function deployment({ ctx, value, runId }, _options = {}) {
+  segment({ ctx, value: value?.id, prefix: "dep-" });
+  if (typeof value.status !== "string" || (runId !== undefined && value.id !== runId)) ctx.fail("Render did not return the requested deployment.");
+  return value;
+}
+/** The service-scoped endpoint enforces run ownership in this read, with no membership pre-query. */
+async function readDeployment({ ctx, target, runId }, _options = {}) {
+  const base = `${serviceUrl({ ctx, target })}/deploys`;
+  const suffix = runId === undefined ? "?limit=1" : `/${segment({ ctx, value: runId, prefix: "dep-" })}`;
+  const response = await ctx.get(`${base}${suffix}`);
+  if (response.truncated) ctx.fail("Render returned an incomplete deployment response.");
+  if (runId !== undefined) return deployment({ ctx, value: response.json, runId });
+  if (!Array.isArray(response.json)) ctx.fail("Render did not return a deployment list.");
+  if (!response.json.length) return undefined;
+  return deployment({ ctx, value: response.json[0]?.deploy });
+}
+async function status(ctx, { target, runId, branch }) {
+  if (branch !== undefined) ctx.fail("Render status uses a deployment ID, not a branch filter.");
+  const run = await readDeployment({ ctx, target, runId });
+  if (!run) return { platform: "render", target, state: "unknown", summary: "No Render deployments found.", items: [], checkedAt: ctx.nowIso() };
+  return { platform: "render", target, state: overall({ state: run.status }), summary: `Render deployment: ${run.status.slice(0, 2000)}`, items: [{ id: run.id, state: run.status.slice(0, 2000) }], checkedAt: ctx.nowIso() };
+}
+function validateRef({ ctx, ref }, _options = {}) {
+  if (ref !== undefined && (typeof ref !== "string" || !/^[0-9a-fA-F]{40}$/.test(ref))) ctx.fail("Render ref must be a full commit SHA; omit it to deploy the connected branch.");
+}
+/** A full SHA pins the commit; omission uses the service's connected branch. Never retry writes here. */
+async function deploy(ctx, { target, ref }) {
+  validateRef({ ctx, ref });
+  await service({ ctx, target });
+  const response = await ctx.send({ method: "POST", url: `${serviceUrl({ ctx, target })}/deploys`, body: ref === undefined ? {} : { commitId: ref } });
+  // 202 means queued behind a running deploy and carries no body, so there is no run ID to follow yet.
+  if (response.status === 202) return { platform: "render", target, started: true, ...(ref === undefined ? {} : { sha: ref }), summary: "Render queued the deployment behind one already running. Wait for the service's latest deployment status." };
+  if (response.truncated || response.status !== 201) ctx.fail("Render did not confirm deployment acceptance. Check Render before retrying.");
+  const runId = response.json?.id;
+  if (typeof runId !== "string" || !/^dep-[A-Za-z0-9_-]{1,124}$/.test(runId)) ctx.fail("Render accepted the request without a usable deployment ID. Check Render before retrying.");
+  return { platform: "render", target, started: true, runId, ...(ref === undefined ? {} : { sha: ref }), summary: "Render accepted the deployment. Check its status to see when it is live." };
+}
+/** Log labels are metadata; return no raw service or log response objects. */
+function logLine({ ctx, entry }, _options = {}) {
+  if (typeof entry?.message !== "string" || typeof entry.timestamp !== "string" || !Array.isArray(entry.labels)) ctx.fail("Render returned an invalid log entry.");
+  const level = entry.labels.find(label => label?.name === "level")?.value;
+  return { at: entry.timestamp.slice(0, 2000), ...(typeof level === "string" ? { level: level.slice(0, 2000) } : {}), message: entry.message.slice(0, 2000) };
+}
+/** One bounded service-log page. These are recent service logs, not a deploy-specific stream. */
+async function logs(ctx, { target, limit, runId, branch }) {
+  if (branch !== undefined) ctx.fail("Render logs do not support a branch filter.");
+  if (!Number.isInteger(limit) || limit < 1 || limit > 1000) ctx.fail("Render log limit must be between 1 and 1000.");
+  const found = await service({ ctx, target });
+  if (typeof found.ownerId !== "string" || !found.ownerId) ctx.fail("Render did not return the service workspace ID needed for logs.");
+  if (runId !== undefined) await readDeployment({ ctx, target, runId });
+  const query = new URLSearchParams({ ownerId: found.ownerId, resource: target, limit: String(Math.min(limit, 100)), direction: "backward" });
+  const response = await ctx.get(`${API}/logs?${query}`);
+  const entries = response.json?.logs;
+  if (!Array.isArray(entries)) ctx.fail("Render did not return a logs array.");
+  const lines = entries.slice(0, limit).map(entry => logLine({ ctx, entry }));
+  return { platform: "render", target, lines, truncated: logsTruncated({ response, entries, limit }) };
+}
+function logsTruncated({ response, entries, limit }, _options = {}) {
+  return response.truncated === true || response.json.hasMore === true || entries.length > limit || entries.slice(0, limit).some(entry => entry.message.length > 2000);
+}
+function secretInfo({ ctx, value }, _options = {}) {
+  if (typeof value?.key !== "string" || !value.key || value.key.length > 128) ctx.fail("Render returned an invalid environment variable key.");
+  return { name: value.key };
+}
+/** Only names leave this adapter; no value reads, digests or invented revision timestamps. */
+async function listSecrets(ctx, { target }) {
+  const result = await pages({ ctx, url: `${serviceUrl({ ctx, target })}/env-vars`, field: "envVar", project: secretInfo });
+  return { secrets: result.items, truncated: result.truncated };
+}
+function envUrl({ ctx, target, name }, _options = {}) {
+  if (typeof name !== "string" || !name || name.length > 128) ctx.fail("Use a valid Render environment variable key.");
+  if (name === "." || name === ".." || /[\x00-\x1f\x7f]/.test(name)) ctx.fail("Use a valid Render environment variable key.");
+  return `${serviceUrl({ ctx, target })}/env-vars/${encodeURIComponent(name)}`;
+}
+/** Per-key PUT preserves unrelated variables. The new value applies on the next deploy. */
+async function setSecret(ctx, { target, name, value }) {
+  await ctx.send({ method: "PUT", url: envUrl({ ctx, target, name }), body: { value } });
+  return {};
+}
+/** Host revision safeguards normally refuse this call: Render lists no revision metadata. */
+async function unsetSecret(ctx, { target, name }) {
+  await ctx.send({ method: "DELETE", url: envUrl({ ctx, target, name }) });
+  return {};
+}
+const secretCapabilities = { appliesOn: "next-deploy", supportsStaging: true };
+export default { listTargets, deploy, status, logs, secretCapabilities, listSecrets, setSecret, unsetSecret };

package/render/mcp.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  "mcpServers": {}
+}

package/render/plugin.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "render",
+  "version": "1.0.0",
+  "description": "Generates render.yaml and deploys existing Render server services through the API, with status, logs and environment variable tools.",
+  "author": "Tovu",
+  "license": "Apache-2.0",
+  "extensions": {
+    "tovu": {
+      "maturity": "soon",
+      "vendorAliases": ["render.com", "render.yaml", "onrender.com", "RENDER_API_KEY"],
+      "displayName": "Render",
+      "summary": "Configure and deploy an existing Render server service, then check its status and logs.",
+      "id": "tovu/render",
+      "provides": [
+        "deploy-config:render",
+        "deploy-ops:render"
+      ],
+      "credentialCards": [
+        {
+          "target": "render",
+          "title": "Connect Render",
+          "label": "Render API",
+          "ownedApiLabel": "Render API",
+          "category": "hosting",
+          "intro": "Save a Render API key for deploying this site from Tovu. Use it to look up existing services, deploy your server, check status and logs, and manage environment variables. Writing the deployment settings file needs no key. Untested: this connection hasn't been tried end to end yet.",
+          "usedFor": [
+            "Looks up your Render services",
+            "Deploys your server"
+          ],
+          "keyHint": "In Render, open Account Settings → API Keys → Create API Key. The key has the same access as your Render account, so use an account that can deploy the site's service.",
+          "saveKind": "api",
+          "helpUrl": "https://render.com/docs/api#1-create-an-api-key",
+          "helpLabel": "Create a Render API key",
+          "baseUrl": "https://api.render.com/v1",
+          "probeUrl": "https://api.render.com/v1/owners?limit=1"
+        }
+      ]
+    }
+  },
+  "keywords": [
+    "render",
+    "deploy",
+    "deploy-config:render",
+    "deploy-ops:render"
+  ]
+}

package/render/skills/render/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: render
+description: Configure and deploy existing Render server services, inspect status and recent logs, and stage environment variables securely.
+---
+
+# Render server deployment
+
+The in-app assistant uses tools, never Bash or a Render CLI. Reuse an existing,
+already-configured server service. Do not create paid resources, change billing,
+scale services or provision disks. Static sites and cron jobs are unsupported.
+Deploying ships code, not site content. Keep one server instance when its state
+lives on the persistent disk (SQLite), and configure that disk before deployment.
+Follow the host guidance first: it names how this host generates `render.yaml`.
+
+The `render.yaml` generator uses the host's server descriptor for the Dockerfile,
+port, health check, persistent disk and secret names, plus the non-secret variables
+the host passes. Secret values are never emitted; `sync: false` leaves them for
+secure setup.
+Writing `render.yaml` needs **no key**. Do not open a key card for that task.
+
+## Render API key
+
+Choose the card yourself from its `usedFor` list. Reuse a saved key or working
+sign-in for that task. Never offer a replacement unless the person asks.
+Check `content_read.custom_credential {}` for a saved key first.
+Otherwise open **Connect Render** with
+`credential_save { kind: "plugin-provider", target: "render" }`; it saves as `Render API`.
+The person creates the key under Account Settings → API Keys. A deploy hook URL
+is not a key.
+Saving a key deploys nothing. Untested: this connection has not been tried end to end.
+Never ask for a key in chat. Never offer to replace a working key unless asked.
+
+## Deploy and observe
+
+Use `deployment_ops_list_targets` with platform `render` to discover server
+services. Optional `org` filters by workspace ID. Choose the existing `srv-…`
+service; discovery refuses incomplete results at 500 services rather than hiding
+choices. Then use `deployment_ops_deploy` with that target. Omit `ref` to use the
+latest commit on the service's connected branch. Only a full 40-character commit
+SHA is supported as an explicit `ref`; branch and tag names are refused.
+The API must accept the request before the tool reports it started. A connection
+failure may mean the request was accepted: inspect Render before retrying.
+
+Keep the returned `dep-…` runId for `deployment_ops_status` and
+`deployment_ops_wait`. A deploy queued behind a running one returns no runId; wait on
+the service's latest deployment instead. Accepted does not mean live. Unknown states remain unknown.
+`deployment_ops_logs` resolves the service's workspace and returns a bounded page
+(at most 100 lines) of recent **service logs**, newest first, defaulting to Render's last-hour window.
+These logs are not isolated to the selected deployment; a supplied runId is
+checked through the service-scoped deployment endpoint. Branch filters are unsupported.
+Check the live service after the deployment becomes healthy.
+
+## Environment variables
+
+Use the existing deployment secret tools and masked entry/site-key source; never
+put values in chat. Listing returns names only, never values. Setting a key uses
+an individual-key PUT and preserves unrelated variables. Changes are staged and
+need a deployment to reach the running service. Set all needed keys, then deploy.
+The listing is capped at 500 and reports truncation. No secret readback or copying
+is provided. Render supplies no revision metadata for safe removal, so use the
+provider console to remove variables when the host refuses the removal tool.
+
+The Render API key card checks access with a read-only GET before saving the key.

package/render/tovu-deploy-configs.json

@@ -0,0 +1,16 @@
+{
+  "schemaVersion": 1,
+  "generators": [
+    {
+      "id": "render",
+      "label": "Render",
+      "module": "deploy-configs/render.mjs",
+      "candidatePaths": [
+        {
+          "path": "render.yaml",
+          "order": 2
+        }
+      ]
+    }
+  ]
+}

package/render/tovu-deploy-ops.json

@@ -0,0 +1,11 @@
+{
+  "schemaVersion": 1,
+  "platforms": [
+    {
+      "id": "render",
+      "label": "Render",
+      "module": "deploy-ops/render.mjs",
+      "hosts": ["api.render.com"]
+    }
+  ]
+}

package/resend/NOTES.md

@@ -0,0 +1,52 @@
+# Resend — implementation notes
+
+Vendor-specific notes moved out of the host's core comments (2026-10-22, vendor-to-plugins). Core describes
+these behaviours generically; the vendor detail lives here.
+
+- **Rate limit.** Resend's 2/s, burst-2 bucket (`capabilities.rateLimit` in `adapters/resend.mjs`) is why
+  core's newsletter send pipeline treats a quota answer as back-pressure, not a failure (review email#4,
+  2026-10-21): a batch of 20 deferred on almost every other row and used to exhaust the outbox budget.
+- **Batch idempotency keys.** One key per message (`<key>:<index>`), which core's mail delivery policy now
+  mirrors for per-recipient dispatch.
+- **Credential label.** `Tovu Mail — Resend API` is the v1 label shape core's `defaultCredentialLabel`
+  reproduces for v2 descriptors without one.
+- **Feedback inbox.** Resend webhook events are recorded under `providerId: "resend"`.
+
+## Resend's hosted MCP server (2026-10-22)
+
+- **Server.** Resend's official hosted server, `https://mcp.resend.com/mcp` (streamable HTTP), the same
+  open-source code as the `resend-mcp` npm package (github.com/resend/resend-mcp). Docs:
+  https://resend.com/docs/mcp-server. The hosted URL is unversioned; tool names were read from
+  `resend-mcp@2.25.0` (2026-10-06) and checked unchanged in 2.27.1, which only adds inbox tools.
+- **Why remote, not `npx resend-mcp`.** Core never auto-wires a plugin's `stdio` server
+  (`federate-mcp.ts`), and a remote row is what `agent_plugin_connect` and the token form act on.
+- **Auth (2026-10-25).** The account connection uses `tovuAuthMode: "none"` plus the existing
+  `tovuTokenAuth` declaration. The Full access key arrives through the plugin's secure account card,
+  is sealed on the MCP row and sent as `Authorization: Bearer`. `agent_plugin_connect` reuses a saved
+  credential or opens that card; it does not start OAuth for this declaration.
+- **Historical OAuth rationale (superseded 2026-10-25).** Resend's MCP advertises RFC 9728 metadata pointing at `https://api.resend.com`, which
+  supports dynamic client registration and PKCE (scopes `full_access`, `emails:send`), so
+  the earlier declaration selected `tovuAuthMode: "oauth"` as the primary sign-in and `tovuTokenAuth`
+  as its fallback: the key arrives
+  through `credential_save { kind: "agent-plugin-token", target: "resend" }`, is sealed on the row and
+  sent as `Authorization: Bearer`, the header Resend documents for headless clients.
+- **Historical OAuth discovery mismatch (2026-10-24).** The server's protected-resource metadata lives only at the origin
+  root and names `"resource": "https://mcp.resend.com"`, not the `/mcp` endpoint. RFC 9728 wants an exact
+  match and `oauth4webapi` enforces it, so Jini's discovery fails ("did not return a JSON object") and no
+  sign-in card opens; the chat falls back to the Full access key card. MCP's own SDK accepts a same-origin
+  path-prefix resource, which is the generic Jini fix.
+- **Probe.** `GET /domains` answers 200 for a Full access key and 401 `restricted_api_key` for a
+  Sending access key, so a key that cannot manage the account is refused before it is saved. A
+  malformed key gets 400, which core's generic probe reports as "unavailable", not "rejected"; the
+  skill tells the assistant what that usually means.
+- **Two keys on purpose.** The site's mail adapter keeps its own Sending access key
+  (`Tovu Mail — Resend API`); the account tools use the separate Full access key. Site mail keeps
+  least privilege, and revoking one never breaks the other.
+- **Default tools.** 62 of the 64 allowed. Left out: every `remove-*`, `batch-remove-suppressions`,
+  `send-broadcast`, API key create/update/remove, webhook create/update/rotate/replay, OAuth-grant
+  revoke, automations, events, the dashboard editor, contact imports and inboxes. Resend's tool names
+  are hyphenated and most carry no annotations, so the federation's per-call confirm classifier
+  (which splits on `_` and knows `delete`, not `remove`) would let removals and `send-broadcast` run
+  without a card; keeping them out of the defaults is the plugin-side guard until that is fixed.
+
+- **0.2.1 (2026-10-25).** Version bump distributes the token-based account authentication declaration to already installed bundled packages.

package/resend/adapters/resend.mjs

@@ -0,0 +1,161 @@
+// @ts-check
+import { parseErrorBody } from '../lib/errors.mjs';
+import { domainRequirements, domainStatus, retryAfterMs } from '../lib/domains.mjs';
+import { feedback } from '../lib/feedback.mjs';
+
+/**
+ * @file Resend mail adapter for the `resend` Agent Plugin.
+ *
+ * Moved out of core (`apps/website/src/platform/mail/adapters/http-api.resend.ts`) unchanged in
+ * behavior: same request, same error mapping, same batch strategy. Core now knows only the generic
+ * mail-adapter contract (`apps/website/src/platform/mail/adapter-module.ts`); it loads this file
+ * through its mail-adapter registry and hands it the guarded outbound-HTTP client, so every request
+ * still goes through the host's egress policy. Plain JS, no npm imports: an installed plugin has none.
+ *
+ * Why a hosted API is the recommended mailer: outbound SMTP (587/465) is blocked or throttled by most
+ * residential ISPs and cloud providers, while HTTPS always works, and a provider API gives warmed
+ * sending IPs plus bounce/complaint webhooks (the only thing that can ever fill the suppression ledger).
+ *
+ * `sendBatch` loops `send()` rather than calling Resend's `/emails/batch`: the mail port requires
+ * per-message results with partial failure allowed, and Resend's batch endpoint reports success or
+ * failure for the whole request only. `maxBatchSize` is `1` accordingly.
+ *
+ * The default export is a full Jini `MailProviderModule` (2026-10-21): id, credential keys,
+ * capabilities (Resend's documented 2 requests/second default), the Svix feedback parser
+ * (`../lib/feedback.mjs`) and sending-domain verification (`../lib/domains.mjs`). `create()` keeps its
+ * original call shape (`send(message, opts)`), which the host's mailer still uses.
+ *
+ * @typedef {{ email: string, name?: string }} EmailAddress
+ * @typedef {{ filename: string, contentType: string, contentBase64: string }} EmailAttachment
+ * @typedef {{ to: EmailAddress, from: EmailAddress, replyTo?: EmailAddress, subject: string, html?: string,
+ *   text?: string, headers?: Readonly<Record<string, string>>, attachments?: readonly EmailAttachment[] }} OutboundEmail
+ * @typedef {{ idempotencyKey: string, timeoutMs?: number }} SendOptions
+ * @typedef {{ ok: true, providerMessageId: string, acceptedAt: string }
+ *   | { ok: false, retryable: boolean, errorCode: string, message: string, retryAfterMs?: number }} SendResult
+ * @typedef {{ send(request: { method: string, url: string, headers: Record<string, string>, body?: string,
+ *   timeoutMs: number }): Promise<{ status: number, bodyText: string, headers?: Readonly<Record<string, string>> }> }} HttpClient
+ * @typedef {{ credential: { token: string, baseUrl?: string }, kit: { httpClient: HttpClient } }} CreateContext
+ */
+
+/** Resend's real API origin; a saved credential's `baseUrl` normally equals it. */
+const DEFAULT_BASE_URL = "https://api.resend.com";
+
+/** Bounds a hung request; a caller's own `timeoutMs` wins. */
+const DEFAULT_TIMEOUT_MS = 10_000;
+
+/** `EmailAddress` to Resend's `"Name <email>"` / bare-email string. @param {EmailAddress} address */
+function formatAddress(address) {
+  return address.name ? `${address.name} <${address.email}>` : address.email;
+}
+
+/** Resend's attachment shape (snake_case, base64 in `content`). @param {EmailAttachment} attachment */
+function toResendAttachment(attachment) {
+  return { filename: attachment.filename, content: attachment.contentBase64, content_type: attachment.contentType };
+}
+
+/** The JSON body of `POST /emails`. @param {OutboundEmail} message @returns {Record<string, unknown>} */
+function toResendPayload(message) {
+  /** @type {Record<string, unknown>} */
+  const payload = { from: formatAddress(message.from), to: formatAddress(message.to), subject: message.subject };
+  if (message.replyTo) payload.reply_to = formatAddress(message.replyTo);
+  if (message.html !== undefined) payload.html = message.html;
+  if (message.text !== undefined) payload.text = message.text;
+  if (message.headers) payload.headers = message.headers;
+  if (message.attachments && message.attachments.length > 0) payload.attachments = message.attachments.map(toResendAttachment);
+  return payload;
+}
+
+/** Transient per Resend's error reference: rate limit, idempotency conflict, server outage. @param {number} status */
+function isRetryableStatus(status) {
+  return status === 429 || status === 409 || status >= 500;
+}
+
+/** Shared mail contract's throttling code (`@jini-ai/platform/mail` `MAIL_RATE_LIMITED`); a literal,
+ * since an installed plugin has no npm imports. Callers defer it instead of failing the recipient. */
+const MAIL_RATE_LIMITED = "MAIL_RATE_LIMITED";
+
+/**
+ * Maps a non-2xx response to a send result. Never throws.
+ * A 429 carries Resend's `Retry-After` as `retryAfterMs` so the caller backs off for that long, and is
+ * normalized to {@link MAIL_RATE_LIMITED} (Resend's own name kept in the message) so it is deferred,
+ * not recorded as a failed recipient.
+ * @param {number} status @param {string} bodyText @param {Readonly<Record<string, string>>} [headers] @returns {SendResult}
+ */
+function classifyError(status, bodyText, headers) {
+  const { errorCode, message } = parseErrorBody({ status, bodyText });
+  if (status !== 429) return { ok: false, retryable: isRetryableStatus(status), errorCode, message };
+  const wait = retryAfterMs(headers);
+  return { ok: false, retryable: true, errorCode: MAIL_RATE_LIMITED, message: `${message} (${errorCode})`, ...(wait === undefined ? {} : { retryAfterMs: wait }) };
+}
+
+/** Builds the mailer from a saved credential. @param {CreateContext} context */
+function create({ credential, kit }) {
+  const baseUrl = credential.baseUrl || DEFAULT_BASE_URL;
+  const { httpClient } = kit;
+
+  /** @param {OutboundEmail} message @param {SendOptions} opts @returns {Promise<SendResult>} */
+  async function send(message, opts) {
+    let response;
+    try {
+      response = await httpClient.send({
+        method: "POST",
+        url: `${baseUrl}/emails`,
+        headers: {
+          Authorization: `Bearer ${credential.token}`,
+          "content-type": "application/json",
+          "Idempotency-Key": opts.idempotencyKey,
+        },
+        body: JSON.stringify(toResendPayload(message)),
+        timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      });
+    } catch (err) {
+      // Network failure, timeout or an egress-policy refusal: retryable, and never thrown across
+      // the mail port.
+      return { ok: false, retryable: true, errorCode: "TRANSPORT_ERROR", message: err instanceof Error ? err.message : String(err) };
+    }
+    if (response.status < 200 || response.status >= 300) return classifyError(response.status, response.bodyText, response.headers);
+
+    let parsed;
+    try {
+      parsed = JSON.parse(response.bodyText);
+    } catch {
+      // HTTP acceptance still stands if a proxy strips or corrupts the optional response body.
+      // Keep the existing idempotency-key fallback so this batch can continue without resending.
+    }
+    const providerMessageId = typeof parsed?.id === "string" ? parsed.id : opts.idempotencyKey;
+    return { ok: true, providerMessageId, acceptedAt: new Date().toISOString() };
+  }
+
+  return {
+    capabilities() {
+      // Resend honours `Idempotency-Key` (24h window) and emits bounce/complaint webhooks.
+      return { driver: "resend", supportsIdempotencyKey: true, supportsWebhookFeedback: true, maxBatchSize: 1, supportsAttachments: true };
+    },
+    send,
+    /** @param {readonly OutboundEmail[]} messages @param {SendOptions} opts */
+    async sendBatch(messages, opts) {
+      /** @type {SendResult[]} */
+      const results = [];
+      for (const [index, message] of messages.entries()) {
+        // One key per message: reusing the batch key would make messages 2..n look like retries of
+        // message 1 to Resend. `:index` is deterministic, so a redelivery reproduces the same keys.
+        results.push(await send(message, { ...opts, idempotencyKey: `${opts.idempotencyKey}:${index}` }));
+      }
+      return results;
+    },
+  };
+}
+
+export default {
+  id: 'resend',
+  label: 'Resend',
+  // Sending access cannot read domains; the plugin's separate account key can.
+  domainReadConnection: { serverId: 'resend', baseUrl: DEFAULT_BASE_URL },
+  credentialKeys: ['token'],
+  webhookSecretKey: 'webhookSecret',
+  capabilities: { hosted: true, feedback: true, domainVerification: true, rateLimit: { perSecond: 2, burst: 2 } },
+  create,
+  feedback,
+  domainRequirements,
+  domainStatus,
+};

package/resend/lib/domains.mjs

@@ -0,0 +1,137 @@
+// @ts-check
+import { parseErrorBody } from './errors.mjs';
+
+/**
+ * @file Resend sending-domain verification over the Domains API (Jini `MailProviderModule`
+ * `domainRequirements` / `domainStatus`). Never throws: every outcome is a `ProviderResult`.
+ *
+ * `GET /domains` lists the account's domains (no records); `GET /domains/{id}` carries the DNS
+ * records Resend needs: SPF as an MX and a TXT on the `send` subdomain, DKIM as a TXT. Record names
+ * come back relative to the domain and are qualified here, because the DNS port takes full names.
+ * Requests go through the host's guarded client (`ctx.httpClient`; see `getJson` for its shape).
+ *
+ * @typedef {{ status: 'ok', value: any } | { status: 'rejected' | 'unknown', error: { code: string, message: string, retryAfterMs?: number } }} ProviderResult
+ * @typedef {{ method: string, url: string, headers: Record<string, string>, timeoutMs: number }} HttpRequest
+ * @typedef {{ status: number, bodyText: string, headers?: Readonly<Record<string, string>> }} HttpResponse
+ * @typedef {{ credential: { token: string, baseUrl?: string }, httpClient: { send(required: { request: HttpRequest }): Promise<HttpResponse> } }} CallContext
+ */
+
+export const DEFAULT_BASE_URL = 'https://api.resend.com';
+const TIMEOUT_MS = 10_000;
+const DNS_TYPES = new Set(['TXT', 'MX', 'CNAME']);
+/** @type {Readonly<Record<number, string>>} */
+const REJECTED_CODES = { 401: 'unauthorized', 403: 'forbidden', 404: 'not_found' };
+
+/** `Retry-After` (seconds) in ms, when present and sane. @param {Readonly<Record<string, string>> | undefined} headers */
+export function retryAfterMs(headers) {
+  const raw = headers?.['retry-after'] ?? headers?.['Retry-After'] ?? '';
+  const seconds = raw.trim() === '' ? Number.NaN : Number(raw);
+  return Number.isFinite(seconds) && seconds >= 0 ? Math.ceil(seconds * 1000) : undefined;
+}
+
+/** Legacy fallback when Resend supplies no structured error body. @param {{status: number}} required */
+function domainFailureFallback({ status }) {
+  if (status === 429) return { errorCode: 'rate_limited', message: 'Resend rate limit reached' };
+  if (status >= 500) return { errorCode: 'provider_unavailable', message: `Resend responded with HTTP ${status}` };
+  return { errorCode: REJECTED_CODES[status] ?? 'provider_error', message: `Resend refused the request (HTTP ${status})` };
+}
+
+/** HTTP status to a rejected/unknown result. The code stays Jini's canonical one for the status;
+ * Resend's own error name and message ride in `message` so the owner sees what Resend said.
+ * A 401 `restricted_api_key` is a valid Sending access key without domain permission. The host
+ * retries only permission refusals with the account key, so it must be `forbidden`, not the
+ * `unauthorized` a bad key gets. @param {HttpResponse} response @returns {ProviderResult} */
+function failure(response) {
+  const { status } = response;
+  const fallback = domainFailureFallback({ status });
+  const parsed = parseErrorBody({ status, bodyText: response.bodyText }, { fallback });
+  const restricted = status === 401 && parsed.errorCode === 'restricted_api_key';
+  const named = parsed.errorCode !== fallback.errorCode;
+  const detail = { code: restricted ? 'forbidden' : fallback.errorCode, message: named ? `${parsed.errorCode}: ${parsed.message}` : parsed.message };
+  if (status === 429) {
+    const wait = retryAfterMs(response.headers);
+    return { status: 'rejected', error: { ...detail, ...(wait === undefined ? {} : { retryAfterMs: wait }) } };
+  }
+  if (status >= 500) return { status: 'unknown', error: { ...detail } };
+  return { status: 'rejected', error: detail };
+}
+
+/** One GET, parsed. @param {CallContext} ctx @param {string} path @returns {Promise<ProviderResult>} */
+async function getJson(ctx, path) {
+  const baseUrl = ctx.credential.baseUrl || DEFAULT_BASE_URL;
+  let response;
+  try {
+    const request = { method: 'GET', url: `${baseUrl}${path}`, headers: { Authorization: `Bearer ${ctx.credential.token}` }, timeoutMs: TIMEOUT_MS };
+    // Both client shapes: Jini's `send({ request })` reads `.request`, the host's positional
+    // `send(request)` reads the fields. The provider contract names Jini's; `create()` has always been
+    // handed the host's positional shape.
+    response = await ctx.httpClient.send({ request, ...request });
+  } catch (err) {
+    return { status: 'unknown', error: { code: 'network', message: err instanceof Error ? err.message : String(err) } };
+  }
+  if (response.status < 200 || response.status >= 300) return failure(response);
+  try {
+    return { status: 'ok', value: JSON.parse(response.bodyText) };
+  } catch {
+    return { status: 'unknown', error: { code: 'unexpected_response', message: 'Resend returned a body that is not JSON' } };
+  }
+}
+
+/** The account's domain named `domain` (case-insensitive), or null. @param {CallContext} ctx @param {string} domain */
+async function findDomain(ctx, domain) {
+  const listed = await getJson(ctx, '/domains');
+  if (listed.status !== 'ok') return listed;
+  const rows = Array.isArray(listed.value?.data) ? listed.value.data : [];
+  const wanted = domain.toLowerCase();
+  return { status: 'ok', value: rows.find((/** @type {any} */ row) => String(row?.name ?? '').toLowerCase() === wanted) ?? null };
+}
+
+/** Resend's domain status to the contract's four states. @param {unknown} status */
+export function domainState(status) {
+  if (status === 'verified') return 'verified';
+  return status === 'failed' ? 'failed' : 'pending';
+}
+
+/** A relative record name under `domain` as a full name. @param {string} name @param {string} domain */
+export function qualify(name, domain) {
+  const lower = name.toLowerCase();
+  if (lower === '' || lower === '@' || lower === domain) return domain;
+  return lower.endsWith(`.${domain}`) ? lower : `${lower}.${domain}`;
+}
+
+/** @param {any} record @param {string} domain */
+function toRequirement(record, domain) {
+  return {
+    type: record.type, name: qualify(String(record.name ?? ''), domain), value: String(record.value ?? ''),
+    ...(typeof record.ttl === 'number' ? { ttl: record.ttl } : {}),
+    ...(typeof record.priority === 'number' ? { priority: record.priority } : {}),
+    note: `${record.record ?? 'Resend'} record`,
+  };
+}
+
+/**
+ * @param {CallContext} ctx @param {{ domain: string }} required
+ * @returns {Promise<ProviderResult>}
+ */
+export async function domainRequirements(ctx, { domain }) {
+  const name = domain.toLowerCase();
+  const found = await findDomain(ctx, name);
+  if (found.status !== 'ok') return found;
+  if (found.value === null) return { status: 'rejected', error: { code: 'not_found', message: `Add ${name} under Domains in Resend first` } };
+  const detail = await getJson(ctx, `/domains/${encodeURIComponent(String(found.value.id))}`);
+  if (detail.status !== 'ok') return detail;
+  const records = (Array.isArray(detail.value?.records) ? detail.value.records : [])
+    .filter((/** @type {any} */ record) => DNS_TYPES.has(record?.type)).map((/** @type {any} */ record) => toRequirement(record, name));
+  return { status: 'ok', value: { purpose: 'mail', domain: name, providerId: 'resend', records } };
+}
+
+/**
+ * @param {CallContext} ctx @param {{ domain: string }} required
+ * @returns {Promise<ProviderResult>}
+ */
+export async function domainStatus(ctx, { domain }) {
+  const name = domain.toLowerCase();
+  const found = await findDomain(ctx, name);
+  if (found.status !== 'ok') return found;
+  return { status: 'ok', value: { domain: name, state: found.value === null ? 'not_found' : domainState(found.value.status) } };
+}