@hasna/connectors 0.3.1 → 0.3.2

package/bin/mcp.js

@@ -4569,7 +4569,6 @@ var require_limitLength = __commonJS((exports) => {
 var require_pattern = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var code_1 = require_code2();
-  var util_1 = require_util();
   var codegen_1 = require_codegen();
   var error2 = {
     message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
@@ -4582,18 +4581,10 @@ var require_pattern = __commonJS((exports) => {
     $data: true,
     error: error2,
     code(cxt) {
-      const { gen, data, $data, schema, schemaCode, it } = cxt;
+      const { data, $data, schema, schemaCode, it } = cxt;
       const u = it.opts.unicodeRegExp ? "u" : "";
-      if ($data) {
-        const { regExp } = it.opts.code;
-        const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
-        const valid = gen.let("valid");
-        gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
-        cxt.fail$data((0, codegen_1._)`!${valid}`);
-      } else {
-        const regExp = (0, code_1.usePattern)(cxt, schema);
-        cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
-      }
+      const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
+      cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
     }
   };
   exports.default = def;
@@ -6286,7 +6277,7 @@ var require_formats = __commonJS((exports) => {
   }
   var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
   function getTime(strictTimeZone) {
-    return function time(str) {
+    return function time3(str) {
       const matches = TIME.exec(str);
       if (!matches)
         return false;
@@ -18120,62 +18111,6 @@ class ExperimentalServerTasks {
   requestStream(request, resultSchema, options) {
     return this._server.requestStream(request, resultSchema, options);
   }
-  createMessageStream(params, options) {
-    const clientCapabilities = this._server.getClientCapabilities();
-    if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
-      throw new Error("Client does not support sampling tools capability.");
-    }
-    if (params.messages.length > 0) {
-      const lastMessage = params.messages[params.messages.length - 1];
-      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
-      const hasToolResults = lastContent.some((c) => c.type === "tool_result");
-      const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
-      const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
-      const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
-      if (hasToolResults) {
-        if (lastContent.some((c) => c.type !== "tool_result")) {
-          throw new Error("The last message must contain only tool_result content if any is present");
-        }
-        if (!hasPreviousToolUse) {
-          throw new Error("tool_result blocks are not matching any tool_use from the previous message");
-        }
-      }
-      if (hasPreviousToolUse) {
-        const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
-        const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
-        if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
-          throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
-        }
-      }
-    }
-    return this.requestStream({
-      method: "sampling/createMessage",
-      params
-    }, CreateMessageResultSchema, options);
-  }
-  elicitInputStream(params, options) {
-    const clientCapabilities = this._server.getClientCapabilities();
-    const mode = params.mode ?? "form";
-    switch (mode) {
-      case "url": {
-        if (!clientCapabilities?.elicitation?.url) {
-          throw new Error("Client does not support url elicitation.");
-        }
-        break;
-      }
-      case "form": {
-        if (!clientCapabilities?.elicitation?.form) {
-          throw new Error("Client does not support form elicitation.");
-        }
-        break;
-      }
-    }
-    const normalizedParams = mode === "form" && params.mode === undefined ? { ...params, mode: "form" } : params;
-    return this.requestStream({
-      method: "elicitation/create",
-      params: normalizedParams
-    }, ElicitResultSchema, options);
-  }
   async getTask(taskId, options) {
     return this._server.getTask({ taskId }, options);
   }
@@ -20271,11 +20206,110 @@ function guessKeyField(name) {
   return "apiKey";
 }
 
+// src/lib/runner.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { spawn } from "child_process";
+var __dirname3 = dirname3(fileURLToPath3(import.meta.url));
+function resolveConnectorsDir2() {
+  const fromBin = join4(__dirname3, "..", "connectors");
+  if (existsSync4(fromBin))
+    return fromBin;
+  const fromSrc = join4(__dirname3, "..", "..", "connectors");
+  if (existsSync4(fromSrc))
+    return fromSrc;
+  return fromBin;
+}
+var CONNECTORS_DIR2 = resolveConnectorsDir2();
+function getConnectorCliPath(name) {
+  const safeName = name.replace(/[^a-z0-9-]/g, "");
+  const connectorDir = join4(CONNECTORS_DIR2, `connect-${safeName}`);
+  const cliPath = join4(connectorDir, "src", "cli", "index.ts");
+  if (existsSync4(cliPath))
+    return cliPath;
+  return null;
+}
+function runConnectorCommand(name, args, timeoutMs = 30000) {
+  const cliPath = getConnectorCliPath(name);
+  if (!cliPath) {
+    return Promise.resolve({
+      stdout: "",
+      stderr: `Connector '${name}' not found or has no CLI.`,
+      exitCode: 1,
+      success: false
+    });
+  }
+  return new Promise((resolve) => {
+    const proc = spawn("bun", ["run", cliPath, ...args], {
+      timeout: timeoutMs,
+      env: { ...process.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code ?? 1,
+        success: code === 0
+      });
+    });
+    proc.on("error", (err) => {
+      resolve({
+        stdout: "",
+        stderr: err.message,
+        exitCode: 1,
+        success: false
+      });
+    });
+  });
+}
+async function getConnectorOperations(name) {
+  const cliPath = getConnectorCliPath(name);
+  if (!cliPath) {
+    return { commands: [], helpText: "", hasCli: false };
+  }
+  const result = await runConnectorCommand(name, ["--help"]);
+  const helpText = result.stdout || result.stderr;
+  const commands = [];
+  const lines = helpText.split(`
+`);
+  let inCommands = false;
+  for (const line of lines) {
+    if (line.trim().startsWith("Commands:")) {
+      inCommands = true;
+      continue;
+    }
+    if (inCommands) {
+      const match = line.match(/^\s{2,}(\S+)/);
+      if (match && match[1] !== "help") {
+        commands.push(match[1]);
+      }
+      if (line.trim() === "" && commands.length > 0) {
+        inCommands = false;
+      }
+    }
+  }
+  return { commands, helpText, hasCli: true };
+}
+async function getConnectorCommandHelp(name, command) {
+  const result = await runConnectorCommand(name, [command, "--help"]);
+  return result.stdout || result.stderr;
+}
+
 // src/mcp/index.ts
 loadConnectorVersions();
 var server = new McpServer({
   name: "connectors",
-  version: "0.3.1"
+  version: "0.3.2"
 });
 server.registerTool("search_connectors", {
   title: "Search Connectors",
@@ -20523,6 +20557,111 @@ server.registerTool("list_categories", {
     ]
   };
 });
+server.registerTool("list_connector_operations", {
+  title: "List Connector Operations",
+  description: "Discover available API operations for a connector. Returns CLI commands the connector supports (e.g. messages, products, customers). Use this before run_connector_operation to know what's available.",
+  inputSchema: {
+    name: exports_external.string().describe("Connector name (e.g. stripe, gmail, anthropic)"),
+    command: exports_external.string().optional().describe("Get detailed help for a specific subcommand (e.g. products, messages)")
+  }
+}, async ({ name, command }) => {
+  const meta = getConnector(name);
+  if (!meta) {
+    return {
+      content: [{ type: "text", text: `Connector '${name}' not found.` }],
+      isError: true
+    };
+  }
+  if (!getConnectorCliPath(name)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Connector '${name}' does not have a CLI. It may be API-only.`
+        }
+      ],
+      isError: true
+    };
+  }
+  if (command) {
+    const help = await getConnectorCommandHelp(name, command);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ connector: name, command, help }, null, 2)
+        }
+      ]
+    };
+  }
+  const ops = await getConnectorOperations(name);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          connector: name,
+          displayName: meta.displayName,
+          commands: ops.commands,
+          helpText: ops.helpText
+        }, null, 2)
+      }
+    ]
+  };
+});
+server.registerTool("run_connector_operation", {
+  title: "Run Connector Operation",
+  description: "Execute an API operation on a connector. Pass the connector name and CLI arguments. Use list_connector_operations first to discover available commands. Example: name='stripe', args=['products', 'list', '--limit', '5']",
+  inputSchema: {
+    name: exports_external.string().describe("Connector name (e.g. stripe, gmail, anthropic)"),
+    args: exports_external.array(exports_external.string()).describe("CLI arguments for the connector command (e.g. ['products', 'list', '--limit', '5'])"),
+    format: exports_external.enum(["json", "pretty"]).optional().describe("Output format (default: json for structured parsing)"),
+    timeout: exports_external.number().optional().describe("Timeout in milliseconds (default: 30000)")
+  }
+}, async ({ name, args, format, timeout }) => {
+  const meta = getConnector(name);
+  if (!meta) {
+    return {
+      content: [{ type: "text", text: `Connector '${name}' not found.` }],
+      isError: true
+    };
+  }
+  const finalArgs = [...args];
+  if (format) {
+    finalArgs.push("--format", format);
+  } else if (!args.includes("--format") && !args.includes("-f")) {
+    finalArgs.push("--format", "json");
+  }
+  const result = await runConnectorCommand(name, finalArgs, timeout ?? 30000);
+  if (!result.success) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            connector: name,
+            success: false,
+            error: result.stderr || result.stdout,
+            exitCode: result.exitCode
+          }, null, 2)
+        }
+      ],
+      isError: true
+    };
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          connector: name,
+          success: true,
+          output: result.stdout
+        }, null, 2)
+      }
+    ]
+  };
+});
 server.registerTool("search_tools", {
   title: "Search Tools",
   description: "List tool names, optionally filtered by keyword.",
@@ -20539,6 +20678,8 @@ server.registerTool("search_tools", {
     "connector_auth_status",
     "configure_auth",
     "list_categories",
+    "list_connector_operations",
+    "run_connector_operation",
     "search_tools",
     "describe_tools"
   ];
@@ -20560,7 +20701,9 @@ server.registerTool("describe_tools", {
     connector_info: "Get metadata and install status. Params: name",
     connector_auth_status: "Check auth status and env vars. Params: name",
     configure_auth: "Save API key or token. Params: name, key, field?",
-    list_categories: "List connector categories with counts."
+    list_categories: "List connector categories with counts.",
+    list_connector_operations: "Discover available API operations for a connector. Params: name, command?",
+    run_connector_operation: "Execute an API operation on a connector. Params: name, args[], format?, timeout?"
   };
   const result = names.map((n) => `${n}: ${descriptions[n] || "See tool schema"}`).join(`
 `);

package/bin/serve.js

@@ -1,21 +1,5 @@
 #!/usr/bin/env bun
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
 var __require = import.meta.require;
 
 // src/server/serve.ts

package/connectors/connect-aws/package.json

@@ -25,6 +25,8 @@
     "s3",
     "lambda",
     "dynamodb",
+    "ses",
+    "email",
     "connector",
     "cli",
     "typescript",
@@ -39,7 +41,8 @@
   },
   "dependencies": {
     "commander": "^12.1.0",
-    "chalk": "^5.3.0"
+    "chalk": "^5.3.0",
+    "@aws-sdk/client-sesv2": "^3.0.0"
   },
   "engines": {
     "bun": ">=1.0.0"

package/connectors/connect-aws/src/api/awsses.ts

@@ -0,0 +1,311 @@
+import type { AWSClient } from './client';
+import type {
+  SesEmailIdentity,
+  SesSendEmailRequest,
+  SesSendEmailResponse,
+  SesListIdentitiesResponse,
+  SesCreateIdentityResponse,
+  SesDkimAttributes,
+  SesSendStatistics,
+  SesSuppressedDestination,
+  SesSuppressedDestinationsResponse,
+} from '../types';
+
+/**
+ * SES v2 API client
+ */
+export class AwsSesApi {
+  private readonly client: AWSClient;
+
+  constructor(client: AWSClient) {
+    this.client = client;
+  }
+
+  /**
+   * Send a transactional email
+   */
+  async sendEmail(opts: SesSendEmailRequest): Promise<SesSendEmailResponse> {
+    const body: Record<string, unknown> = {
+      FromEmailAddress: opts.from,
+      Destination: {
+        ToAddresses: Array.isArray(opts.to) ? opts.to : [opts.to],
+        ...(opts.cc && { CcAddresses: Array.isArray(opts.cc) ? opts.cc : [opts.cc] }),
+        ...(opts.bcc && { BccAddresses: Array.isArray(opts.bcc) ? opts.bcc : [opts.bcc] }),
+      },
+      Content: {
+        Simple: {
+          Subject: {
+            Data: opts.subject,
+            Charset: 'UTF-8',
+          },
+          Body: {
+            ...(opts.html && {
+              Html: {
+                Data: opts.html,
+                Charset: 'UTF-8',
+              },
+            }),
+            ...(opts.text && {
+              Text: {
+                Data: opts.text,
+                Charset: 'UTF-8',
+              },
+            }),
+          },
+          ...(opts.attachments && opts.attachments.length > 0 && {
+            Attachments: opts.attachments.map(att => ({
+              FileName: att.filename,
+              Data: att.data,
+              ContentType: att.contentType,
+            })),
+          }),
+        },
+      },
+      ...(opts.replyTo && { ReplyToAddresses: Array.isArray(opts.replyTo) ? opts.replyTo : [opts.replyTo] }),
+    };
+
+    const response = await this.client.request<{ MessageId: string }>('/v2/email/outbound-emails', {
+      method: 'POST',
+      service: 'sesv2',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    return {
+      messageId: response.MessageId,
+    };
+  }
+
+  /**
+   * List verified email/domain identities
+   */
+  async listIdentities(type?: 'EMAIL_ADDRESS' | 'DOMAIN'): Promise<SesListIdentitiesResponse> {
+    const params: Record<string, string | number | boolean | undefined> = {
+      ...(type && { IdentityType: type }),
+    };
+
+    const response = await this.client.request<{
+      EmailIdentities?: Array<{
+        IdentityName?: string;
+        IdentityType?: string;
+        SendingEnabled?: boolean;
+        VerificationStatus?: string;
+      }>;
+      NextToken?: string;
+    }>('/v2/email/identities', {
+      method: 'GET',
+      service: 'sesv2',
+      params,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    return {
+      identities: (response.EmailIdentities || []).map(identity => ({
+        identityName: identity.IdentityName || '',
+        identityType: (identity.IdentityType as 'EMAIL_ADDRESS' | 'DOMAIN') || 'EMAIL_ADDRESS',
+        sendingEnabled: identity.SendingEnabled ?? false,
+        verificationStatus: identity.VerificationStatus || 'NOT_STARTED',
+      })),
+      nextToken: response.NextToken,
+    };
+  }
+
+  /**
+   * Create (verify) an email address or domain identity
+   */
+  async createIdentity(identity: string): Promise<SesCreateIdentityResponse> {
+    const response = await this.client.request<{
+      IdentityType?: string;
+      VerifiedForSendingStatus?: boolean;
+      DkimAttributes?: {
+        SigningEnabled?: boolean;
+        Status?: string;
+        Tokens?: string[];
+        SigningAttributesOrigin?: string;
+        NextSigningKeyLength?: string;
+        CurrentSigningKeyLength?: string;
+        LastKeyGenerationTimestamp?: string;
+      };
+    }>('/v2/email/identities', {
+      method: 'POST',
+      service: 'sesv2',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ EmailIdentity: identity }),
+    });
+
+    return {
+      identityType: (response.IdentityType as 'EMAIL_ADDRESS' | 'DOMAIN') || 'EMAIL_ADDRESS',
+      verifiedForSendingStatus: response.VerifiedForSendingStatus ?? false,
+      dkimAttributes: response.DkimAttributes
+        ? {
+            signingEnabled: response.DkimAttributes.SigningEnabled ?? false,
+            status: response.DkimAttributes.Status || 'NOT_STARTED',
+            tokens: response.DkimAttributes.Tokens || [],
+          }
+        : undefined,
+    };
+  }
+
+  /**
+   * Delete an email address or domain identity
+   */
+  async deleteIdentity(identity: string): Promise<void> {
+    await this.client.request<Record<string, never>>(
+      `/v2/email/identities/${encodeURIComponent(identity)}`,
+      {
+        method: 'DELETE',
+        service: 'sesv2',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }
+    );
+  }
+
+  /**
+   * Get DKIM signing attributes and DNS records for a domain identity
+   */
+  async getDkimAttributes(identity: string): Promise<SesDkimAttributes> {
+    const response = await this.client.request<{
+      DkimAttributes?: {
+        SigningEnabled?: boolean;
+        Status?: string;
+        Tokens?: string[];
+        SigningAttributesOrigin?: string;
+        NextSigningKeyLength?: string;
+        CurrentSigningKeyLength?: string;
+        LastKeyGenerationTimestamp?: string;
+      };
+      IdentityType?: string;
+      FeedbackForwardingStatus?: boolean;
+      VerifiedForSendingStatus?: boolean;
+    }>(`/v2/email/identities/${encodeURIComponent(identity)}`, {
+      method: 'GET',
+      service: 'sesv2',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    const dkim = response.DkimAttributes || {};
+    const region = this.client.getRegion();
+    const tokens = dkim.Tokens || [];
+
+    return {
+      signingEnabled: dkim.SigningEnabled ?? false,
+      status: dkim.Status || 'NOT_STARTED',
+      tokens,
+      signingAttributesOrigin: dkim.SigningAttributesOrigin || 'AWS_SES',
+      dnsRecords: tokens.map(token => ({
+        name: `${token}._domainkey.${identity}`,
+        type: 'CNAME',
+        value: `${token}.dkim.amazonses.com`,
+        region,
+      })),
+    };
+  }
+
+  /**
+   * Get send statistics for a given period
+   */
+  async getStatistics(period?: string): Promise<SesSendStatistics> {
+    const response = await this.client.request<{
+      SendDataPoints?: Array<{
+        Timestamp?: string;
+        DeliveryAttempts?: number;
+        Bounces?: number;
+        Complaints?: number;
+        Rejects?: number;
+      }>;
+    }>('/v2/email/account/sending-statistics', {
+      method: 'GET',
+      service: 'sesv2',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    const dataPoints = response.SendDataPoints || [];
+
+    // Filter by period if provided (period is expected as ISO duration or cutoff date string)
+    let filtered = dataPoints;
+    if (period) {
+      const cutoff = new Date(period);
+      if (!isNaN(cutoff.getTime())) {
+        filtered = dataPoints.filter(dp => dp.Timestamp && new Date(dp.Timestamp) >= cutoff);
+      }
+    }
+
+    // Aggregate totals
+    const totals = filtered.reduce(
+      (acc, dp) => ({
+        deliveryAttempts: acc.deliveryAttempts + (dp.DeliveryAttempts || 0),
+        bounces: acc.bounces + (dp.Bounces || 0),
+        complaints: acc.complaints + (dp.Complaints || 0),
+        rejects: acc.rejects + (dp.Rejects || 0),
+      }),
+      { deliveryAttempts: 0, bounces: 0, complaints: 0, rejects: 0 }
+    );
+
+    return {
+      ...totals,
+      dataPoints: filtered.map(dp => ({
+        timestamp: dp.Timestamp || '',
+        deliveryAttempts: dp.DeliveryAttempts || 0,
+        bounces: dp.Bounces || 0,
+        complaints: dp.Complaints || 0,
+        rejects: dp.Rejects || 0,
+      })),
+    };
+  }
+
+  /**
+   * List suppression list entries
+   */
+  async getSuppressedDestinations(options?: {
+    reasons?: Array<'BOUNCE' | 'COMPLAINT'>;
+    startDate?: string;
+    endDate?: string;
+    nextToken?: string;
+    pageSize?: number;
+  }): Promise<SesSuppressedDestinationsResponse> {
+    const params: Record<string, string | number | boolean | undefined> = {
+      ...(options?.reasons && { Reason: options.reasons.join(',') }),
+      ...(options?.startDate && { StartDate: options.startDate }),
+      ...(options?.endDate && { EndDate: options.endDate }),
+      ...(options?.nextToken && { NextToken: options.nextToken }),
+      ...(options?.pageSize && { PageSize: options.pageSize }),
+    };
+
+    const response = await this.client.request<{
+      SuppressedDestinationSummaries?: Array<{
+        EmailAddress?: string;
+        Reason?: string;
+        LastUpdateTime?: string;
+      }>;
+      NextToken?: string;
+    }>('/v2/email/suppression/addresses', {
+      method: 'GET',
+      service: 'sesv2',
+      params,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    return {
+      suppressedDestinations: (response.SuppressedDestinationSummaries || []).map(entry => ({
+        emailAddress: entry.EmailAddress || '',
+        reason: (entry.Reason as 'BOUNCE' | 'COMPLAINT') || 'BOUNCE',
+        lastUpdateTime: entry.LastUpdateTime || '',
+      })),
+      nextToken: response.NextToken,
+    };
+  }
+}

package/connectors/connect-aws/src/api/client.ts

@@ -6,6 +6,7 @@ const SERVICE_ENDPOINTS: Record<string, string> = {
   s3: 's3.{region}.amazonaws.com',
   lambda: 'lambda.{region}.amazonaws.com',
   dynamodb: 'dynamodb.{region}.amazonaws.com',
+  sesv2: 'email.{region}.amazonaws.com',
 };
 
 export interface AWSRequestOptions {