@motorical/mcp 1.0.2

package/README.md

@@ -0,0 +1,87 @@
+# @motorical/mcp
+
+MCP tools for **transactional HTTP send and delivery inspection** on Motorical Sending SMTP (same job class as SendGrid/Postmark-style email APIs).
+
+Agents can **execute** Motorical APIs (not only read docs): dry-run / send email, mint public tokens, list Motor Blocks, inspect message events. Discovery docs remain at [docs.motorical.com/llms.txt](https://docs.motorical.com/llms.txt).
+
+A **Motorical SMTP Motor Block** is an isolated sending stream (similar to a per-app/per-tenant ESP project).
+
+## Tools (v1)
+
+| Tool | Auth | Purpose |
+|------|------|---------|
+| `motorical_get_send_status` | none | `GET /v1/status` |
+| `motorical_mint_public_token` | `ak_live_…` | Mint Public API bearer |
+| `motorical_list_motor_blocks` | bearer (auto-mint) | List Motor Blocks |
+| `motorical_send_email` | `mk_live_…` | Transactional `POST /v1/send` (**default `dryRun: true`**) |
+| `motorical_get_message` | bearer | Message by UUID |
+| `motorical_get_message_events` | bearer | Delivery lifecycle events |
+| `motorical_sandbox_status` | `MOTORICAL_JWT` | Developer sandbox status |
+| `motorical_sandbox_provision` | `MOTORICAL_JWT` | Provision `*.sandbox.motorical.com` |
+| `motorical_sandbox_convert` | `MOTORICAL_JWT` | Convert sandbox → verified domain |
+
+**Resources:** `motorical://docs/llms.txt`, `motorical://docs/openapi.json`  
+**Prompt:** `motorical_integrate_send`
+
+Safety: real sends require `dryRun: false` **and** `confirmRealSend: true`. Sandbox outbound is allowlist-locked until convert.
+
+## Environment
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `MOTORICAL_MK_API_KEY` | for send | Motor Block key `mk_live_…` |
+| `MOTORICAL_AK_API_KEY` | for public API tools | Account key `ak_live_…` |
+| `MOTORICAL_JWT` | for sandbox tools | Dashboard JWT from signup/login |
+| `MOTORICAL_MOTOR_BLOCK_ID` | recommended | UUID used when minting tokens |
+| `MOTORICAL_DEFAULT_FROM` | optional | Default From address |
+| `MOTORICAL_BEARER_TOKEN` | optional | Pre-minted public bearer |
+| `MOTORICAL_API_BASE_URL` | optional | default `https://api.motorical.com` |
+| `MOTORICAL_DOCS_BASE_URL` | optional | default `https://docs.motorical.com` |
+
+## Cursor install
+
+Add to MCP config (e.g. Cursor Settings → MCP):
+
+```json
+{
+  "mcpServers": {
+    "motorical": {
+      "command": "node",
+      "args": ["/root/motoric_smtp/packages/motorical-mcp/src/index.js"],
+      "env": {
+        "MOTORICAL_MK_API_KEY": "mk_live_…",
+        "MOTORICAL_AK_API_KEY": "ak_live_…",
+        "MOTORICAL_MOTOR_BLOCK_ID": "your-block-uuid",
+        "MOTORICAL_DEFAULT_FROM": "noreply@yourdomain.com"
+      }
+    }
+  }
+}
+```
+
+On a developer Mac after cloning:
+
+```bash
+cd packages/motorical-mcp && npm ci
+# point args at the absolute path to src/index.js
+```
+
+Or via npx once published:
+
+```json
+"args": ["-y", "@motorical/mcp"]
+```
+
+## Develop / test
+
+```bash
+cd packages/motorical-mcp
+npm test                 # unit + in-memory MCP
+npm run smoke            # ovh24 live dry-run (creates/revokes temp keys)
+```
+
+## Out of scope (v1)
+
+- Communications Block tools (lists/campaigns) — later
+- OAuth consent / SMTP / mTLS execution — use docs + out-of-band clients
+- Hosted remote MCP HTTP

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@motorical/mcp",
+  "version": "1.0.2",
+  "description": "MCP server for Motorical transactional email API — dry-run/send, mint public tokens, list Motor Blocks, inspect delivery events",
+  "type": "module",
+  "bin": {
+    "motorical-mcp": "./src/index.js"
+  },
+  "main": "./src/server.js",
+  "exports": {
+    ".": "./src/server.js",
+    "./client": "./src/client.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "node --test test/*.test.js",
+    "smoke": "node test/live-smoke.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "motorical",
+    "mcp",
+    "email",
+    "smtp",
+    "transactional-email",
+    "email-api",
+    "model-context-protocol"
+  ],
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.0",
+    "zod": "^3.25.0"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://docs.motorical.com/ai-mcp"
+}

package/src/client.js

@@ -0,0 +1,236 @@
+/**
+ * Thin Motorical HTTP client for MCP tools.
+ * Auth rules match docs.motorical.com (mk_live_ → /v1/send; ak_live_ → mint bearer).
+ */
+
+const DEFAULT_API_BASE = 'https://api.motorical.com';
+const DEFAULT_DOCS_BASE = 'https://docs.motorical.com';
+
+export function loadConfig(env = process.env) {
+  return {
+    apiBaseUrl: (env.MOTORICAL_API_BASE_URL || DEFAULT_API_BASE).replace(/\/$/, ''),
+    docsBaseUrl: (env.MOTORICAL_DOCS_BASE_URL || DEFAULT_DOCS_BASE).replace(/\/$/, ''),
+    mkApiKey: env.MOTORICAL_MK_API_KEY || '',
+    akApiKey: env.MOTORICAL_AK_API_KEY || '',
+    bearerToken: env.MOTORICAL_BEARER_TOKEN || '',
+    dashboardJwt: env.MOTORICAL_JWT || '',
+    motorBlockId: env.MOTORICAL_MOTOR_BLOCK_ID || '',
+    defaultFrom: env.MOTORICAL_DEFAULT_FROM || ''
+  };
+}
+
+export class MotoricalClient {
+  constructor(config = loadConfig()) {
+    this.config = config;
+    /** @type {string|null} */
+    this._cachedBearer = config.bearerToken || null;
+  }
+
+  requireMk() {
+    if (!this.config.mkApiKey) {
+      throw new Error('MOTORICAL_MK_API_KEY is required (mk_live_... Motor Block API key for POST /v1/send)');
+    }
+    return this.config.mkApiKey;
+  }
+
+  requireAk() {
+    if (!this.config.akApiKey) {
+      throw new Error('MOTORICAL_AK_API_KEY is required (ak_live_... Account API key to mint public tokens)');
+    }
+    return this.config.akApiKey;
+  }
+
+  async request(method, path, { headers = {}, body, apiKey, bearer } = {}) {
+    const url = `${this.config.apiBaseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+    const h = { Accept: 'application/json', ...headers };
+    if (apiKey) h.Authorization = `ApiKey ${apiKey}`;
+    if (bearer) h.Authorization = `Bearer ${bearer}`;
+    if (body !== undefined) h['Content-Type'] = 'application/json';
+
+    const res = await fetch(url, {
+      method,
+      headers: h,
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+
+    const text = await res.text();
+    let data;
+    try {
+      data = text ? JSON.parse(text) : null;
+    } catch {
+      data = { raw: text };
+    }
+
+    if (!res.ok) {
+      const msg = data?.error || data?.message || data?.error_description || res.statusText;
+      const err = new Error(`${method} ${path} → ${res.status}: ${msg}`);
+      err.status = res.status;
+      err.data = data;
+      throw err;
+    }
+    return data;
+  }
+
+  async mintPublicToken({ motorBlockId, scopes, ttlSeconds = 900 } = {}) {
+    const blockId = motorBlockId || this.config.motorBlockId;
+    if (!blockId) {
+      throw new Error('motorBlockId is required (argument or MOTORICAL_MOTOR_BLOCK_ID)');
+    }
+    const data = await this.request('POST', '/api/public/token/account-key', {
+      apiKey: this.requireAk(),
+      body: {
+        motorBlockId: blockId,
+        scopes: scopes || ['logs.read', 'analytics.read', 'webhooks.manage', 'config.read'],
+        ttlSeconds
+      }
+    });
+    const token = data?.data?.token || data?.token || data?.access_token;
+    if (token) this._cachedBearer = token;
+    return data;
+  }
+
+  async getBearer({ motorBlockId, forceRefresh = false } = {}) {
+    if (this._cachedBearer && !forceRefresh) return this._cachedBearer;
+    const minted = await this.mintPublicToken({ motorBlockId });
+    const token = minted?.data?.token || minted?.token || minted?.access_token;
+    if (!token) throw new Error('Token mint succeeded but no token field in response');
+    this._cachedBearer = token;
+    return token;
+  }
+
+  async listMotorBlocks({ motorBlockId } = {}) {
+    const bearer = await this.getBearer({ motorBlockId });
+    return this.request('GET', '/api/public/v1/motor-blocks', { bearer });
+  }
+
+  async sendEmail(payload) {
+    const {
+      from,
+      fromName,
+      to,
+      subject,
+      text,
+      html,
+      dryRun = true,
+      confirmRealSend = false,
+      idempotencyKey,
+      headers: customHeaders,
+      ...rest
+    } = payload;
+
+    if (dryRun === false && confirmRealSend !== true) {
+      throw new Error(
+        'Refusing real send: set dryRun:true (default) or pass confirmRealSend:true with dryRun:false'
+      );
+    }
+
+    const fromAddr = from || this.config.defaultFrom;
+    if (!fromAddr) throw new Error('from is required (or set MOTORICAL_DEFAULT_FROM)');
+    if (!to || (Array.isArray(to) && to.length === 0)) throw new Error('to is required');
+    if (!subject) throw new Error('subject is required');
+    if (!text && !html) throw new Error('At least one of text or html is required');
+
+    const headers = {};
+    if (idempotencyKey) headers['Idempotency-Key'] = idempotencyKey;
+
+    return this.request('POST', '/v1/send', {
+      apiKey: this.requireMk(),
+      headers,
+      body: {
+        from: fromAddr,
+        ...(fromName ? { fromName } : {}),
+        to: Array.isArray(to) ? to : [to],
+        subject,
+        text,
+        html,
+        dryRun: dryRun !== false,
+        ...(customHeaders ? { headers: customHeaders } : {}),
+        ...rest
+      }
+    });
+  }
+
+  async getMessage(messageId, { includePII = false, motorBlockId } = {}) {
+    if (!messageId) throw new Error('messageId is required');
+    const bearer = await this.getBearer({ motorBlockId });
+    const q = includePII ? '?includePII=true' : '';
+    return this.request('GET', `/api/public/v1/messages/${encodeURIComponent(messageId)}${q}`, { bearer });
+  }
+
+  async getMessageEvents(messageId, { includePII = false, motorBlockId } = {}) {
+    if (!messageId) throw new Error('messageId is required');
+    const bearer = await this.getBearer({ motorBlockId });
+    const q = includePII ? '?includePII=true' : '';
+    return this.request('GET', `/api/public/v1/messages/${encodeURIComponent(messageId)}/events${q}`, { bearer });
+  }
+
+  async getSendApiStatus() {
+    return this.request('GET', '/v1/status');
+  }
+
+  requireDashboardJwt() {
+    if (!this.config.dashboardJwt) {
+      throw new Error(
+        'MOTORICAL_JWT is required for developer sandbox tools (dashboard session from motorical login / set-password)'
+      );
+    }
+    return this.config.dashboardJwt;
+  }
+
+  async sandboxStatus() {
+    return this.request('GET', '/api/developer/sandbox', { bearer: this.requireDashboardJwt() });
+  }
+
+  async sandboxProvision({ handle, channel = 'agent' } = {}) {
+    return this.request('POST', '/api/developer/sandbox/provision', {
+      bearer: this.requireDashboardJwt(),
+      body: { handle, channel }
+    });
+  }
+
+  async sandboxConvert({ domainId }) {
+    if (!domainId) throw new Error('domainId is required');
+    return this.request('POST', '/api/developer/sandbox/convert', {
+      bearer: this.requireDashboardJwt(),
+      body: { domainId }
+    });
+  }
+
+  async domainAdd({ domain, verificationMethod = 'dns' } = {}) {
+    if (!domain) throw new Error('domain is required');
+    return this.request('POST', '/api/domains', {
+      bearer: this.requireDashboardJwt(),
+      body: { domain, verificationMethod }
+    });
+  }
+
+  async domainVerify({ domainId, method = 'dns' } = {}) {
+    if (!domainId) throw new Error('domainId is required');
+    return this.request('POST', `/api/domains/${encodeURIComponent(domainId)}/verify`, {
+      bearer: this.requireDashboardJwt(),
+      body: { method }
+    });
+  }
+
+  async domainCheckDns({ domainId, recordType } = {}) {
+    if (!domainId) throw new Error('domainId is required');
+    return this.request('POST', `/api/domains/${encodeURIComponent(domainId)}/check-dns`, {
+      bearer: this.requireDashboardJwt(),
+      body: recordType ? { recordType } : {}
+    });
+  }
+
+  async webHandoff({ path } = {}) {
+    return this.request('POST', '/api/auth/web-handoff', {
+      bearer: this.requireDashboardJwt(),
+      body: path ? { path } : {}
+    });
+  }
+
+  async fetchDocs(path = '/llms.txt') {
+    const url = `${this.config.docsBaseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Docs fetch ${url} → ${res.status}`);
+    return res.text();
+  }
+}

package/src/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+/**
+ * Motorical MCP server — stdio transport for Cursor / Claude Desktop / etc.
+ * Credentials via env (see README). Log only to stderr.
+ */
+
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createMotoricalMcpServer } from './server.js';
+
+async function main() {
+  const { server } = createMotoricalMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('[motorical-mcp] ready on stdio');
+}
+
+main().catch((err) => {
+  console.error('[motorical-mcp] fatal:', err);
+  process.exit(1);
+});

package/src/server.js

@@ -0,0 +1,367 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { MotoricalClient, loadConfig } from './client.js';
+
+const PACKAGE_VERSION = '1.0.2';
+
+function jsonResult(data, { isError = false } = {}) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+    structuredContent: typeof data === 'object' && data !== null ? data : { value: data },
+    isError
+  };
+}
+
+function errorResult(err) {
+  return jsonResult(
+    {
+      error: err.message,
+      status: err.status || null,
+      details: err.data || null
+    },
+    { isError: true }
+  );
+}
+
+/**
+ * Create a configured Motorical MCP server (stdio/HTTP transport attached by caller).
+ */
+export function createMotoricalMcpServer(options = {}) {
+  const client = options.client || new MotoricalClient(options.config || loadConfig());
+
+  const server = new McpServer({
+    name: 'motorical',
+    version: PACKAGE_VERSION
+  });
+
+  server.registerTool(
+    'motorical_get_send_status',
+    {
+      description:
+        'Check Motorical transactional email HTTP Send API status (GET /v1/status). No auth required.',
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        return jsonResult(await client.getSendApiStatus());
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerTool(
+    'motorical_mint_public_token',
+    {
+      description:
+        'Mint a short-lived Public Analytics API bearer token using MOTORICAL_AK_API_KEY (ak_live_...). ' +
+        'Use for /api/public/v1 logs, analytics, webhooks, config. Not for POST /v1/send.',
+      inputSchema: {
+        motorBlockId: z.string().uuid().optional().describe('Defaults to MOTORICAL_MOTOR_BLOCK_ID'),
+        scopes: z.array(z.string()).optional(),
+        ttlSeconds: z.number().int().min(60).max(900).optional()
+      }
+    },
+    async (args) => {
+      try {
+        return jsonResult(await client.mintPublicToken(args));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerTool(
+    'motorical_list_motor_blocks',
+    {
+      description:
+        'List Motor Blocks (isolated sending streams) visible to a Public API bearer token (auto-mints with ak_live_ if needed).',
+      inputSchema: {
+        motorBlockId: z.string().uuid().optional().describe('Block used when minting a token if none cached')
+      }
+    },
+    async (args) => {
+      try {
+        return jsonResult(await client.listMotorBlocks(args));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerTool(
+    'motorical_send_email',
+    {
+      description:
+        'Transactional email: send or validate via POST /v1/send using MOTORICAL_MK_API_KEY (mk_live_...). ' +
+        'Defaults to dryRun:true. Real sends require dryRun:false AND confirmRealSend:true. ' +
+        'Do not use OAuth access tokens or Bearer tokens here.',
+      inputSchema: {
+        from: z.string().email().optional().describe('Defaults to MOTORICAL_DEFAULT_FROM'),
+        fromName: z
+          .string()
+          .max(78)
+          .optional()
+          .describe('Optional From display name (do not put From in headers — use this field)'),
+        to: z.union([z.string().email(), z.array(z.string().email())]),
+        subject: z.string().min(1),
+        text: z.string().optional(),
+        html: z.string().optional(),
+        dryRun: z.boolean().optional().describe('Default true — validate without queueing'),
+        confirmRealSend: z
+          .boolean()
+          .optional()
+          .describe('Required true when dryRun is false'),
+        idempotencyKey: z.string().optional()
+      }
+    },
+    async (args) => {
+      try {
+        return jsonResult(await client.sendEmail(args));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerTool(
+    'motorical_get_message',
+    {
+      description: 'Get a message by send UUID (GET /api/public/v1/messages/{id}). Auto-mints bearer if needed.',
+      inputSchema: {
+        messageId: z.string().uuid(),
+        includePII: z.boolean().optional(),
+        motorBlockId: z.string().uuid().optional()
+      }
+    },
+    async (args) => {
+      try {
+        return jsonResult(await client.getMessage(args.messageId, args));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerTool(
+    'motorical_get_message_events',
+    {
+      description:
+        'Get delivery lifecycle events for a message (GET /api/public/v1/messages/{id}/events).',
+      inputSchema: {
+        messageId: z.string().uuid(),
+        includePII: z.boolean().optional(),
+        motorBlockId: z.string().uuid().optional()
+      }
+    },
+    async (args) => {
+      try {
+        return jsonResult(await client.getMessageEvents(args.messageId, args));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerTool(
+    'motorical_sandbox_status',
+    {
+      description:
+        'Get developer sandbox status (domain, Motor Block, outbound lock, allowlist). Requires MOTORICAL_JWT.',
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        return jsonResult(await client.sandboxStatus());
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerTool(
+    'motorical_sandbox_provision',
+    {
+      description:
+        'Provision unpaid developer sandbox (*.sandbox.motorical.com + outbound-locked Motor Block). ' +
+        'Returns mk_live_ once. Requires MOTORICAL_JWT from signup/login. channel defaults to agent.',
+      inputSchema: {
+        handle: z.string().optional(),
+        channel: z.enum(['cli', 'agent', 'web']).optional()
+      }
+    },
+    async (args) => {
+      try {
+        return jsonResult(await client.sandboxProvision(args));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerTool(
+    'motorical_sandbox_convert',
+    {
+      description:
+        'Convert sandbox Motor Block onto a verified customer domain. Requires active Motorical Plan + MOTORICAL_JWT.',
+      inputSchema: {
+        domainId: z.string().uuid()
+      }
+    },
+    async (args) => {
+      try {
+        return jsonResult(await client.sandboxConvert(args));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerTool(
+    'motorical_domain_add',
+    {
+      description:
+        'Add a customer domain (POST /api/domains). Returns verification DNS instructions. ' +
+        'For cname_managed DKIM publish the CNAME in verification.records.dkim / dnsRecords (not a TXT p= key). Requires MOTORICAL_JWT.',
+      inputSchema: {
+        domain: z.string().min(3),
+        verificationMethod: z.enum(['dns', 'email']).optional()
+      }
+    },
+    async (args) => {
+      try {
+        return jsonResult(await client.domainAdd(args));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerTool(
+    'motorical_domain_verify',
+    {
+      description:
+        'Verify domain ownership and refresh DKIM/SPF/DMARC send-readiness flags (POST /api/domains/{id}/verify). ' +
+        'Safe to re-call after ownership is done — returns sendReady. Requires MOTORICAL_JWT.',
+      inputSchema: {
+        domainId: z.string().uuid(),
+        method: z.enum(['dns', 'email']).optional()
+      }
+    },
+    async (args) => {
+      try {
+        return jsonResult(await client.domainVerify(args));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerTool(
+    'motorical_domain_check_dns',
+    {
+      description:
+        'Live-check DKIM/SPF/DMARC and persist dkim_configured/spf_configured (POST /api/domains/{id}/check-dns). ' +
+        'Required before /v1/send when ownership is verified but send returns DOMAIN_DNS_INCOMPLETE. Requires MOTORICAL_JWT.',
+      inputSchema: {
+        domainId: z.string().uuid(),
+        recordType: z.enum(['dkim', 'spf', 'dmarc', 'mx']).optional()
+      }
+    },
+    async (args) => {
+      try {
+        return jsonResult(await client.domainCheckDns(args));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerTool(
+    'motorical_web_handoff',
+    {
+      description:
+        'Mint a one-time CLI→browser handoff URL (POST /api/auth/web-handoff). ' +
+        'Open the URL so the human can set a dashboard password / use the UI. Requires MOTORICAL_JWT.',
+      inputSchema: {
+        path: z.string().optional().describe('Optional in-app path after handoff, e.g. /usage')
+      }
+    },
+    async (args) => {
+      try {
+        return jsonResult(await client.webHandoff(args));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+
+  server.registerResource(
+    'motorical-llms',
+    'motorical://docs/llms.txt',
+    {
+      description: 'Motorical llms.txt — transactional email API discovery index for agents',
+      mimeType: 'text/plain'
+    },
+    async () => ({
+      contents: [
+        {
+          uri: 'motorical://docs/llms.txt',
+          mimeType: 'text/plain',
+          text: await client.fetchDocs('/llms.txt')
+        }
+      ]
+    })
+  );
+
+  server.registerResource(
+    'motorical-openapi',
+    'motorical://docs/openapi.json',
+    {
+      description: 'Motorical OpenAPI snapshot from docs.motorical.com',
+      mimeType: 'application/json'
+    },
+    async () => ({
+      contents: [
+        {
+          uri: 'motorical://docs/openapi.json',
+          mimeType: 'application/json',
+          text: await client.fetchDocs('/openapi.json')
+        }
+      ]
+    })
+  );
+
+  server.registerPrompt(
+    'motorical_integrate_send',
+    {
+      description: 'Guidance for integrating Motorical transactional email (HTTP Send) safely',
+      argsSchema: {
+        language: z.string().optional().describe('e.g. node, python, curl')
+      }
+    },
+    async ({ language }) => ({
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: [
+              `Help me integrate Motorical transactional email (HTTP Send API)${language ? ` in ${language}` : ''}.`,
+              'Motorical is a transactional email API and SMTP provider; Motor Blocks are isolated sending streams.',
+              'Rules: use mk_live_ ApiKey for POST /v1/send; start with dryRun:true;',
+              'use ak_live_ only to mint bearer tokens for /api/public/v1;',
+              'never put OAuth access tokens on /v1/send;',
+              'SMTP is mail.motorical.com:2587/2465 (password / OAuth / mTLS).',
+              'Canonical docs: https://docs.motorical.com/llms.txt'
+            ].join(' ')
+          }
+        }
+      ]
+    })
+  );
+
+  return { server, client };
+}
+
+export { loadConfig, MotoricalClient };